cloudoll 2.0.24__tar.gz → 2.1.0__tar.gz

{cloudoll-2.0.24 → cloudoll-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudoll
-Version: 2.0.24
+Version: 2.1.0
 Summary: 辅助快速创建可分布的微服务。
 Home-page: https://gitee.com/chuchur/cloudoll-py
 Author: chuchur

cloudoll-2.1.0/cloudoll/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.0"

cloudoll-2.1.0/cloudoll/orm/base.py

@@ -0,0 +1,130 @@
+from .model import Model
+from enum import Enum
+import re
+
+
+class QueryTypes(Enum):
+    ALL = 1
+    ONE = 2
+    MANY = 3
+    COUNT = 4
+    CREATE = 5
+    UPDATE = 6
+    DELETE = 7
+
+
+class MeteBase:
+    def use(self, model: Model):
+        model.__pool__ = self.pool
+        return model
+
+    async def __aexit__(self):
+        await self.close()
+
+    async def close(self):
+        if self.pool:
+            self.pool.close()
+            await self.pool.wait_closed()
+
+    # async def begin_transaction(self):
+    #     conn = await self._set_conn()
+    #     await conn.begin()
+    #     return conn
+
+    # async def begin_transaction_scope(self, fun):
+    #     conn = await self._set_conn()
+    #     await conn.begin()
+    #     cursor = None
+    #     if isfunction(fun):
+    #         try:
+    #             cursor = await conn.cursor()
+    #             await fun(cursor)
+    #             await conn.commit()
+    #         except Exception as e:
+    #             error(e)
+    #             await conn.rollback()
+    #         finally:
+    #             if cursor:
+    #                 await cursor.close()
+    #         self.pool.release(conn)
+
+    # async def release(self):
+    #     cursor = self.cursor
+    #     if cursor:
+    #         await cursor.close()
+    #         # self.conn.close()
+    #     if self.pool:
+    #         self.pool.release(self.conn)
+
+    async def query(self, sql, params=None, query_type: QueryTypes = 2, size: int = 10):
+        sql = sql.replace("?", "%s")
+        # if params:
+        #     params = [
+        #         (
+        #             re.sub(r"(%{2,})", "%", x.replace("'", "\\'"))
+        #             if isinstance(x, str)
+        #             else x
+        #         )
+        #         for x in params
+        #     ]
+        print("sql", sql, params)
+        if not self.pool:
+            raise ValueError("must be create_engine first.")
+        async with self.pool.acquire() as conn:
+            async with conn.cursor() as cursor:
+                # current_cursor = getattr(cur, 'lastrowid', None)
+                # conn = await self.pool.acquire()
+                # cursor = await conn.cursor()
+                # try:
+                await cursor.execute(sql, params)
+
+                # if query_type.value > 4:
+                await conn.commit()
+
+                if query_type == QueryTypes.ALL:
+                    return await cursor.fetchall()
+                elif query_type == QueryTypes.ONE:
+                    return await cursor.fetchone()
+                elif query_type == QueryTypes.MANY:
+                    return await cursor.fetchmany(size)
+                elif query_type == QueryTypes.COUNT:
+                    rs = await cursor.fetchone()
+                    value = 0
+                    for r in rs:
+                        value = rs[r]
+                    return value
+                elif query_type == QueryTypes.CREATE:
+                    result = cursor.rowcount > 0
+                    id = cursor.lastrowid
+                    return result, id
+                elif query_type == QueryTypes.UPDATE:
+                    return cursor.rowcount > 0
+                elif query_type == QueryTypes.DELETE:
+                    return cursor.rowcount > 0
+                # except Exception as e:
+                # error(e)
+                # pass
+                # self.cursor = cursor
+                # self.conn = conn
+                # return self
+
+    async def all(self, sql, params):
+        return await self.query(sql, params, QueryTypes.ALL)
+
+    async def one(self, sql, params):
+        return await self.query(sql, params, QueryTypes.ONE)
+
+    async def many(self, sql, params, size: int):
+        return await self.query(sql, params, QueryTypes.MANY, size)
+
+    async def count(self, sql, params):
+        return await self.query(sql, params, QueryTypes.COUNT)
+
+    async def update(self, sql, params):
+        return await self.query(sql, params, QueryTypes.UPDATE)
+
+    async def delete(self, sql, params):
+        return await self.query(sql, params, QueryTypes.DELETE)
+
+    async def create(self, sql, params):
+        return await self.query(sql, params, QueryTypes.CREATE)

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll/orm/field.py

@@ -7,45 +7,49 @@ class objdict(dict):
 
 
 OP = objdict(
-    AND='AND',
-    OR='OR',
-    ADD='+',
-    SUB='-',
-    MUL='*',
-    DIV='/',
-    BIN_AND='&',
-    BIN_OR='|',
-    XOR='#',
-    MOD='%',
-    EQ='=',
-    LT='<',
-    LTE='<=',
-    GT='>',
-    GTE='>=',
-    NE='!=',
-    IN='IN',
-    NOT_IN='NOT IN',
-    IS='IS',
-    DESC='DESC',
-    ASC='ASC',
-    AVG='AVG',
-    AS='AS',
-    SUM='SUM',
-    COUNT='COUNT',
-    IS_NOT='IS NOT',
-    IS_NOT_NULL='IS NOT NULL',
-    IS_NULL='IS NULL',
-    LIKE='LIKE',
-    NOT_LIKE='NOT LIKE',
-    ILIKE='ILIKE',
-    BETWEEN='BETWEEN',
-    CONTAINS='CONTAINS',
-    NOT_BETWEEN='NOT BETWEEN',
-    REGEXP='REGEXP',
-    IREGEXP='IREGEXP',
-    DISTINCT='DISTINCT',
-    CONCAT='||',
-    BITWISE_NEGATION='~')
+    AND="AND",
+    OR="OR",
+    ADD="+",
+    SUB="-",
+    MUL="*",
+    DIV="/",
+    BIN_AND="&",
+    BIN_OR="|",
+    XOR="#",
+    MOD="%",
+    EQ="=",
+    LT="<",
+    LTE="<=",
+    GT=">",
+    GTE=">=",
+    NE="!=",
+    IN="IN",
+    NOT_IN="NOT IN",
+    IS="IS",
+    DESC="DESC",
+    ASC="ASC",
+    AVG="AVG",
+    AS="AS",
+    SUM="SUM",
+    DATE_FORMAT="DATE_FORMAT",
+    JSON_CONTAINS_OBJECT="JSON_CONTAINS_OBJECT",
+    JSON_CONTAINS_ARRAY="JSON_CONTAINS_ARRAY",
+    COUNT="COUNT",
+    IS_NOT="IS NOT",
+    IS_NOT_NULL="IS NOT NULL",
+    IS_NULL="IS NULL",
+    LIKE="LIKE",
+    NOT_LIKE="NOT LIKE",
+    ILIKE="ILIKE",
+    BETWEEN="BETWEEN",
+    CONTAINS="CONTAINS",
+    NOT_BETWEEN="NOT BETWEEN",
+    REGEXP="REGEXP",
+    IREGEXP="IREGEXP",
+    DISTINCT="DISTINCT",
+    CONCAT="||",
+    BITWISE_NEGATION="~",
+)
 
 
 class FieldBase:
