cloudoll 2.2.20__tar.gz → 2.2.24__tar.gz

{cloudoll-2.2.20 → cloudoll-2.2.24}/PKG-INFO

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

cloudoll-2.2.24/cloudoll/__init__.py

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

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/orm/__init__.py

@@ -1,13 +1,20 @@
 from redis import asyncio as aioredis
 from .parse import parse_coon
-import aiopg, aiomysql
 from .base import MeteBase, QueryTypes
 from typing import Any
 from ..logging import print_info, print_error
 import traceback
+import aiomysql
 from aiomysql import Pool as MYPool
+
+import aiopg as pg
 from aiopg.pool import Pool as PGPool
 
+# import asyncpg as pg
+# from asyncpg.pool import Pool as PGPool
+
+__ALL__ = "create_engine"
+
 
 async def create_engine(**kw):
     url = kw.get("url")
@@ -26,7 +33,7 @@ async def create_engine(**kw):
 
     if driver == "mysql":
         return await Mysql().create_engine(**configs, **query)
-    elif driver == "postgres":
+    elif driver == "postgres" or driver == "postgressql":
         return await Postgres().create_engine(**configs, **query)
     elif driver == "redis" or driver == "rediss":
         """
@@ -48,6 +55,65 @@ class Postgres(MeteBase):
     def __call__(self, *args: Any, **kwds: Any) -> Any:
         self.__init__(*args, **kwds)
 
+    # async def query(self, sql, params=None, query_type: QueryTypes = 2, size: int = 10):
+    #     sql = sql.replace("?", "%s").replace("`", "")
+    #     print_info("sql", sql, params)
+    #     if not self.pool:
+    #         raise ValueError("must be create_engine first.")
+    #     if self.pool._closing or self.pool._closed:
+    #         return None
+
+    #     # async with self.pool.acquire() as conn:
+    #     async with self.pool.acquire() as conn:
+    #         # current_cursor = getattr(cursor, 'lastrowid', None)
+    #         if (
+    #             query_type == QueryTypes.CREATEBATCH
+    #             or query_type == QueryTypes.UPDATEBATCH
+    #         ):
+    #             result = await conn.executemany(sql, params)  # aiopg don't support executemany
+    #         else:
+    #             result = await conn.execute(sql, params)
+
+    #         # result = None
+
+    #         return result
+
+    #         if query_type == QueryTypes.ALL:
+    #             columns = [desc[0] for desc in cursor.description]
+    #             rows = await cursor.fetchall()
+    #             result = [dict(zip(columns, row)) for row in rows]
+    #             return result
+    #         elif query_type == QueryTypes.ONE:
+    #             columns = [desc[0] for desc in cursor.description]
+    #             row = await cursor.fetchone()
+    #             # print("rows_reuslt", rows)
+    #             result = dict(zip(columns, row)) if row else {}
+    #             return result
+    #         elif query_type == QueryTypes.MANY:
+    #             columns = [desc[0] for desc in cursor.description]
+    #             rows = await cursor.fetchmany(size)
+    #             result = [dict(zip(columns, row)) for row in rows]
+    #             return result
+    #         elif query_type == QueryTypes.COUNT:
+    #             rs = await cursor.fetchone()
+    #             return rs[0] if row else 0
+    #         elif query_type == QueryTypes.CREATE:
+    #             result = cursor.rowcount > 0
+    #             id = cursor.lastrowid
+    #             return result, id
+    #         elif query_type == QueryTypes.CREATEBATCH:
+    #             count = cursor.rowcount
+    #             id = cursor.lastrowid
+    #             return count, id
+    #         elif query_type == QueryTypes.UPDATE:
+    #             return cursor.rowcount > 0
+    #         elif query_type == QueryTypes.UPDATEBATCH:
+    #             return cursor.rowcount
+    #         elif query_type == QueryTypes.DELETE:
+    #             return cursor.rowcount > 0
+
+    #         self.pool.release(cursor)
+
     async def query(self, sql, params=None, query_type: QueryTypes = 2, size: int = 10):
         sql = sql.replace("?", "%s").replace("`", "")
         print_info("sql", sql, params)
@@ -55,43 +121,56 @@ class Postgres(MeteBase):
             raise ValueError("must be create_engine first.")
         if self.pool._closing or self.pool._closed:
             return None
+
         async with self.pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # current_cursor = getattr(cursor, 'lastrowid', None)
-                await cursor.execute(sql, params)
+                if (
+                    query_type == QueryTypes.CREATEBATCH
+                    or query_type == QueryTypes.UPDATEBATCH
+                ):
+                    # aiopg don't support executemany
+                    await cursor.executemany(sql, params)
+                else:
+                    await cursor.execute(sql, params)
 
-                # if query_type.value > 4:
-                # if self.driver == "mysql":
-                # await conn.commit()
-                # elif self.driver == "postgres":
-                columns = [desc[0] for desc in cursor.description]
                 result = None
 
                 if query_type == QueryTypes.ALL:
+                    columns = [desc[0] for desc in cursor.description]
                     rows = await cursor.fetchall()
                     result = [dict(zip(columns, row)) for row in rows]
                     return result
                 elif query_type == QueryTypes.ONE:
-                    rows = await cursor.fetchone()
-                    result = dict(zip(columns, rows))
+                    columns = [desc[0] for desc in cursor.description]
+                    row = await cursor.fetchone()
+                    # print("rows_reuslt", rows)
+                    result = dict(zip(columns, row)) if row else {}
                     return result
                 elif query_type == QueryTypes.MANY:
+                    columns = [desc[0] for desc in cursor.description]
                     rows = await cursor.fetchmany(size)
                     result = [dict(zip(columns, row)) for row in rows]
                     return result
                 elif query_type == QueryTypes.COUNT:
                     rs = await cursor.fetchone()
-                    return rs[0]
+                    return rs[0] if row else 0
                 elif query_type == QueryTypes.CREATE:
                     result = cursor.rowcount > 0
                     id = cursor.lastrowid
                     return result, id
+                elif query_type == QueryTypes.CREATEBATCH:
+                    count = cursor.rowcount
+                    id = cursor.lastrowid
+                    return count, id
                 elif query_type == QueryTypes.UPDATE:
                     return cursor.rowcount > 0
+                elif query_type == QueryTypes.UPDATEBATCH:
+                    return cursor.rowcount
                 elif query_type == QueryTypes.DELETE:
                     return cursor.rowcount > 0
 
-        self.pool.release(conn)
+        self.pool.release(cursor)
 
     async def create_engine(self, **kw):
         try:
@@ -100,17 +179,20 @@ class Postgres(MeteBase):
             user = (kw.get("username"),)
             password = (str(kw.get("password", "")),)
             db = (kw.get("db"),)
-            dsn = f"dbname={db[0]} user={user[0]} password={password[0]} host={host[0]} port={port[0]}"
-            self.pool = await aiopg.create_pool(
+            dsn = f"dbname={db[0]} user={user[0]} password={password[0]} host={host[0]} port={port[0]}"  # aiopg
+            # dsn = f"postgres://{user[0]}:{password[0]}@{host[0]}:{port[0]}/{db[0]}" #asyncpg
+            self.pool = await pg.create_pool(
                 dsn=dsn,
                 timeout=kw.get("timeout"),
-                echo=kw.get("echo", False),
-                maxsize=kw.get("maxsize", 10),
-                minsize=kw.get("pool_size", 5),
+                echo=kw.get("echo", False),  # aiopg
+                # max_size=kw.get("maxsize", 10), #asyncpg
+                # min_size=kw.get("minsize", 5), #asyncpg
+                maxsize=kw.get("maxsize", 10),  # aiopg
+                minsize=kw.get("minsize", 5),  # aiopg
             )
             print_info(f"Database connection successfuly for postgres/{kw.get('db')}")
         except Exception as e:
-            # print_error(e)
+            print_error(e)
             # print(traceback.format_exc())
             print_error(
                 f"Database connection failed,the instance : postgres/{kw.get('db')}"
@@ -144,7 +226,7 @@ class Mysql(MeteBase):
 
     async def query(self, sql, params=None, query_type: QueryTypes = 2, size: int = 10):
         sql = sql.replace("?", "%s")
-        print_info("sql", sql, params)
+        # print_info("sql", sql, params)
         if not self.pool:
             raise ValueError("must be create_engine first.")
         if self.pool._closing or self.pool._closed:
@@ -152,7 +234,13 @@ class Mysql(MeteBase):
         async with self.pool.acquire() as conn:
             async with conn.cursor() as cursor:
                 # current_cursor = getattr(cursor, 'lastrowid', None)
-                await cursor.execute(sql, params)
+                if (
+                    query_type == QueryTypes.CREATEBATCH
+                    or query_type == QueryTypes.UPDATEBATCH
+                ):
+                    await cursor.executemany(sql, params)
+                else:
+                    await cursor.execute(sql, params)
 
                 # if query_type.value > 4:
                 # if self.driver == "mysql":
@@ -176,8 +264,14 @@ class Mysql(MeteBase):
                     result = cursor.rowcount > 0
                     id = cursor.lastrowid
                     return result, id
+                elif query_type == QueryTypes.CREATEBATCH:
+                    count = cursor.rowcount
+                    id = cursor.lastrowid
+                    return count, id
                 elif query_type == QueryTypes.UPDATE:
                     return cursor.rowcount > 0
+                elif query_type == QueryTypes.UPDATEBATCH:
+                    return cursor.rowcount
                 elif query_type == QueryTypes.DELETE:
                     return cursor.rowcount > 0
 
@@ -195,7 +289,7 @@ class Mysql(MeteBase):
                 charset=kw.get("charset", "utf8"),
                 autocommit=False,  # kw.get("autocommit", False),
                 maxsize=kw.get("maxsize", 10),
-                minsize=kw.get("pool_size", 5),
+                minsize=kw.get("minsize", 5),
                 cursorclass=AttrDictCursor,
                 loop=loop,
             )

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/orm/base.py

@@ -9,6 +9,8 @@ class QueryTypes(Enum):
     CREATE = 5
     UPDATE = 6
     DELETE = 7
+    CREATEBATCH = 8
+    UPDATEBATCH = 9
 
 
 class MeteBase:
@@ -60,9 +62,15 @@ class MeteBase:
 
     async def update(self, sql, params):
         return await self.query(sql, params, QueryTypes.UPDATE)
+    
+    async def update_batch(self, sql, params):
+        return await self.query(sql, params, QueryTypes.UPDATEBATCH)
 
     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)
+    
+    async def create_batch(self, sql, params):
+        return await self.query(sql, params, QueryTypes.CREATEBATCH)

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/orm/field.py

@@ -354,6 +354,7 @@ class Field(FieldBase):
         primary_key=False,  # 主键
         charset=None,  # 编码
         max_length=None,  # 长度
+        scale_length=None, # 精度
         auto_increment=False,  # 自增
         NOT_NULL=False,  # 非空
         created_generated=False,  # 创建时for datetime
@@ -371,6 +372,7 @@ class Field(FieldBase):
         self.charset = charset
         self.default = default
         self.max_length = max_length
+        self.scale_length = scale_length
         self.auto_increment = auto_increment
         self.NOT_NULL = NOT_NULL
         self.created_generated = created_generated

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/orm/model.py

@@ -3,9 +3,12 @@ from ..logging import print_warn
 from functools import reduce
 import operator
 import copy
+import re
 import datetime
 from ..utils.common import Object
 
+__ALL__ = ("models", "Model")
+
 
 class ModelMetaclass(type):
     # def __init__(self, **kw):
@@ -127,6 +130,8 @@ class Model(metaclass=ModelMetaclass):
 
     def _get_primary(self):
         pk = self.__primary_key__
+        if pk is None:
+            return None, None
         pkf = getattr(self, pk)
         return pk, pkf.value
 
@@ -144,14 +149,14 @@ class Model(metaclass=ModelMetaclass):
     @classmethod
     def use(cls, pool=None):
         cls.__pool__ = pool
+        cls.__ispg = cls.__pool__.driver == "postgres"
         return cls()
 
     def select(cls, *args):
         cols = []
-        is_pg = cls.__pool__.driver == "postgres"
         for col in args:
             if isinstance(col, Field):
-                cols.append(col.name if is_pg else col.full_name)
+                cols.append(col.name if cls.__ispg else col.full_name)
             elif isinstance(col, Function):
                 q, p = col.sql()
                 cols.append(q)
@@ -190,12 +195,11 @@ class Model(metaclass=ModelMetaclass):
 
     def order_by(self, *args):
         by = []
-        is_pg = self.__pool__.driver == "postgres"
         for f in args:
             if isinstance(f, str):
                 by.append(f)
             else:
-                by.append(f"{f.lhs.name if is_pg else f.lhs.full_name} {f.op}")
+                by.append(f"{f.lhs.name if self.__ispg else f.lhs.full_name} {f.op}")
         if self.__order_by__ is not None:
             by = self.__order_by__ + by
         self.__order_by__ = by
@@ -203,17 +207,15 @@ class Model(metaclass=ModelMetaclass):
 
     def group_by(self, *args):
         by = []
-        is_pg = self.__pool__.driver == "postgres"
         for f in args:
-            by.append(f.name if is_pg else f.full_name)
+            by.append(f.name if self.__ispg else f.full_name)
         if self.__group_by__ is not None:
             by = self.__group_by__ + by
         self.__group_by__ = by
         return self
 
-    def _get_key_args(self, args):
+    def _format_data(self, action, args):
         data = dict()
-        md = None
         if args is None or not args:
             for k in self.__fields__:
                 f = getattr(self, k)
@@ -223,13 +225,19 @@ class Model(metaclass=ModelMetaclass):
             data = args
         else:
             for item in args:
-                md = item
                 if isinstance(item, Model):
                     for k in item.__dict__:
-                        data[k] = item[k]
+                        if (action == "u" and item[k].value) or action == "i":
+                            data[k] = item[k]
+
                 else:  # for object
                     for k, v in item.items():
                         data[k] = v
+
+        return data
+
+    def _get_update_key_args(self, action, args):
+        data = self._format_data(action, args)
         keys = []
         params = []
         for k, v in data.items():
@@ -246,7 +254,48 @@ class Model(metaclass=ModelMetaclass):
             elif v is not None:  # fix sql format %s
                 keys.append("`%s`=?" % k)
                 params.append(v)
-        return ",".join(keys), params, md
+        return ",".join(keys), params
+
+    def _get_insert_key_args(self, action, args):
+        data = self._format_data(action, args)
+        keys = []
+        params = []
+        for k, v in data.items():
+            if isinstance(v, Field):
+                value = v.value
+                if value is None:
+                    if v.created_generated == True or v.update_generated == True:
+                        value = datetime.datetime.now()
+                    else:
+                        value = v.default
+                if value is not None:
+                    keys.append(k)
+                    params.append(value)
+            elif v is not None:  # fix sql format %s
+                keys.append(k)
+                params.append(v)
+        return keys, params
+
+    def _get_batch_keys_values(self, items: list):
+        keys = []
+        values = []
+        item = items[0]
+        if isinstance(item, Model):
+            keys = item.__dict__.keys()
+        elif isinstance(item, dict):
+            keys = item.keys()
+
+        for item in items:
+            value = []
+            if isinstance(item, Model):
+                for k in item.__dict__:
+                    value.append(item[k].value)
+            elif isinstance(item, dict):  # for object
+                for k, v in item.items():
+                    value.append(v)
+            value = tuple(key for key in value)
+            values.append(value)
+        return keys, values
 
     def _merge_params(self, p):
         if p is not None:
@@ -292,10 +341,11 @@ class Model(metaclass=ModelMetaclass):
     async def one(self):
         self.limit(1)
         sql = self._sql()
+        sql = self._exchange_sql(sql)
         args = self.__params__
         rs = await self.__pool__.one(sql, args)
         if rs:
-            ## join 时返回dict 
+            # join 时返回dict
             result = Object(rs) if self.__join__ is not None else self(**rs)
             self._reset()
             return result
@@ -306,10 +356,29 @@ class Model(metaclass=ModelMetaclass):
 
     async def all(self):
         sql = self._sql()
+        sql = self._exchange_sql(sql)
         args = self.__params__
         self._reset()
         return await self.__pool__.all(sql, args)
 
+    def _exchange_sql(self, sql: str):
+        if self.__ispg:
+            sql = sql.replace("CURDATE()", "CURRENT_DATE")
+            sql = sql.replace("NOW()", "CURRENT_TIMESTAMP")
+
+            pattern = r"INTERVAL\s+(\d+)\s+(DAY|MONTH|YEAR|HOUR|MINUTE|SECOND)"
+            matches = re.findall(pattern, sql)
+
+            def replacement(match):
+                number = match.group(1)
+                unit = match.group(2).lower()  # 转换为小写
+                return f"INTERVAL '{number} {unit}'"
+
+            if matches:
+                sql = re.sub(pattern, replacement, sql)
+
+        return sql
+
     async def update(self, *args, **kw) -> bool:
         """
         Update data
