def get_datebase(dbname='SpiderMan'): return peewee_async.PooledMySQLDatabase( dbname, host=SpiderManConf.MYSQLHOST, port=3306, user=SpiderManConf.MYSQLUSER, password=SpiderManConf.MYSQLPASSWORD, charset='utf8')
def __init__(self, db=None): if not db: db = CONFIG.get('env', {}).get('env', None) if db == 'root': self.db = CONFIG.get('db_root') elif db == 'test': self.db = CONFIG.get('db_test') elif db == 'analysis': self.db = CONFIG.get('db_analysis') else: self.db = CONFIG.get('db') self.redis_config = CONFIG.get('redis') logger.debug('db setting: ' + str(self.db)) self.database = peewee.MySQLDatabase(self.db.get('database'), host=self.db.get('host'), port=self.db.get('port', 3306), user=self.db.get('user'), passwd=self.db.get('passwd'), charset=self.db.get('charset')) self.database_async = peewee_async.MySQLDatabase( self.db.get('database'), host=self.db.get('host'), port=self.db.get('port', 3306), user=self.db.get('user'), password=self.db.get('passwd'), charset=self.db.get('charset')) self.pool = PooledMySQLDatabase(self.db.get('database'), host=self.db.get('host'), port=self.db.get('port', 3306), user=self.db.get('user'), passwd=self.db.get('passwd'), max_connections=self.db.get( 'max_connections', 10)) self.pool_async = peewee_async.PooledMySQLDatabase( self.db.get('database'), host=self.db.get('host'), port=self.db.get('port', 3306), user=self.db.get('user'), password=self.db.get('passwd'), charset=self.db.get('charset'), max_connections=self.db.get('max_connections', 10)) # redis_pool_async = aioredis.create_redis_pool( # (config['redis']['host'], config['redis']['port']), # minsize=config['redis']['minsize'], # maxsize=config['redis']['maxsize'], # loop=asyncio.get_event_loop() # ) logger.debug('redis setting: ' + str(self.redis_config)) self.redis = redis.ConnectionPool( host=self.redis_config['host'], port=self.redis_config['port'], password=self.redis_config['password'], db=self.redis_config['db'], max_connections=self.redis_config['maxsize'], decode_responses=True)
def create_pool(self): _mysql_pools = {} mysql_conf = Config().mysql for alias, cnf in mysql_conf.items(): db = cnf.pop('db') is_async = cnf.pop('is_async', False) db_conn = peewee_async.PooledMySQLDatabase(db, **cnf) # 是否异步操作 if not bool(is_async): db_conn.set_allow_sync(False) manager = peewee_async.Manager(db_conn) # 每个链接对象有两个属性:.db_conn .manager _mysql_pools[alias] = dict2obj( dict(db_conn=db_conn, manager=manager)) self.mysql_pools = _mysql_pools
def __new__(cls, *args, **kwargs): if not hasattr(cls, "_instance"): db_dic = dict( host=options['SQL_HOST'], port=options['SQL_POST'], user=options['SQL_USER'], password=options['SQL_PWD'], max_connections=options['SQL_MAX_CONN'], database=options['SQL_DB_NAME'], ) cls.conn = peewee_async.PooledMySQLDatabase(**db_dic, charset='utf8mb4') cls.manager = peewee_async.Manager(cls.conn) cls._instance = super().__new__(cls) return cls._instance
import peewee_async import settings database = peewee_async.PooledMySQLDatabase(settings.mysql.DATABASE, host=settings.mysql.ENDPOINT, port=settings.mysql.PORT, user=settings.mysql.USER, password=settings.mysql.PASSWORD) manager = peewee_async.Manager(database)
import peewee_async db = { 'user': '******', 'host': '192.168.88.157', 'password': '******', 'port': 3306, 'max_connections': 10 } news_db = peewee_async.PooledMySQLDatabase('wordpress', **db) objects = peewee_async.Manager(news_db) # 数据库常量 # NEWS_TECHNOLOGY, NEWS_STAR, NEWS_SPORTS, NEWS_ # NEWS_TYPE = ( # (, ''), # (, ''), # (, ''), # (, ''), # )
# -*- coding: utf-8 -*- import peewee as models import peewee_async database = peewee_async.PooledMySQLDatabase('blog', max_connections=10, **{ 'charset': 'utf8', 'use_unicode': True, 'host': '127.0.0.1', 'user': '******', 'password': '******' }) Objects = peewee_async.Manager(database) __all__ = [ "Objects", "BaseModel", "Permission", "Group", "Author", "Category", "Blog", "Tag", "Blogtag", "Skynet", "Message", "Visitor", "Comment", "Reply", "Todolist" ] class UnknownField(object): def __init__(self, *_, **__): pass class BaseModel(models.Model): class Meta:
from tornado import ioloop import wtforms_json import peewee_async import aioredis from utils.genCodePic import ValidCodeImg from settings import settings from elasticsearch import AsyncElasticsearch from functools import partial ''' 创建各式微服务 ''' es = AsyncElasticsearch(hosts=settings['es']['host']) db = peewee_async.PooledMySQLDatabase(**settings['mysql']) wtforms_json.init() db.set_allow_sync(False) objects = peewee_async.Manager(db) coder = ValidCodeImg() redis = ioloop.IOLoop.current().run_sync(func=partial( aioredis.create_redis_pool, 'redis://' + settings['redis']['host'] + f':{settings["redis"]["port"]}'))
import os import peewee_async BASE_DIR = os.getcwd() # peewee_async 连接池对象 # peewee_async 连接池 database = peewee_async.PooledMySQLDatabase('aiohttp_data', **{ 'user': '******', 'password': '******', 'host': '127.0.0.1', 'port': 3306, }) objects = peewee_async.Manager(database) # objects.database.allow_sync = False
import peewee_async from app.core import config class AsyncMySQLConnection(peewee_async.AsyncMySQLConnection): """Asynchronous database connection pool. """ def __init__(self, *, database=None, loop=None, timeout=None, **kwargs): self.pool = None self.loop = loop self.database = database self.timeout = timeout kwargs.setdefault('pool_recycle', 360) self.connect_params = kwargs db = peewee_async.PooledMySQLDatabase( config.MYSQL_DB, host=config.MYSQL_HOST, user=config.MYSQL_USER, password=config.MYSQL_PASSWORD, charset='utf8mb4', async_conn=AsyncMySQLConnection, ) db.set_allow_sync(False) objects = peewee_async.Manager(db)
import peewee import peewee_async import tornado.web from tornado import httpserver database = peewee_async.PooledMySQLDatabase('alexdb', host='127.0.0.1', port=3306, user='******', password='******', charset='utf8') # Define model class TestNameModel(peewee.Model): name = peewee.CharField() class Meta: database = database def __str__(self): return self.name # Create table, add some instances TestNameModel.create_table(True) TestNameModel.get_or_create(id=1, defaults={'name': "试试中文问题"}) TestNameModel.get_or_create(id=2, defaults={'name': "TestNameModel id=2"}) TestNameModel.get_or_create(id=3, defaults={'name': "TestNameModel id=3"}) database.close()
import os import peewee_async MYSQL_USER = '******' MYSQL_PASSWORD = '******' MYSQL_DATABASE = 'test_db' MYSQL_HOST = os.getenv('MYSQL_HOST', '127.0.0.1') MYSQL_PORT = os.getenv('MYSQL_PORT', 3306) if not MYSQL_USER or not MYSQL_PASSWORD: raise RuntimeError('mysql credentials not configured') cdb = peewee_async.PooledMySQLDatabase( MYSQL_DATABASE, user=MYSQL_USER, password=MYSQL_PASSWORD, host=MYSQL_HOST, port=MYSQL_PORT, charset='utf8', max_connections=5 )
import peewee import peewee_async import tornado.web from tornado import httpserver database = peewee_async.PooledMySQLDatabase('alexdb', host='127.0.0.1', port=3306, user='******', password='') # Define model class TestNameModel(peewee.Model): name = peewee.CharField() class Meta: database = database def __str__(self): return self.name # Create table, add some instances TestNameModel.create_table(True) TestNameModel.get_or_create(id=1, defaults={'name': "TestNameModel id=1"}) TestNameModel.get_or_create(id=2, defaults={'name': "TestNameModel id=2"}) TestNameModel.get_or_create(id=3, defaults={'name': "TestNameModel id=3"}) database.close()
from collections import Iterable import peewee_async from playhouse.shortcuts import model_to_dict from blogger_service import SERVICE_NAME from chili.gateway import BaseConfig database = BaseConfig(SERVICE_NAME).get_db_config() db_name = database.pop('db_name') blog_db = peewee_async.PooledMySQLDatabase(db_name, **database) objects = peewee_async.Manager(blog_db) def models_to_dict(models, *args, **kwargs): """ 批量序列化 """ if not isinstance(models, Iterable): return [] return [ model_to_dict(model, *args, **kwargs) for model in models ]
from datetime import datetime import peewee import peewee_async config = { 'host': 'localhost', 'port': 33006, 'database': 'app', 'user': '******', 'password': '******' } database = peewee_async.PooledMySQLDatabase(**config) # database_proxy = peewee.DatabaseProxy() # database_proxy.initialize(database) objects = peewee_async.Manager(database=database) class BaseModel(peewee.Model): class Meta: database = database class Tags(BaseModel): name = peewee.CharField(max_length=50) class Meta: database = database
import peewee_async from peewee import * database = peewee_async.PooledMySQLDatabase('nero', host='192.168.1.5', port=3306, user='******', password='******', charset='utf8') class BaseModel(Model): class Meta: database = database class GameMediatag(BaseModel): cover = CharField() groupid = IntegerField() name = CharField() order = IntegerField() ref_count = IntegerField() typeid = IntegerField() usetype = IntegerField() class Meta: db_table = 'game_mediatag' class GameQuinhighcategory(BaseModel): created_time = DateTimeField()
def __new__(cls, table_prefix=None, use_async=True, create_table=True, multiplexing_conn=False): """ 初始化数据库连接,构造peewee model实例 Parameters: table_prefix - 表名前缀,由扫描目标的 host + "_" + str(port) 组成 use_async - 是否开启数据库连接的异步查询功能,默认为True create_table - 数据表不存在时是否创建,默认为True multiplexing_conn - 是否复用连接,为True时,相同的Model的实例会使用同一个连接,默认为False Raises: create_table为Fasle且目标数据表不存在时,引发exceptions.TableNotExist """ try: cls.connect_para = { "database": Config().get_config("database.db_name"), "host": Config().get_config("database.host"), "port": Config().get_config("database.port"), "user": Config().get_config("database.username"), "password": Config().get_config("database.password"), "charset": "utf8mb4" } if not hasattr(cls, "db_created"): conn = pymysql.connect( host=Config().get_config("database.host"), port=Config().get_config("database.port"), user=Config().get_config("database.username"), passwd=Config().get_config("database.password"), charset="utf8mb4") cursor = conn.cursor() cursor._defer_warnings = True sql = "CREATE DATABASE IF NOT EXISTS {dbname} default charset {charset} COLLATE {charset}_general_ci;".format( dbname=Config().get_config("database.db_name"), charset="utf8mb4") cursor.execute(sql) cursor.close() conn.commit() conn.close() cls.db_created = True if multiplexing_conn is True: with BaseModel.mul_lock: if not hasattr(BaseModel, "mul_database"): BaseModel.mul_database = peewee_async.MySQLDatabase( **cls.connect_para) BaseModel.mul_database.connect() BaseModel.mul_database_timeout = time.time() + 60 elif time.time() > BaseModel.mul_database_timeout: BaseModel.mul_database.close() BaseModel.mul_database = peewee_async.MySQLDatabase( **cls.connect_para) BaseModel.mul_database.connect() BaseModel.mul_database_timeout = time.time() + 60 elif isinstance(multiplexing_conn, int): with BaseModel.mul_lock: if not hasattr(BaseModel, "mul_database"): BaseModel.mul_database = peewee_async.PooledMySQLDatabase( **cls.connect_para, max_connections=multiplexing_conn) except Exception as e: cls._handle_exception("Mysql Connection Fail!", e) instance = super(BaseModel, cls).__new__(cls) return instance
import peewee_async from peewee import * from conf.op_conf import get_conf import model db = peewee_async.PooledMySQLDatabase(database=get_conf()['db'], user=get_conf()['username'], password=get_conf()['password'], host=get_conf()['host'], port=get_conf()['port']) objs = peewee_async.Manager(db) db.set_allow_sync(True) class BaseModel(Model): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.trans = db.atomic_async # 将事务改成atomic_async self.objs = peewee_async.Manager(db) # 添加一个Manager类 # add_time = DateTimeField(null=True, verbose_name="添加时间") class Meta: database = db def create_table(): db.create_tables([model.index.Server, model.index.User])