@@ -54,6 +58,7 @@ class FieldBase:
             if inverse:
                 return Expression(rhs, op, self)
             return Expression(self, op, rhs)
+
         return inner
 
     def __eq__(self, rhs):
@@ -73,7 +78,7 @@ class FieldBase:
     __add__ = _op(OP.ADD)  # +
     __radd__ = _op(OP.ADD, True)  # +=
     __sub__ = _op(OP.SUB)  # -
-    __sub__ = _op(OP.SUB, True)  # -=
+    __rsub__ = _op(OP.SUB, True)  # -=
     __mul__ = _op(OP.MUL)  # *
     __rmul__ = _op(OP.MUL, True)  # *=
     __div__ = _op(OP.DIV)  # /
@@ -103,6 +108,15 @@ class FieldBase:
     def avg(self):
         return Function(self, OP.AVG)
 
+    def date_format(self, args):
+        return Function(self, OP.DATE_FORMAT, args)
+
+    def json_contains_object(self, key, value):
+        return Function(self, OP.JSON_CONTAINS_OBJECT, (key, value))
+
+    def json_contains_array(self, args):
+        return Function(self, OP.JSON_CONTAINS_ARRAY, args)
+
     def contains(self, args):
         return Function(self, OP.CONTAINS, args)
         # return AO(f"contains({self.full_name},?)", args)