@@ -318,7 +387,7 @@ class Model(metaclass=ModelMetaclass):
         # where = self.__where__
         where = self._literal("WHERE", self.__where__)
 
-        keys, params, md = self._get_key_args(args or kw)
+        keys, params = self._get_update_key_args("u", args or kw)
 
         sql = f"update `{table}` set {keys} {where}"
 
@@ -339,6 +408,7 @@ class Model(metaclass=ModelMetaclass):
             else:
                 raise "Need where or primary key"
         self._reset()
+        sql = self._exchange_sql(sql)
         return await self.__pool__.update(sql, params)
 
     async def delete(self) -> bool:
@@ -358,15 +428,26 @@ class Model(metaclass=ModelMetaclass):
             else:
                 raise "need where or primary key"
         self._reset()
+        sql = self._exchange_sql(sql)
         return await self.__pool__.delete(sql, args)
 
     async def insert(self, *args, **kw):
         table = self.__table__
-        keys, params, md = self._get_key_args(args or kw)
-        sql = f"insert into `{table}` set {keys}"
+        keys, params = self._get_insert_key_args("i", args or kw)
+        sql = f"insert into `{table}` ({','.join(keys)}) values ({','.join(['?' for k in keys])})"
         self._reset()
+        params = tuple(key for key in params)
         return await self.__pool__.create(sql, params)
 
