def setUp(self): os.system( "createdb peeweedbevolve_test && psql peeweedbevolve_test -c 'create extension IF NOT EXISTS hstore;' > /dev/null 2> /dev/null" ) self.db = PooledPostgresqlExtDatabase('peeweedbevolve_test') self.db.connect() peeweedbevolve.clear()
class PooledPostgreSQL(PostgreSQL): def setUp(self): os.system( "createdb peeweedbevolve_test && psql peeweedbevolve_test -c 'create extension IF NOT EXISTS hstore;' > /dev/null 2> /dev/null" ) self.db = PooledPostgresqlExtDatabase('peeweedbevolve_test') self.db.connect() peeweedbevolve.clear() def tearDown(self): self.db.manual_close() os.system('dropdb peeweedbevolve_test')
def __init__(self, logger=None): self.database = PooledPostgresqlExtDatabase( database=os.environ.get('DB_NAME'), user=os.environ.get('DB_USER'), password=os.environ.get('DB_PASSWORD'), host=os.environ.get('DB_HOST'), port=os.environ.get('DB_PORT'), max_connections=os.environ.get('DB_POOL_MAX_CONNECTIONS'), stale_timeout=os.environ.get('DB_POOL_TIMEOUT'), ) self.open_connection() self.logger = logger
def return_db(): db_config = parse_db_url(os.environ['DATABASE_URL']) if os.getenv('MIGRATION','0') =='1': from playhouse.postgres_ext import PostgresqlExtDatabase return PostgresqlExtDatabase( db_config['database'], user=db_config.get('user', None), password=db_config.get('password', None), host=db_config.get('host', 'localhost'), port=db_config.get('port', '5432') ) else: from playhouse.pool import PooledPostgresqlExtDatabase return PooledPostgresqlExtDatabase( db_config['database'], max_connections=os.getenv('DB_POOL', 5), stale_timeout=os.getenv('DB_TIMEOUT', 300), # 5 minutes. user=db_config.get('user', None), password=db_config.get('password', None), host=db_config.get('host', 'localhost'), port=db_config.get('port', '5432'))
def spawn_deferred_db(field_types=dict()): return PooledPostgresqlExtDatabase(None, max_connections=8, stale_timeout=600, register_hstore=False, autorollback=True, field_types=field_types)
def load_db_config(server_config=None): """Initialise db proxy with parameters from inifile Args: serverconfig (dict): dict of server parameters as returned by waptserver_config.load_config(ainifilename) Returns configured db : db which has been put in wapt_db proxy """ global wapt_db if server_config is None: server_config = waptserver_config.load_config() logger.info( 'Initializing a DB connection pool for db host:%s db_name:%s. Size:%s' % (server_config['db_host'], server_config['db_name'], server_config['db_max_connections'])) pgdb = PooledPostgresqlExtDatabase( database=server_config['db_name'], host=server_config['db_host'], user=server_config['db_user'], password=server_config['db_password'], max_connections=server_config['db_max_connections'], stale_timeout=server_config['db_stale_timeout'], timeout=server_config['db_connect_timeout']) wapt_db.initialize(pgdb) return pgdb
def __init__(self): super().__init__() self.db = PooledPostgresqlExtDatabase( database=os.environ.get("POSTGRES_DB_NAME", "postgres"), user=os.environ.get("POSTGRES_DB_USER", "postgres"), host=os.environ.get("POSTGRES_DB_HOST", "127.0.0.1"), port=os.environ.get("POSTGRES_DB_PORT", "5432"), # password='******' autorollback=True, max_connections=32, stale_timeout=300, # 5 minutes ) # TODO: figure this out (try with creating a base class and only assigning # _meta.database to that base class) Block._meta.database = self.db Transaction._meta.database = self.db Round._meta.database = self.db PoolTransaction._meta.database = self.db self._active_delegates = [] self.wallets = WalletManager()
def postgres(self): assert app.config['DB_ENGINE'] == 'peewee.PostgresqlDatabase' db_url = urlparse(os.environ.get('DATABASE_URL', None)) database = db_url.path[1:] return PooledPostgresqlExtDatabase( database, max_connections=1, stale_timeout=300, # 5 minutes timeout=0, # Wait forever for a connection user=db_url.username, password=db_url.password, host=db_url.hostname, port=db_url.port, register_hstore=False)
class PostgreSQLProvider(): def __init__(self, logger=None): self.database = PooledPostgresqlExtDatabase( database=os.environ.get('DB_NAME'), user=os.environ.get('DB_USER'), password=os.environ.get('DB_PASSWORD'), host=os.environ.get('DB_HOST'), port=os.environ.get('DB_PORT'), max_connections=os.environ.get('DB_POOL_MAX_CONNECTIONS'), stale_timeout=os.environ.get('DB_POOL_TIMEOUT'), ) self.open_connection() self.logger = logger def __del__(self): self.close_connection() def open_connection(self): self.database.connect(reuse_if_open=True) print('Connected to PostgreSQL database') def close_connection(self): self.database.close() print('Connection to PostgreSQL database closed')
def create_pgdb_pool(host=None, database=None, user=None, password=None, max_connections=32): return PooledPostgresqlExtDatabase( database=database, host=host, user=user, password=password, max_connections=max_connections, autorollback=True, register_hstore=False, stale_timeout=60 * 2, ) # 2 minutes
def setup(settings): """ Setup the database connection. """ connector = settings.get('db_connector') if connector == 'postgres': from playhouse.pool import PooledPostgresqlExtDatabase return PooledPostgresqlExtDatabase( settings['db_name'], user=settings['db_user'], password=settings['db_password'], host=settings['db_host'], port=settings.get('db_port'), max_connections=settings.get('db_max_conn'), stale_timeout=settings.get('db_stale_timeout'), timeout=settings.get('db_timeout'), register_hstore=False)
def database_init(app, models): logging.info("Init database connection: %s %s" % (app.config["DATABASE"], app.config["DATABASE_NAME"])) if app.config["DATABASE"] == "postgresql": from playhouse.pool import PooledPostgresqlExtDatabase database = PooledPostgresqlExtDatabase(app.config["DATABASE_NAME"], max_connections=16, stale_timeout=300, **app.config["DATABASE_AUTH"]) elif app.config["DATABASE"] == "sqlite": from playhouse.pool import PooledSqliteDatabase database = PooledSqliteDatabase(app.config["DATABASE_PATH"], pragmas={ "journal_mode": "wal", "cache_size": -1024 * 64, "foreign_keys": 1 }) else: raise RuntimeError("No database set or invalid") try: DB.initialize(database) except: logging.exception("Could not initialize database")
def database_init(app, models): logging.debug("ConnectDB: " + app.config["DATABASE"]) if app.config["DATABASE"] == "postgresql": from playhouse.pool import PooledPostgresqlExtDatabase database = PooledPostgresqlExtDatabase(app.config["DATABASE_NAME"], max_connections=16, stale_timeout=300, **app.config["DATABASE_AUTH"]) elif app.config["DATABASE"] == "sqlite": from playhouse.pool import PooledSqliteDatabase database = PooledSqliteDatabase(app.config["DATABASE_PATH"], pragmas=(("journal_mode", "wal"), ("cache_size", -1024 * 64))) else: raise RuntimeError("No database set or invalid") DB.initialize(database)
def init_database(database_name: Path, database_type="postgres", user="******", password=None, host="localhost", port=5432): assert database_type in DATABASE_TYPES if database_type == "postgres": logger.debug(f"Opening postgres database {database_name}\n" f"user={user}; host={host} port={port}") db = PooledPostgresqlExtDatabase(database_name, user=user, host=host, port=port, password=password, max_connections=MAX_PROCESSES, stale_timeout=300) elif database_type == "sqlite": db = pw.SqliteDatabase(str(database_name), pragmas=PRAGMAS) else: raise ValueError("Allowed database types: {}".format(DATABASE_TYPES)) return db
from peewee import CharField, CompositeKey, DateField, DecimalField, Model from playhouse.pool import PooledPostgresqlExtDatabase db = PooledPostgresqlExtDatabase(database='exchangerates', user='******', password='******', host='127.0.0.1', max_connections=32, stale_timeout=300) class ExchangeRates(Model): source = CharField(choices=(('ecb', 'European Central Bank'), )) date = DateField(index=True) currency = CharField() rate = DecimalField(max_digits=16, decimal_places=6) class Meta: database = db primary_key = CompositeKey('date', 'currency')
import logging import json import falcon from peewee import * from playhouse.postgres_ext import ArrayField from werkzeug.serving import run_simple from playhouse.pool import PooledPostgresqlExtDatabase import config # PG DB connection string database = PooledPostgresqlExtDatabase(None, stale_timeout=300, max_connections=20, register_hstore=False) # PeeWee models class BaseModel(Model): class Meta: database = database class User(BaseModel): username = CharField(unique=True) password = CharField() remember_token = CharField(unique=True) join_date = DateTimeField()
# How many messages consider a user rain eligible LAST_MSG_RAIN_COUNT = 5 # (Seconds) How spaced out the messages must be LAST_MSG_RAIN_DELTA = 60 # How many words messages must contain LAST_MSG_RAIN_WORDS = 3 # (Seconds) How long user must wait between tiprandom TIP_RANDOM_WAIT = 10 # (Seconds) How long user mus wait between tipfavorites TIP_FAVORITES_WAIT = 150 db = PooledPostgresqlExtDatabase(settings.database, user=settings.database_user, password=settings.database_password, host='localhost', port=5432, max_connections=16) logger = util.get_logger("db") ### User Stuff @db.connection_context() def get_accounts(): u = User.select(User.wallet_address) accts = [] for a in u: accts.append(a.wallet_address) return accts
from peewee import CharField, DateTimeField, AutoField from playhouse.postgres_ext import BinaryJSONField from playhouse.pool import PooledPostgresqlExtDatabase from actinia_gdi.resources.config import JOBTABLE from actinia_gdi.resources.logging import log log.debug("Database config loaded: " + JOBTABLE.host + ":" + JOBTABLE.port + "/" + JOBTABLE.database + "/" + JOBTABLE.schema + "." + JOBTABLE.table) """database connection""" jobdb = PooledPostgresqlExtDatabase( JOBTABLE.database, **{ 'host': JOBTABLE.host, 'port': JOBTABLE.port, 'user': JOBTABLE.user, 'password': JOBTABLE.pw, 'max_connections': 8, 'stale_timeout': 300 }) class BaseModel(Model): """Base Model for tables in jobdb """ class Meta: database = jobdb class Job(BaseModel): """Model for jobtable in database
import os import waptserver_config # You must be sure your database is an instance of PostgresqlExtDatabase in order to use the JSONField. server_config = waptserver_config.load_config() import logging logger = logging.getLogger() logger.debug('DB connection pool : %s' % server_config['db_max_connections']) wapt_db = PooledPostgresqlExtDatabase( database=server_config['db_name'], host=server_config['db_host'], user=server_config['db_user'], password=server_config['db_password'], max_connections=server_config['db_max_connections'], stale_timeout=server_config['db_stale_timeout']) class BaseModel(SignaledModel): """A base model that will use our Postgresql database""" class Meta: database = wapt_db class ServerAttribs(BaseModel): """key/value registry""" key = CharField(primary_key=True, null=False, index=True) value = BinaryJSONField(null=True)
# -*- coding:utf-8 -*- from peewee import Model from playhouse.pool import PooledPostgresqlExtDatabase from jobs.jobs_config import DB_CONFIG SUCCESS_INVOICE_STATUS = 3 trio_db = PooledPostgresqlExtDatabase(**DB_CONFIG) trio_db.commit_select = True trio_db.autorollback = True class BaseModel(Model): class Meta: database = trio_db @classmethod def get_by_id(cls, id): try: return cls.get(cls.id == id) except cls.DoesNotExist: return None
# -*- coding: utf-8 -*- from peewee import * from playhouse.migrate import * from datetime import datetime try: raise ImportError import conf import psycopg2 from playhouse.pool import PooledPostgresqlExtDatabase db = PooledPostgresqlExtDatabase(conf.dbname, max_connections=8, stale_timeout=300, user=conf.user, host=conf.host, password=conf.passwd, autorollback=True, register_hstore=False) migrator = PostgresqlMigrator(db) except ImportError: db = SqliteDatabase('db.sqlite') migrator = SqliteMigrator(db) class BaseModel(Model): class Meta: database = db class Provs(BaseModel):
# -*- coding:utf-8 -*- from peewee import (Model, TextField, DoubleField, DateTimeField, datetime as peewee_datetime) from playhouse.pool import PooledPostgresqlExtDatabase from config import db_config binance_db = PooledPostgresqlExtDatabase(**db_config) binance_db.commit_select = True binance_db.autorollback = True class BaseModel(Model): class Meta: database = binance_db class PriceLog(BaseModel): class Meta: db_table = "price_logs" created = DateTimeField(default=peewee_datetime.datetime.now) symbol = TextField() max_price = DoubleField() min_price = DoubleField() drop_percent = DoubleField() def init_db(): try:
from functools import partial from peewee import ( Check, CharField, DecimalField, ForeignKeyField, IntegerField, Model, DateField, SQL) from playhouse.pool import PooledPostgresqlExtDatabase DATABASE = PooledPostgresqlExtDatabase(None) class BaseModel(Model): class Meta: database = DATABASE legacy_table_names = False MoneyField = partial(DecimalField, decimal_places=10, max_digits=30) class RelationType(BaseModel): name = CharField(max_length=30, unique=True) class TransactionType(BaseModel):
# !/usr/bin/env python # -*- coding: utf-8 -*- from peewee import * from datetime import datetime try: import psycopg2 from playhouse.pool import PooledPostgresqlExtDatabase db = PooledPostgresqlExtDatabase("***", max_connections=8, stale_timeout=300, user="******", host='your ip', password="******", autorollback=True, register_hstore=False) except Exception, err: db = SqliteDatabase('smzdm.sqlite') class BaseModel(Model): class Meta: database = db class Smzdmarticle(BaseModel): url = CharField(max_length=300, null=False, primary_key=True,
if sys.version[0] == '2': from functools32 import wraps else: from functools import wraps from enum import Enum from peewee import DateTimeField, Model from playhouse.pool import PooledPostgresqlExtDatabase from playhouse.shortcuts import model_to_dict import settings db = PooledPostgresqlExtDatabase( database=settings.DB_NAME, host=settings.DB_HOST, user=settings.DB_USER, password=settings.DB_PASSWORD, max_connections=settings.DB_MAXCONNECTIONS, register_hstore=False, stale_timeout=60*2) # 2 minutes class BaseModel(Model): class Meta: database = db only_save_dirty = True def to_dict(self, only=None, exclude=None, recurse=False): return model_to_dict(self, only=only, exclude=exclude, recurse=recurse) class CommonModel(BaseModel):
app = Flask(__name__) api = Api(app) # settings = { # 'database': 'psqltest', # 'user': '******', # 'password': '******', # 'host': '120.53.223.160', # 'port': '7080', # } DATABASE = PooledPostgresqlExtDatabase( database='psqltest', user='******', password='******', host='120.53.223.160', port='7080', ) class BaseModel(peewee.Model): class Meta: database = DATABASE # def create_tables(): class PostModel(BaseModel): id = peewee.PrimaryKeyField(primary_key=True, )
from typing import Dict, Union import os from fastapi import FastAPI, Body from pydantic import BaseModel from peewee import ( Model, IntegerField, TextField, CompositeKey, IntegrityError ) from playhouse.postgres_ext import JSONField from playhouse.pool import PooledPostgresqlExtDatabase DB = PooledPostgresqlExtDatabase( database=os.environ['DATABASE'], user=os.environ['USER'], password=os.environ['PASSWORD'], host=os.environ['HOST'], max_connections=19, stale_timeout=10, ) class Submission_api(BaseModel): learning_unit: Union[str, int] slack_id: str = Body(..., min_length=5, max_length=20) grade: int metadata: Dict[str, str] class Submission_db(Model): learning_unit = IntegerField() slack_id = TextField()
from playhouse.pool import PooledPostgresqlExtDatabase from peewee import Model from database import * # PooledPostgresqlExtDatabase. db = PooledPostgresqlExtDatabase(PG_DB, user=PG_USER, password=PG_PASSWORD, host=PG_HOST, port=PG_PORT, max_connections=1000, stale_timeout=5, register_hstore=False) class DatabaseModel(Model): class Meta: database = db
4: "RUNTIME_ERROR", 5: "SYSTEM_ERROR", 6: "PENDING", 7: "JUDGING", 8: "PARTIALLY_ACCEPTED", } with open("./conf.d/database.json", "r") as f: setting = json.load(f) # with open("./database.json", "r") as f: # setting = json.load(f) database_name = "Judee_dev" # database_name = "postgres" db = PooledPostgresqlExtDatabase(database_name, **setting) class BaseModel(Model): class Meta: database = db class submission(BaseModel): ID = IntegerField(primary_key=True) create_time = DateTimeField() code = TextField() result = IntegerField() info = BinaryJSONField() language = CharField(max_length=15) ip = TextField()
def __init__(self, threadID, name, counter): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.counter = counter def run(self): #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数 print("Starting " + self.name) print_time(self.name, self.counter) print("Exiting " + self.name) db = PooledPostgresqlExtDatabase( 'adminlq', max_connections=2, stale_timeout=300, # 5 minutes. timeout=0, password='******', host='127.0.0.1', user='******') def print_time(threadName, delay): db.connect() count = 0 while count < 1: time.sleep(delay) count += 1 print('%s: %s' % (threadName, time.ctime(time.time()))) db.close()
from itsdangerous import (TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired) from peewee import (Model, CharField, TextField, ForeignKeyField, IntegerField, SmallIntegerField, DateTimeField, DoubleField, BooleanField, DecimalField, datetime as peewee_datetime, fn) from playhouse.pool import PooledPostgresqlExtDatabase from flask import Markup, request, g from config import DB_CONFIG, SECRET_KEY, MEDIA_ROOT, MEDIA_URL from zippy_gig.constants import AccountType from geopy.geocoders import Nominatim db = PooledPostgresqlExtDatabase(**DB_CONFIG) db.commit_select = True db.autorollback = True import zippy_gig.sql_additional peewee_now = peewee_datetime.datetime.now class _Model(Model): class Meta: database = db class Photo(_Model):
def __call__(self): return PooledPostgresqlExtDatabase(**self.kwargs, max_connections=30, stale_timeout=300)