@@ -137,16 +151,16 @@ class ExpList(FieldBase):
         q = []
         if isinstance(lpt, Exception):
             _q, _p = lpt.sql()
-            q = q+_q
-            p = p+_p
+            q = q + _q
+            p = p + _p
         else:
             q.append("?")
             p.append(lpt)
         q.append(f" {self.op} ")
         if isinstance(rpt, Exception):
             _q, _p = lpt.sql()
-            q = q+_q
-            p = p+_p
+            q = q + _q
+            p = p + _p
         else:
             q.append("?")
             p.append(lpt)
@@ -162,8 +176,25 @@ class Function(FieldBase):
         self.rpt = rpt
 
     def sql(self):
+        op = self.op
+        col_name = self.col.full_name
+        is_field = isinstance(self.rpt, Field)
         # todo:
-        return f"{self.op}({self.col.full_name} {','+str(self.rpt) if self.rpt else ''})"
+        if op == OP.DATE_FORMAT:
+            return f"{op}({col_name},?)", [self.rpt]
+        elif op == OP.JSON_CONTAINS_OBJECT:
+            _k, _v = self.rpt
+            key = _k.full_name if isinstance(_k, Field) else f"'{_k}'"
+            return f"json_contains({col_name},json_object({key},?))", [_v]
+        elif op == OP.JSON_CONTAINS_ARRAY:
+            if is_field:
+                return (
+                    f"json_contains({col_name},json_array({self.rpt.full_name}))",
+                    None,
+                )
+            return f"json_contains({col_name},json_array(?))", [self.rpt]
+        elif op == OP.COUNT:
+            return f"COUNT({col_name})", None
 
 
 class Expression(FieldBase):
@@ -171,32 +202,75 @@ class Expression(FieldBase):
         self.lhs = lhs
         self.op = op
         self.rhs = rhs
+        # self.__value = ""
+        # if op in "+-*/|&~" and lhs._value:
+        #     cal = f"{lhs._value}{op}"
+        #     if isinstance(rhs, FieldBase):
+        #         self.__value = str(eval(f"{cal}{rhs._value}"))
+        #     else:
+        #         self.__value = str(eval(f"{cal}{rhs}"))
 
     def sql(self):
         l = self.lhs
         r = self.rhs
+        is_fun = isinstance(l, Function)
         p = []
-        q = ["("]
+        q = []
+        if not is_fun:
+            q.append("(")
         if isinstance(l, Field):
             q.append(l.full_name)
         elif isinstance(l, Expression):
             _q, _p = l.sql()
             q.append(_q)
-            p = p+_p
+            p = p + _p
+        elif is_fun:
+            _q, _p = l.sql()
+            q.append(_q)
+            if _p:
+                p = p + _p
+            # return l.sql()
+
         q.append(f" {self.op} ")
 
         if isinstance(r, Field):
-            q.append(r.full_name)
+            if r._value is not None:
+                # _value = r._value if r._value is not None else r.full_name
+                q.append("?")
+                p.append(r._value)
+            else:
+                q.append(r.full_name)
+            # q.append(str(r._value) if r._value is not None else r.full_name)
         elif isinstance(r, FieldBase):
             _q, _p = r.sql()
             q.append(_q)
-            p = p+_p
-        else:
-            q.append('?')
+            p = p + _p
+        elif self.op == OP.AS:
+            # is_fun or (isinstance(r, str) and (self.op == OP.AND or self.op == OP.OR)):
+            q.append(r)
+        elif r is not None:
+            q.append("?")
             p.append(r)
-        q.append(')')
+        if not is_fun:
+            q.append(")")
+        # q.append(")")
+        q = [str(num) for num in q]
+        # print("".join(q))
         return "".join(q), p
-        # return f"({l.full_name if isinstance(l,Field) else l.sql()} {self.op} {r.full_name if isinstance(r,Field) else (r.sql() if isinstance(r,FieldBase) else str(r))})"
+
+    # def __str__(self):
+    #     return self.__value
+    #     cal = f"{self.lhs._value}{self.op}"
+    #     if isinstance(self.rhs, FieldBase):
+    #         return str(eval(f"{cal}{self.rhs._value}"))
+    #     return str(eval(f"{cal}{self.rhs}"))
+
+    def __repr__(self):
+        # return self.__value
+        cal = f"{self.lhs.get_value()}{self.op}"
+        if isinstance(self.rhs, FieldBase):
+            return str(eval(f"{cal}{self.rhs.get_value()}"))
+        return str(eval(f"{cal}{self.rhs}"))
 
 
 class Field(FieldBase):

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll/orm/model.py