+    async def insert_batch(self, items: list):
+        table = self.__table__
+        if len(items) == 0:
+            return 0
+        keys, params = self._get_batch_keys_values(items)
+        sql = f"insert into `{table}` ({','.join(keys)}) values ({','.join(['?' for k in keys])})"
+        self._reset()
+        return await self.__pool__.create_batch(sql, params)
+
     async def count(self):
         __where__ = copy.copy(self.__where__)
         __join__ = copy.copy(self.__join__)
@@ -376,6 +457,7 @@ class Model(metaclass=ModelMetaclass):
         aft = " ".join([JOIN, WHERE])
         sql = f"SELECT COUNT(*) FROM {cls.__table__} {aft}"
         args = cls.__params__
+        sql = self._exchange_sql(sql)
         return await cls.__pool__.count(sql, args)
 
 
@@ -512,6 +594,7 @@ class Models(object):
             default=None,
             not_null=False,
             max_length=None,
+            scale_length=None,
             unsigned=False,
             comment=None,
         ):
@@ -521,10 +604,33 @@ class Models(object):
                 default,
                 NOT_NULL=not_null,
                 max_length=max_length,
+                scale_length=scale_length,
                 unsigned=unsigned,
                 comment=comment,
             )
 
+    class NumericField(Field):
+        def __init__(
+            self,
+            name=None,
+            default=0.0,
+            not_null=False,
+            max_length=None,
+            scale_length=None,
+            unsigned=False,
+            comment=None,
+        ):
+            super().__init__(
+                name,
+                "numeric",
+                default,
+                NOT_NULL=not_null,
+                unsigned=unsigned,
+                max_length=max_length,
+                scale_length=scale_length,
+                comment=comment,
+            )
+
     class DecimalField(Field):
         def __init__(
             self,
@@ -532,6 +638,7 @@ class Models(object):
             default=0.0,
             not_null=False,
             max_length=None,
+            scale_length=None,
             unsigned=False,
             comment=None,
         ):