@@ -62,6 +62,8 @@ class Model(dict, metaclass=ModelMetaclass):
         for k, v in kw.items():
             f = getattr(self, k, None)
             if isinstance(f, Field):
+                if v is None:
+                    v = f.default
                 self.set_value(k, v)
 
         super(Model, self).__init__(self, **kw)
@@ -90,6 +92,7 @@ class Model(dict, metaclass=ModelMetaclass):
         # self[key] = value
         self.set_value(key, value)
 
+    # @classmethod
     def get_value(self, key):
         return getattr(self, key, None).get_value()
 
@@ -116,7 +119,7 @@ class Model(dict, metaclass=ModelMetaclass):
     @classmethod
     def use(self, pool=None):
         # model = self()
-        self.__pool__ = pool
+        self.db = pool
         # self['__pool__'] = pool
         return self
 
@@ -127,14 +130,24 @@ class Model(dict, metaclass=ModelMetaclass):
             if isinstance(col, Field):
                 cols.append(col.full_name)
             elif isinstance(col, Function):
-                cols.append(col.sql())
+                q, p = col.sql()
+                cols.append(q)
+            elif isinstance(col, Expression):
+                q, p = col.sql()
+                cols.append(q)
+                self._merge_params(self, p)
         self.__cols__ = ",".join(cols) if len(cols) else "*"
         return self
 
     @classmethod
     def join(self, table, *exp):
-        exp = reduce(operator.and_, exp).sql()
-        join = f"JOIN {table.__table__} ON {exp}"
+        ex = reduce(operator.and_, exp)
+        if isinstance(ex, Expression) or isinstance(ex, Function):
+            exp, q = ex.sql()
+            self._merge_params(self, q)
+        else:
+            exp = ex
+        join = f"{table.__table__} ON " + exp
         if self.__join__ is None:
             self.__join__ = join
         else:
@@ -159,7 +172,10 @@ class Model(dict, metaclass=ModelMetaclass):
     def order_by(self, *args):
         by = []
         for f in args:
-            by.append(f"{f.lhs.full_name} {f.op}")
+            if isinstance(f, str):
+                by.append(f)
+            else:
+                by.append(f"{f.lhs.full_name} {f.op}")
         if self.__order_by__ is not None:
             by = self.__order_by__ + by
         self.__order_by__ = by
@@ -181,7 +197,7 @@ class Model(dict, metaclass=ModelMetaclass):
         md = None
         if args is None or not args:
             for f in self.__fields__:
-                data[f] = self.get_value(f)
+                data[f] = self.get_value(self, f)
         else:
             for item in args:
                 md = item
@@ -195,24 +211,29 @@ class Model(dict, metaclass=ModelMetaclass):
             params.append(v)
         return ",".join(keys), params, md
 
+    def _merge_params(self, p):
+        if p is not None:
+            if self.__params__ is not None:
+                p = self.__params__ + p
+            self.__params__ = p
+
     @classmethod
     def _literal(self, op, exp):
         if exp is not None:
             if isinstance(exp, list):
                 return f'{op} {",".join(exp)}'
-            elif isinstance(exp, Expression):
+            elif isinstance(exp, Expression) or isinstance(exp, Function):
                 q, p = exp.sql()
-                if self.__params__ is not None:
-                    p = self.__params__ + p
-                self.__params__ = p
+                self._merge_params(self, p)
                 return f"{op} {q}"
             else:
-                return exp
+                # return exp
+                return f"{op} {exp}"
         return ""
 
     @classmethod
     def sql(self):
-        JOIN = self._literal("JOIN", self.__join__)
+        JOIN = self._literal("LEFT JOIN", self.__join__)
         WHERE = self._literal("WHERE", self.__where__)
         GROUPBY = self._literal("GROUP BY", self.__group_by__)
         HAVING = self._literal("HAVING", self.__having__)
@@ -224,43 +245,36 @@ class Model(dict, metaclass=ModelMetaclass):
         # return self._build_sql(self)
 
     @classmethod
-    def test(self):
-        return self.sql()
+    def limit(self, limit: int):
+        self.__limit__ = f"{limit}"
+        return self
 
     @classmethod
-    async def __query(self, sql, args):
-        # print(sql,  args)
-        try:
-            rs = await self.__pool__.query(sql, args)
-        finally:
-            self._clear()
-        return rs
+    def offset(self, offset: int):
+        self.__offset__ = f"{offset}"
+        return self
+
+    @classmethod
+    def test(self):
+        return self.sql()
 
     @classmethod
     async def one(self):
-        sql = self.sql()
         self.limit(1)
+        sql = self.sql()
         args = self.__params__
-        rs = await self.__query(sql, args)
-        item = await rs.one()
-        return self(**item)
-
-    @classmethod
-    def limit(self, limit: int):
-        self.__limit__ = f"LIMIT {limit}"
-        return self
-
-    @classmethod
-    def offset(self, offset: int):
-        self.__offset__ = f"OFFSET {offset}"
-        return self
+        self._clear()
+        rs = await self.db.one(sql, args)
+        if rs:
+            return self(**rs)
+        return None
 
     @classmethod
     async def all(self):
         sql = self.sql()
         args = self.__params__
-        rs = await self.__query(sql, args)
-        return await rs.all()
+        self._clear()
+        return await self.db.all(sql, args)
 
     @classmethod
     async def update(self, *args) -> bool:
@@ -274,7 +288,7 @@ class Model(dict, metaclass=ModelMetaclass):
 
         sql = f"update `{table}` set {keys}"
 
-        pk, pkv = self.get_primary()
+        pk, pkv = self.get_primary(self)
         if where is not None:
             sql += f' where {" and ".join(f for f in where)}'
             params += self.__params__
@@ -284,10 +298,8 @@ class Model(dict, metaclass=ModelMetaclass):
         else:
             raise "Need where or primary key"
 
-        rs = await self.__query(sql, params)
-        result = rs.cursor.rowcount > 0
-        await rs.release()
-        return result
+        self._clear()
+        return await self.db.update(sql, params)
 
     @classmethod
     async def delete(self) -> bool:
@@ -299,7 +311,7 @@ class Model(dict, metaclass=ModelMetaclass):
         args = self.__params__
         sql = f"delete from `{table}`"
 
-        pk, pkv = self.get_primary()
+        pk, pkv = self.get_primary(self)
         if where is not None:
             sql += f' where {" and ".join(f for f in where)}'
         elif pkv is not None:
@@ -307,29 +319,23 @@ class Model(dict, metaclass=ModelMetaclass):
             args = [pkv]
         else:
             raise "need where or primary"
-        # return await sa.query(sql, args)
-        rs = await self.__query(sql, args)
-        result = rs.cursor.rowcount > 0
-        await rs.release()
-        return result
+        self._clear()
+        return await self.db.delete(sql, args)
 
     @classmethod
     async def insert(self, *args):
         table = self.__table__
         keys, params, md = self._get_key_args(args)
         sql = f"insert into `{table}` set {keys}"
-        rs = await self.__query(sql, params)
-        result = rs.cursor.rowcount > 0
-        id = rs.cursor.lastrowid
-        await rs.release()
-        return result, id
+        self._clear()
+        return await self.db.create(sql, params)
 
     @classmethod
     async def count(self):
         sql = self.sql()
         args = self.__params__
-        rs = await self.__query(sql, args)
-        return await rs.count()
+        self._clear()
+        return await self.db.count(sql, args)
 
 
 class Models(object):
@@ -378,7 +384,9 @@ class Models(object):
             )
 
     class BooleanField(Field):