@@ -542,6 +649,7 @@ class Models(object):
                 NOT_NULL=not_null,
                 unsigned=unsigned,
                 max_length=max_length,
+                scale_length=scale_length,
                 comment=comment,
             )
 

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/robot/feishu.py

@@ -5,7 +5,8 @@ __author__ = "chuchur/chuchur.com"
 
 import hashlib, hmac, time, base64
 from curl_cffi import requests as http
-from ..logging import print_error,print_info
+from ..logging import print_error, print_info
+
 
 class Client(object):
     def __init__(self, **kw):

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll/utils/m2d.py

@@ -6,12 +6,12 @@ import importlib
 
 
 def snake_to_camel(snake_str):
-    components = snake_str.split('_')
+    components = snake_str.split("_")
     # camel_str = components[0] + ''.join(x.title() for x in components[1:])
     # x.capitalize() //first
     # x.title() //all
     # return camel_str[0].upper() + camel_str[1:]
-    return ''.join(x.title() for x in components[0:])
+    return "".join(x.title() for x in components[0:])
 
 
 async def create_model(pool, table_name) -> str:
@@ -27,6 +27,7 @@ async def create_model(pool, table_name) -> str:
     tb += f"\t__table__ = '{table_name}'\n\n"
     for f in rows:
         fields = get_col(f, pool.driver)
+        # print("fields",fields)
         name = fields["name"]
         column_type = fields["column_type"]
         values = []
@@ -40,6 +41,8 @@ async def create_model(pool, table_name) -> str:
                 if isinstance(fields["max_length"], str) and "," in fields["max_length"]
                 else f"max_length={fields['max_length']}"
             )
+        if fields["scale_length"]:
+            values.append(f"scale_length={fields['scale_length']}")
         if fields["default"]:
             values.append(f"default='{fields['default']}'")
         if fields["auto_increment"]:
@@ -65,16 +68,28 @@ async def get_table_cols(pool, table_name):
     if pool.driver == "mysql":
         return await pool.all(f"show full COLUMNS from `{table_name}`", None)
     elif pool.driver == "postgres":
+        pri_row = await pool.one(
+            f"SELECT column_name from information_schema.key_column_usage WHERE table_name = '{table_name}'",
+            None,
+        )
         sql = f"""SELECT column_name Field, 
             column_default Default,
             data_type column_type, 
             is_nullable Null,
             numeric_precision num_length,
+            numeric_scale scale_length,
             character_maximum_length str_length,
             datetime_precision date_length,
             col_description('{table_name}'::regclass, ordinal_position) Comment
             FROM information_schema.columns WHERE table_name ='{table_name}'"""