-        def __init__(self, name=None, default=False, not_null=False, comment=None, unsigned=False):
+        def __init__(
+            self, name=None, default=False, not_null=False, comment=None, unsigned=False
+        ):
             super().__init__(
                 name,
                 "boolean",

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll/orm/mysql.py

@@ -26,9 +26,11 @@ __author__ = "chuchur/chuchur.com"
 
 from aiomysql import create_pool, DictCursor
 from aiomysql.pool import Pool
-from aiomysql.cursors import Cursor
-from aiomysql.connection import Connection
-from cloudoll.logging import error,  warning
+
+# from aiomysql.cursors import Cursor
+# from aiomysql.connection import Connection
+from cloudoll.logging import error, warning
+
 # from inspect import isclass, isfunction
 from .base import MeteBase
 
@@ -50,9 +52,9 @@ class AttrDictCursor(DictCursor):
 class Mysql(MeteBase):
     def __init__(self):
         self.pool: Pool = None
-        self.cursor: Cursor = None
-        self.conn: Connection = None
-        self.__MODELS__ = []
+        # self.cursor: Cursor = None
+        # self.conn: Connection = None
+        # self.__MODELS__ = []
 
     async def create_engine(self, loop=None, **kw):
         try:
@@ -64,7 +66,7 @@ class Mysql(MeteBase):
                 db=kw.get("db"),
                 echo=kw.get("echo", False),
                 charset=kw.get("charset", "utf8"),
-                autocommit=kw.get("autocommit", False),
+                autocommit=False,  # kw.get("autocommit", False),
                 maxsize=kw.get("maxsize", 10),
                 minsize=kw.get("pool_size", 5),
                 cursorclass=AttrDictCursor,

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll/web/__init__.py

@@ -156,7 +156,6 @@ def _int(num):
 class Application(object):
     def __init__(self):
         self._loop = None
-        self.mysql = None
         self.env = None
         self.app = None
         self._route_table = web.RouteTableDef()
@@ -237,6 +236,7 @@ class Application(object):
         for db in apps.db:
             await apps.db[db].close()
 
+        # close for session
         if "redis" in apps:
             await apps.redis.close()
 

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll/web/settings.py

@@ -1,12 +1,13 @@
 import yaml
 import os
-from ..logging import error
+from ..logging import error,info
 
 
 def get_config(env):
     if env is None:
         return {}
     conf_path = os.path.join(os.path.abspath("."), "config", f"conf.{env}.yaml")
+    info(f'loading config {conf_path}')
     if not os.path.exists(conf_path):
         error(f"Configuration file does not exist: {conf_path}")
         return {}

{cloudoll-2.0.24 → cloudoll-2.1.0}/cloudoll.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudoll
-Version: 2.0.24
+Version: 2.1.0
 Summary: 辅助快速创建可分布的微服务。
 Home-page: https://gitee.com/chuchur/cloudoll-py
 Author: chuchur

cloudoll-2.0.24/cloudoll/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.0.24"

cloudoll-2.0.24/cloudoll/orm/base.py

@@ -1,87 +0,0 @@
-from .model import Model
-
-
-class MeteBase():
-    def use(self, model: Model):
-        model.__pool__ = self.pool
-        return model
-
-    async def __aexit__(self):
-        await self.close()
-
-    async def close(self):
-        if self.pool:
-            self.pool.close()
-            await self.pool.wait_closed()
-
-    # async def begin_transaction(self):
-    #     conn = await self._set_conn()
-    #     await conn.begin()
-    #     return conn
-
-    # async def begin_transaction_scope(self, fun):
-    #     conn = await self._set_conn()
-    #     await conn.begin()
-    #     cursor = None
-    #     if isfunction(fun):
-    #         try:
-    #             cursor = await conn.cursor()
-    #             await fun(cursor)
-    #             await conn.commit()
-    #         except Exception as e:
-    #             error(e)
-    #             await conn.rollback()
-    #         finally:
-    #             if cursor:
-    #                 await cursor.close()
-    #         self.pool.release(conn)
-
-    async def release(self):
-        cursor = self.cursor
-        if cursor:
-            await cursor.close()
-        if self.pool:
-            self.pool.release(self.conn)
-
-    async def query(self, sql, params=None):
-        sql = sql.replace("?", "%s")
-        # print('sql', sql, params)
-        if not self.pool:
-            raise ValueError("must be create_engine first.")
-        conn = await self.pool.acquire()
-        cursor = await conn.cursor()
-        await cursor.execute(sql, params)
-        self.cursor = cursor
-        self.conn = conn
-        return self
-
-    async def all(self):
-        cursor = self.cursor
-        result = None
-        if cursor:
-            result = await cursor.fetchall()
-            await self.release()
-        return result
-
-    async def one(self):
-        cursor = self.cursor
-        result = None
-        if cursor:
-            result = await cursor.fetchone()
-            await self.release()
-        return result
-
-    async def many(self, size: int):
-        cursor = self.cursor
-        result = None
-        if cursor:
-            result = await cursor.fetchmany(size)
-            await self.release()
-        return result
-
-    async def count(self):
-        result = await self.one()
-        value = 0
-        for r in result:
-            value = result[r]
-        return value