-        return await pool.all(sql, None)
+
+        rows = await pool.all(sql, None)
+        for row in rows:
+            row["Key"] = "PRI" if pri_row and pri_row["column_name"] == row["field"] else None
+       
+        # print("rows", rows)
+        
+        return rows
     else:
         raise ValueError("Database not support.")
 
@@ -91,7 +106,6 @@ async def get_all_tables(pool):
         raise ValueError("Database not support.")
 
 
-
 async def create_models(pool, save_path: str = None, tables: list = None):
     """
     Create models
@@ -201,16 +215,17 @@ def get_col(field, driver="mysql"):
             fields["column_type"] = t.groups()[0]
             fields["max_length"] = t.groups()[1]
         return fields
-    elif driver == "postgres":
+    elif driver == "postgres" or driver == "postgresql":
         fields = {
             "name": field["field"],
             "column_type": field["column_type"].replace(" ", "_"),
-            "primary_key": False,
+            "primary_key": field["Key"] == "PRI",
             "default": field["default"],
             "charset": None,
             "max_length": field["num_length"]
             or field["str_length"]
             or field["date_length"],
+            "scale_length": field["scale_length"],
             "auto_increment": None,
             "NOT_NULL": field["null"] == "NO",
             "created_generated": None,
@@ -224,11 +239,12 @@ def get_col_sql(field):
     sql = f"`{field.name}` {field.column_type}"
 
     if field.max_length:
-        sql += (
-            f"{field.max_length}"
-            if isinstance(field.max_length, tuple)
-            else f"({field.max_length})"
-        )
+        if isinstance(field.max_length, tuple):
+            sql += f"{field.max_length}"
+        elif field.scale_length:
+            sql += f"({field.max_length},{field.scale_length})"
+        else:
+            sql += f"({field.max_length})"
 
     if field.charset:
         # _ci 不区分大小写 _cs Yes
@@ -237,7 +253,8 @@ def get_col_sql(field):
     if field.primary_key:
         sql += " PRIMARY KEY"
     if field.auto_increment:
-        sql += " AUTO_INCREMENT"
+        # todo: postgres SERIAL
+        sql += " AUTO_INCREMENT" 
     if field.NOT_NULL:
         sql += " NOT NULL"
     if field.default:
@@ -279,14 +296,15 @@ class ColTypes(enum.Enum):
     float = "Float"
     double = "Double"
     decimal = "Decimal"
+    numeric = "Numeric"
     date = "Date"
     datetime = "Datetime"
     timestamp = "Timestamp"
     json = "Json"
     # pg
     timestamp_with_time_zone = "Timestamp"
+    timestamp_without_time_zone = "Timestamp"
     character_varying = "VarChar"
+    character = "Char"
     integer = "Integer"
     boolean = "Boolean"
-    
-    

cloudoll-2.2.24/cloudoll/utils/snowflake.py

@@ -0,0 +1,86 @@
+
+import time
+import threading
+
+
+"""
+雪花算法（全局唯一id）
+
+# 最早是Twitter公司在其内部用于分布式环境下生成唯一ID
+
+# Twitter's Snowflake algorithm implementation which is used to generate distributed IDs.
+
+# https://github.com/twitter-archive/snowflake/blob/snowflake-2010/src/main/scala/com/twitter/service/snowflake/IdWorker.scala
+"""
+
+
+class IdWorker:
+    def __init__(self, worker_id, datacenter_id, sequence=0):
+         # 位移值
+        self.worker_id_bits = 5
+        self.datacenter_id_bits = 5
+        self.sequence_bits = 12
+        
+        self.max_worker_id = -1 ^ (-1 << self.worker_id_bits)
+        self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)
+
+        # 参数校验
+        if worker_id > self.max_worker_id or worker_id < 0:
+            raise ValueError(f'worker_id must be between 0 and {self.max_worker_id}')
+        if datacenter_id > self.max_datacenter_id or datacenter_id < 0:
+            raise ValueError(f'datacenter_id must be between 0 and {self.max_datacenter_id}')
+
+        self.worker_id = worker_id
+        self.datacenter_id = datacenter_id
+        self.sequence = sequence
+        self.lock = threading.Lock()
+
+        # Twitter Epoch (2010-11-04 01:42:54 UTC)
+        self.twepoch = 1288834974657
+
+       
+
+       
+        self.worker_id_shift = self.sequence_bits
+        self.datacenter_id_shift = self.sequence_bits + self.worker_id_bits
+        self.timestamp_left_shift = self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
+        self.sequence_mask = -1 ^ (-1 << self.sequence_bits)
+
+        self.last_timestamp = -1
+
+    def _time_gen(self):
+        return int(time.time() * 1000)
+
+    def _til_next_millis(self, last_timestamp):
+        timestamp = self._time_gen()
+        while timestamp <= last_timestamp:
+            timestamp = self._time_gen()
+        return timestamp
+
+    def next_id(self):
+        with self.lock:
+            timestamp = self._time_gen()
+
+            if timestamp < self.last_timestamp:
+                raise Exception(f'Clock moved backwards. Refusing to generate id for {self.last_timestamp - timestamp} milliseconds')
+
+            if self.last_timestamp == timestamp:
+                self.sequence = (self.sequence + 1) & self.sequence_mask
+                if self.sequence == 0:
+                    timestamp = self._til_next_millis(self.last_timestamp)
+            else:
+                self.sequence = 0
+
+            self.last_timestamp = timestamp
+
+            id = ((timestamp - self.twepoch) << self.timestamp_left_shift) | \
+                (self.datacenter_id << self.datacenter_id_shift) | \
+                (self.worker_id << self.worker_id_shift) | \
+                self.sequence
+
+            return id
+
+
+# 示例使用
+worker = IdWorker(worker_id=1, datacenter_id=1)
+print(worker.next_id())

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll.egg-info/PKG-INFO

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

{cloudoll-2.2.20 → cloudoll-2.2.24}/cloudoll.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ cloudoll/utils/__init__.py
 cloudoll/utils/common.py
 cloudoll/utils/m2d.py
 cloudoll/utils/patch_loop.py
+cloudoll/utils/snowflake.py
 cloudoll/utils/watch.py
 cloudoll/web/__init__.py
 cloudoll/web/exception.py

cloudoll-2.2.20/cloudoll/__init__.py

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