lesscode-database 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

lesscode_database/connect_pool.py

@@ -31,7 +31,7 @@ class Pool:
         try:
             elasticsearch = importlib.import_module("elasticsearch")
         except ImportError:
-            raise Exception(f"elasticsearch is not exist,run:pip install elasticsearch[async]")
+            raise ImportError(f"elasticsearch is not exist,run:pip install elasticsearch[async]")
         pool = elasticsearch.AsyncElasticsearch(hosts=hosts)
         return pool
 
@@ -54,7 +54,7 @@ class Pool:
         try:
             elasticsearch = importlib.import_module("elasticsearch")
         except ImportError:
-            raise Exception(f"elasticsearch is not exist,run:pip install elasticsearch")
+            raise ImportError(f"elasticsearch is not exist,run:pip install elasticsearch")
         pool = elasticsearch.Elasticsearch(hosts)
         return pool
 
@@ -68,7 +68,7 @@ class Pool:
         try:
             motor_asyncio = importlib.import_module("motor.motor_asyncio")
         except ImportError:
-            raise Exception(f"motor is not exist,run:pip install motor")
+            raise ImportError(f"motor is not exist,run:pip install motor")
         if conn_info.dsn:
             uri = conn_info.dsn
         else:
@@ -96,7 +96,7 @@ class Pool:
         try:
             pymongo = importlib.import_module("pymongo")
         except ImportError:
-            raise Exception(f"pymongo is not exist,run:pip install pymongo")
+            raise ImportError(f"pymongo is not exist,run:pip install pymongo")
         if conn_info.dsn:
             uri = conn_info.dsn
         else:
@@ -124,7 +124,7 @@ class Pool:
         try:
             aiomysql = importlib.import_module("aiomysql")
         except ImportError:
-            raise Exception(f"aiomysql is not exist,run:pip install aiomysql")
+            raise ImportError(f"aiomysql is not exist,run:pip install aiomysql")
         pool = await aiomysql.create_pool(host=conn_info.host, port=conn_info.port,
                                           user=conn_info.user,
                                           password=conn_info.password,
@@ -132,7 +132,8 @@ class Pool:
                                           if conn_info.params else 3600,
                                           db=conn_info.db_name, autocommit=True,
                                           minsize=conn_info.min_size,
-                                          maxsize=conn_info.max_size)
+                                          maxsize=conn_info.max_size,
+                                          cursorclass=aiomysql.DictCursor)
         return pool
 
     @staticmethod
@@ -145,11 +146,11 @@ class Pool:
         try:
             pymysql = importlib.import_module("pymysql")
         except ImportError:
-            raise Exception(f"pymysql is not exist,run:pip install pymysql")
+            raise ImportError(f"pymysql is not exist,run:pip install pymysql")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=pymysql, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -169,7 +170,7 @@ class Pool:
         try:
             aiosqlite3 = importlib.import_module("aiosqlite3")
         except ImportError:
-            raise Exception(f"aiosqlite3 is not exist,run:pip install aiosqlite3")
+            raise ImportError(f"aiosqlite3 is not exist,run:pip install aiosqlite3")
         pool = await aiosqlite3.connect(database=conn_info.dsn)
         return pool
 
@@ -183,18 +184,13 @@ class Pool:
         try:
             sqlite3 = importlib.import_module("sqlite3")
         except ImportError:
-            raise Exception(f"sqlite3 is not exist,run:pip install sqlite3")
+            raise ImportError(f"sqlite3 is not exist,run:pip install sqlite3")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
-        pool = pooled_db.PooledDB(creator=sqlite3, host=conn_info.host, port=conn_info.port,
-                                  user=conn_info.user,
-                                  passwd=conn_info.password, db=conn_info.db_name,
-                                  mincached=conn_info.min_size, blocking=True, maxusage=conn_info.min_size,
-                                  maxshared=conn_info.max_size, maxcached=conn_info.max_size,
-                                  ping=1, maxconnections=conn_info.max_size, charset="utf8mb4", autocommit=True,
-                                  read_timeout=30)
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
+        pool = pooled_db.PooledDB(creator=sqlite3, database=conn_info.dsn,
+                                  check_same_thread=False)
         return pool
 
     @staticmethod
@@ -207,11 +203,11 @@ class Pool:
         try:
             pymssql = importlib.import_module("pymssql")
         except ImportError:
-            raise Exception(f"pymssql is not exist,run:pip install pymssql")
+            raise ImportError(f"pymssql is not exist,run:pip install pymssql")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=pymssql, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -231,11 +227,11 @@ class Pool:
         try:
             cx_oracle = importlib.import_module("cx_Oracle")
         except ImportError:
-            raise Exception(f"cx_Oracle is not exist,run:pip install cx_Oracle")
+            raise ImportError(f"cx_Oracle is not exist,run:pip install cx_Oracle")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=cx_oracle, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -255,7 +251,7 @@ class Pool:
         try:
             aiomysql = importlib.import_module("aiomysql")
         except ImportError:
-            raise Exception(f"aiomysql is not exist,run:pip install aiomysql")
+            raise ImportError(f"aiomysql is not exist,run:pip install aiomysql")
         pool = await aiomysql.create_pool(host=conn_info.host, port=conn_info.port,
                                           user=conn_info.user,
                                           password=conn_info.password,
@@ -276,11 +272,11 @@ class Pool:
         try:
             pymysql = importlib.import_module("pymysql")
         except ImportError:
-            raise Exception(f"pymysql is not exist,run:pip install pymysql")
+            raise ImportError(f"pymysql is not exist,run:pip install pymysql")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=pymysql, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -300,7 +296,7 @@ class Pool:
         try:
             aiomysql = importlib.import_module("aiomysql")
         except ImportError:
-            raise Exception(f"aiomysql is not exist,run:pip install aiomysql")
+            raise ImportError(f"aiomysql is not exist,run:pip install aiomysql")
         pool = await aiomysql.create_pool(host=conn_info.host, port=conn_info.port,
                                           user=conn_info.user,
                                           password=conn_info.password,
@@ -321,11 +317,11 @@ class Pool:
         try:
             pymysql = importlib.import_module("pymysql")
         except ImportError:
-            raise Exception(f"pymysql is not exist,run:pip install pymysql")
+            raise ImportError(f"pymysql is not exist,run:pip install pymysql")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=pymysql, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -345,7 +341,7 @@ class Pool:
         try:
             aiomysql = importlib.import_module("aiomysql")
         except ImportError:
-            raise Exception(f"aiomysql is not exist,run:pip install aiomysql")
+            raise ImportError(f"aiomysql is not exist,run:pip install aiomysql")
         pool = await aiomysql.create_pool(host=conn_info.host, port=conn_info.port,
                                           user=conn_info.user,
                                           password=conn_info.password,
@@ -366,11 +362,11 @@ class Pool:
         try:
             pymysql = importlib.import_module("pymysql")
         except ImportError:
-            raise Exception(f"pymysql is not exist,run:pip install pymysql")
+            raise ImportError(f"pymysql is not exist,run:pip install pymysql")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(creator=pymysql, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   passwd=conn_info.password, db=conn_info.db_name,
@@ -391,7 +387,7 @@ class Pool:
             nebula3_gclient_net = importlib.import_module("nebula3.gclient.net")
             nebula3_config = importlib.import_module("nebula3.Config")
         except ImportError:
-            raise Exception(f"nebula3 is not exist,run:pip install nebula3-python")
+            raise ImportError(f"nebula3 is not exist,run:pip install nebula3-python")
         config = nebula3_config.Config()
         ssl_conf = None
         config.max_connection_pool_size = conn_info.max_size
@@ -425,7 +421,7 @@ class Pool:
         try:
             neo4j = importlib.import_module("neo4j")
         except ImportError:
-            raise Exception(f"neo4j is not exist,run:pip install neo4j")
+            raise ImportError(f"neo4j is not exist,run:pip install neo4j")
         if conn_info.dsn:
             uri = conn_info.dsn
         else:
@@ -443,7 +439,7 @@ class Pool:
         try:
             neo4j = importlib.import_module("neo4j")
         except ImportError:
-            raise Exception(f"neo4j is not exist,run:pip install neo4j")
+            raise ImportError(f"neo4j is not exist,run:pip install neo4j")
         if conn_info.dsn:
             uri = conn_info.dsn
         else:
@@ -461,7 +457,7 @@ class Pool:
         try:
             aiopg = importlib.import_module("aiopg")
         except ImportError:
-            raise Exception(f"aiopg is not exist,run:pip install aiopg")
+            raise ImportError(f"aiopg is not exist,run:pip install aiopg")
         pool = await aiopg.create_pool(dsn=conn_info.dsn, host=conn_info.host, port=conn_info.port, user=conn_info.user,
                                        password=conn_info.password,
                                        database=conn_info.db_name)
@@ -477,11 +473,11 @@ class Pool:
         try:
             psycopg2 = importlib.import_module("psycopg2")
         except ImportError:
-            raise Exception(f"psycopg2-binary is not exist,run:pip install psycopg2-binary")
+            raise ImportError(f"psycopg2-binary is not exist,run:pip install psycopg2-binary")
         try:
             pooled_db = importlib.import_module("dbutils.pooled_db")
         except ImportError:
-            raise Exception(f"DBUtils is not exist,run:pip install DBUtils")
+            raise ImportError(f"DBUtils is not exist,run:pip install DBUtils")
         pool = pooled_db.PooledDB(psycopg2, host=conn_info.host, port=conn_info.port,
                                   user=conn_info.user,
                                   password=conn_info.password, database=conn_info.db_name)
@@ -497,7 +493,7 @@ class Pool:
         try:
             aioredis = importlib.import_module("aioredis")
         except ImportError:
-            raise Exception(f"aioredis is not exist,run:pip install aioredis")
+            raise ImportError(f"aioredis is not exist,run:pip install aioredis")
         if not conn_info.dsn:
             conn_info.dsn = "redis://"
         pool = aioredis.ConnectionPool.from_url(url=conn_info.dsn, host=conn_info.host, port=conn_info.port,
@@ -515,7 +511,7 @@ class Pool:
         try:
             redis = importlib.import_module("redis")
         except ImportError:
-            raise Exception(f"redis is not exist,run:pip install redis")
+            raise ImportError(f"redis is not exist,run:pip install redis")
         if not conn_info.dsn:
             conn_info.dsn = "redis://"
         pool = redis.ConnectionPool.from_url(url=conn_info.dsn, host=conn_info.host, port=conn_info.port,
@@ -533,7 +529,7 @@ class Pool:
         try:
             aioredis_cluster = importlib.import_module("aioredis_cluster")
         except ImportError:
-            raise Exception(f"aioredis is not exist,run:pip install aioredis-cluster")
+            raise ImportError(f"aioredis is not exist,run:pip install aioredis-cluster")
         params = conn_info.params if conn_info.params else {}
         retry_min_delay = params.get("retry_min_delay")
         retry_max_delay = params.get("retry_max_delay")
@@ -574,7 +570,7 @@ class Pool:
         try:
             rediscluster = importlib.import_module("rediscluster")
         except ImportError:
-            raise Exception(f"redis is not exist,run:pip install redis-py-cluster")
+            raise ImportError(f"redis is not exist,run:pip install redis-py-cluster")
         params = conn_info.params if conn_info.params else {}
         init_slot_cache = params.get("init_slot_cache", True) if params else True
         max_connections_per_node = params.get("init_slot_cache",
@@ -600,7 +596,7 @@ class Pool:
         try:
             asynch = importlib.import_module("asynch")
         except ImportError:
-            raise Exception(f"asynch is not exist,run:pip install asynch")
+            raise ImportError(f"asynch is not exist,run:pip install asynch")
         pool = await asynch.create_pool(minsize=conn_info.min_size, maxsize=conn_info.max_size,
                                         dsn=conn_info.dsn, host=conn_info.host,
                                         user=conn_info.user, password=conn_info.password,
@@ -612,7 +608,7 @@ class Pool:
         try:
             clickhouse_driver_dbapi = importlib.import_module("clickhouse_driver.dbapi")
         except ImportError:
-            raise Exception(f"clickhouse-driver is not exist,run:pip install clickhouse-driver")
+            raise ImportError(f"clickhouse-driver is not exist,run:pip install clickhouse-driver")
         con = clickhouse_driver_dbapi.connect(dsn=conn_info.dsn, host=conn_info.host,
                                               user=conn_info.user, password=conn_info.password,
                                               port=conn_info.port, database=conn_info.db_name)
@@ -653,11 +649,11 @@ class Pool:
                     conn_info.user, conn_info.password, conn_info.host, conn_info.port,
                     conn_info.db_name)
             else:
-                raise Exception("UNSUPPORTED DB TYPE")
+                raise ImportError("UNSUPPORTED DB TYPE")
         try:
             sqlalchemy = importlib.import_module("sqlalchemy.ext.asyncio")
         except ImportError:
-            raise Exception(f"sqlalchemy is not exist,run:pip install sqlalchemy")
+            raise ImportError(f"sqlalchemy is not exist,run:pip install sqlalchemy")
         engine = sqlalchemy.create_async_engine(url, echo=conn_info.params.get("echo",
                                                                                True) if conn_info.params else True,
                                                 pool_size=conn_info.min_size,
@@ -716,11 +712,11 @@ class Pool:
                     conn_info.user, conn_info.password, conn_info.host, conn_info.port,
                     conn_info.db_name)
             else:
-                raise Exception("UNSUPPORTED DB TYPE")
+                raise ImportError("UNSUPPORTED DB TYPE")
         try:
             sqlalchemy = importlib.import_module("sqlalchemy")
         except ImportError:
-            raise Exception(f"sqlalchemy is not exist,run:pip install sqlalchemy")
+            raise ImportError(f"sqlalchemy is not exist,run:pip install sqlalchemy")
         engine = sqlalchemy.create_engine(url, echo=conn_info.params.get("echo",
                                                                          True) if conn_info.params else True,
                                           pool_size=conn_info.min_size,
@@ -748,90 +744,90 @@ def run_sync(func_instance):
 def get_pool(conn_info: ConnectionInfo):
     if conn_info.dialect == "elasticsearch":
         if conn_info.async_enable:
-            return run_sync(Pool.create_es_pool(conn_info))
+            return run_sync(Pool.create_es_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_es_pool(conn_info))
+            return run_sync(Pool.sync_create_es_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "mongo":
         if conn_info.async_enable:
-            return run_sync(Pool.create_mongo_pool(conn_info))
+            return run_sync(Pool.create_mongo_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_mongo_pool(conn_info))
+            return run_sync(Pool.sync_create_mongo_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "mysql":
         if conn_info.async_enable:
-            return run_sync(Pool.create_mysql_pool(conn_info))
+            return run_sync(Pool.create_mysql_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_mysql_pool(conn_info))
+            return run_sync(Pool.sync_create_mysql_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "doris":
         if conn_info.async_enable:
-            return run_sync(Pool.create_doris_pool(conn_info))
+            return run_sync(Pool.create_doris_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_doris_pool(conn_info))
+            return run_sync(Pool.sync_create_doris_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "ocean_base":
         if conn_info.async_enable:
-            return run_sync(Pool.create_ocean_base_pool(conn_info))
+            return run_sync(Pool.create_ocean_base_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_ocean_base_pool(conn_info))
+            return run_sync(Pool.sync_create_ocean_base_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "tidb":
         if conn_info.async_enable:
-            return run_sync(Pool.create_tidb_pool(conn_info))
+            return run_sync(Pool.create_tidb_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_tidb_pool(conn_info))
+            return run_sync(Pool.sync_create_tidb_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "mssql":
-        return run_sync(Pool.sync_create_mssql_pool(conn_info))
+        return run_sync(Pool.sync_create_mssql_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "oracle":
-        return run_sync(Pool.sync_create_oracle_pool(conn_info))
+        return run_sync(Pool.sync_create_oracle_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "nebula":
-        return run_sync(Pool.sync_create_nebula_pool(conn_info))
+        return run_sync(Pool.sync_create_nebula_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "neo4j":
         if conn_info.async_enable:
-            return run_sync(Pool.create_neo4j_pool(conn_info))
+            return run_sync(Pool.create_neo4j_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_neo4j_pool(conn_info))
+            return run_sync(Pool.sync_create_neo4j_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "postgresql":
         if conn_info.async_enable:
-            return run_sync(Pool.create_postgresql_pool(conn_info))
+            return run_sync(Pool.create_postgresql_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_postgresql_pool(conn_info))
+            return run_sync(Pool.sync_create_postgresql_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "sqlite3":
         if conn_info.async_enable:
-            return run_sync(Pool.create_sqlite3_pool(conn_info))
+            return run_sync(Pool.create_sqlite3_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_sqlite3_pool(conn_info))
+            return run_sync(Pool.sync_create_sqlite3_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "redis":
         if conn_info.async_enable:
-            return run_sync(Pool.create_redis_pool(conn_info))
+            return run_sync(Pool.create_redis_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_redis_pool(conn_info))
+            return run_sync(Pool.sync_create_redis_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "redis_cluster":
         if conn_info.async_enable:
-            return run_sync(Pool.create_redis_cluster_pool(conn_info))
+            return run_sync(Pool.create_redis_cluster_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_redis_cluster_pool(conn_info))
+            return run_sync(Pool.sync_create_redis_cluster_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "clickhouse":
         if conn_info.async_enable:
-            return run_sync(Pool.create_clickhouse_pool(conn_info))
+            return run_sync(Pool.create_clickhouse_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_clickhouse_pool(conn_info))
+            return run_sync(Pool.sync_create_clickhouse_pool(conn_info)), conn_info
 
     elif conn_info.dialect == "sqlalchemy":
         if conn_info.async_enable:
-            return run_sync(Pool.create_sqlalchemy_pool(conn_info))
+            return run_sync(Pool.create_sqlalchemy_pool(conn_info)), conn_info
         else:
-            return run_sync(Pool.sync_create_sqlalchemy_pool(conn_info))
+            return run_sync(Pool.sync_create_sqlalchemy_pool(conn_info)), conn_info
 
     else:
         raise Exception(f"conn_info.dialect={conn_info.dialect} is not supported")

lesscode_database/connection_info.py

@@ -10,7 +10,7 @@ class ConnectionInfo:
     def __init__(self, dialect: str, dsn: str = None, host: str = None, port: int = None, user: str = None,
                  password: str = None,
                  db_name: Any = None, name: str = None, params: dict = None, min_size: int = 3, max_size: int = 10,
-                 enable: bool = True, async_enable: bool = False):
+                 enable: bool = True, async_enable: bool = False, connect_keepalive: bool = True):
         # 数据库dialect类型
         self.dialect = dialect
         # 连接池名称
@@ -40,3 +40,5 @@ class ConnectionInfo:
         self.enable = enable
         # 是否启用异步
         self.async_enable = async_enable
+        # 是否启用session
+        self.connect_keepalive = connect_keepalive

lesscode_database/{options.py → db_options.py}

@@ -4,7 +4,7 @@ from lesscode_database.connect_pool import get_pool
 from lesscode_database.connection_info import ConnectionInfo
 
 
-class Options:
+class DbOptions:
     _instance = None
 
     def __init__(self):
@@ -47,13 +47,13 @@ class Options:
         return cls._instance
 
 
-options = Options()
+db_options = DbOptions()
 
 
-def define(name: str,
-           default: Any = None,
-           type_: Optional[type] = None,
-           help_: Optional[str] = None,
-           callback: Optional[Callable[[Any], None]] = None,
-           ) -> None:
-    return options.define(name=name, default=default, type_=type_, help_=help_, callback=callback)
+def db_define(name: str,
+              default: Any = None,
+              type_: Optional[type] = None,
+              help_: Optional[str] = None,
+              callback: Optional[Callable[[Any], None]] = None,
+              ) -> None:
+    return db_options.define(name=name, default=default, type_=type_, help_=help_, callback=callback)

lesscode_database/ds_helper.py

@@ -0,0 +1,98 @@
+import importlib
+from asyncio import current_task
+from contextlib import contextmanager, asynccontextmanager
+
+from lesscode_database.db_options import db_options
+
+
+class DsHelper:
+    def __init__(self, pool_name):
+        self.pool, self.connect_info = getattr(db_options, pool_name)
+
+    def exec(self, method: str, *args, **kwargs):
+        return getattr(self.pool, method)(*args, **kwargs)
+
+    async def async_exec(self, method: str, *args, **kwargs):
+        return await getattr(self.pool, method)(*args, **kwargs)
+
+    @contextmanager
+    def make_sqlalchemy_session(self, **kwargs):
+        try:
+            sqlalchemy_orm = importlib.import_module("sqlalchemy.orm")
+        except ImportError:
+            raise Exception(f"sqlalchemy is not exist,run:pip install sqlalchemy==1.4.36")
+        session = None
+        try:
+            db_session = sqlalchemy_orm.scoped_session(sqlalchemy_orm.sessionmaker(bind=self.pool, **kwargs))
+            session = db_session()
+            yield session
+        except Exception:
+            if session:
+                session.rollback()
+        else:
+            session.commit()
+        finally:
+            if session:
+                session.close()
+
+    @asynccontextmanager
+    async def async_make_sqlalchemy_session(self, **kwargs):
+        try:
+            sqlalchemy_asyncio = importlib.import_module("sqlalchemy.ext.asyncio")
+        except ImportError:
+            raise Exception(f"sqlalchemy is not exist,run:pip install sqlalchemy==1.4.36")
+        session = None
+        try:
+            session = sqlalchemy_asyncio.async_scoped_session(
+                sqlalchemy_asyncio.async_sessionmaker(self.pool, **kwargs), current_task)
+            yield session
+        except Exception:
+            if session:
+                await session.rollback()
+        else:
+            await session.commit()
+        finally:
+            if session:
+                await session.close()
+
+    @contextmanager
+    def make_neo4j_session(self, **kwargs):
+        session = None
+        try:
+            session = self.pool.session(database=self.connect_info.db_name, **kwargs)
+            yield session
+        except Exception as e:
+            raise e
+        finally:
+            if session:
+                session.close()
+
+    @asynccontextmanager
+    async def async_make_neo4j_session(self, **kwargs):
+        session = None
+        try:
+            session = self.pool.session(database=self.connect_info.db_name, **kwargs)
+            yield session
+        except Exception as e:
+            raise e
+        finally:
+            if session:
+                await session.close()
+
+    # @contextmanager
+    def make_nebula_session(self, **kwargs):
+        try:
+            session = self.pool.session_context(user_name=self.connect_info.user, password=self.connect_info.password,
+                                                **kwargs)
+            return session
+        except Exception as e:
+            raise e
+
+    def exec_nebula_gql(self, sql, space=None):
+        space = space if space else self.connect_info.db_name
+        if not space:
+            raise Exception(f"nebula no selection space")
+        with self.make_nebula_session() as session:
+            session.execute(f'USE {space}')
+            result = session.execute(sql)
+        return result

lesscode_database/dynamic_import_package.py

@@ -0,0 +1,7 @@
+import importlib
+from types import ModuleType
+
+
+def get_module(module_name: str) -> ModuleType:
+    module = importlib.import_module(module_name)
+    return module

lesscode_database/version.py

@@ -1 +1 @@
-__version__ = "0.0.4"
+__version__ = "0.0.6"

{lesscode_database-0.0.4.dist-info → lesscode_database-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-database
-Version: 0.0.4
+Version: 0.0.6
 Summary: lesscode_database是数据库连接工具包
 Author: navysummer
 Author-email: navysummer@yeah.net
@@ -20,14 +20,13 @@ License-File: LICENSE
 ```python
 import asyncio
 
-from sqlalchemy import select, Column, VARCHAR, INTEGER, Table, MetaData
-from sqlalchemy.ext.asyncio import async_sessionmaker
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy import select, MetaData, Table, Column, VARCHAR, INTEGER
 
 from lesscode_database.connection_info import ConnectionInfo
-from lesscode_database.options import options
+from lesscode_database.db_options import db_options
+from lesscode_database.ds_helper import DsHelper
 
-options.conn_list = [
+db_options.conn_list = [
     ConnectionInfo(dialect="mysql", name="mysql", host="127.0.0.1", port=3306, user="root",
                    password="root", db_name="test", enable=False, params={"pool_recycle": 3600},
                    async_enable=True),
@@ -66,8 +65,9 @@ options.conn_list = [
 
 ]
 
+
 # mysql 同步测试，async_enable=False
-with options.mysql.dedicated_connection() as conn:
+with DsHelper("mysql").pool.dedicated_connection() as conn:
     conn.ping(reconnect=True)
     with conn.cursor() as cursor:
         cursor.execute("select 1")
@@ -78,7 +78,7 @@ with options.mysql.dedicated_connection() as conn:
 
 # mysql 异步测试，async_enable=True
 async def async_mysql_test():
-    async with options.mysql.acquire() as conn:
+    async with DsHelper("mysql").pool.acquire() as conn:
         async with conn.cursor() as cursor:
             await cursor.execute("select 1")
             rs = await cursor.fetchone()
@@ -89,7 +89,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_mysql_test())
 
 # doris 同步测试，async_enable=False
-with options.doris.dedicated_connection() as conn:
+with DsHelper("doris").pool.dedicated_connection() as conn:
     conn.ping(reconnect=True)
     with conn.cursor() as cursor:
         cursor.execute("select 1")
@@ -100,7 +100,7 @@ with options.doris.dedicated_connection() as conn:
 
 # doris 异步测试，async_enable=True
 async def async_doris_test():
-    async with options.doris.acquire() as conn:
+    async with DsHelper("doris").pool.acquire() as conn:
         async with conn.cursor() as cursor:
             await cursor.execute("select 1")
             rs = await cursor.fetchone()
@@ -111,7 +111,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_doris_test())
 
 # ocean_base 同步测试，async_enable=False
-with options.ocean_base.dedicated_connection() as conn:
+with DsHelper("ocean_base").pool.dedicated_connection() as conn:
     conn.ping(reconnect=True)
     with conn.cursor() as cursor:
         cursor.execute("select 1")
@@ -122,7 +122,7 @@ with options.ocean_base.dedicated_connection() as conn:
 
 # ocean_base 异步测试，async_enable=True
 async def async_ocean_base_test():
-    async with options.ocean_base.acquire() as conn:
+    async with DsHelper("ocean_base").pool.acquire() as conn:
         async with conn.cursor() as cursor:
             await cursor.execute("select 1")
             rs = await cursor.fetchone()
@@ -133,7 +133,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_ocean_base_test())
 
 # tidb 同步测试，async_enable=False
-with options.tidb.dedicated_connection() as conn:
+with DsHelper("tidb").pool.dedicated_connection() as conn:
     conn.ping(reconnect=True)
     with conn.cursor() as cursor:
         cursor.execute("select 1")
@@ -144,7 +144,7 @@ with options.tidb.dedicated_connection() as conn:
 
 # tidb 异步测试，async_enable=True
 async def async_tidb_test():
-    async with options.tidb.acquire() as conn:
+    async with DsHelper("tidb").pool.acquire() as conn:
         async with conn.cursor() as cursor:
             await cursor.execute("select 1")
             rs = await cursor.fetchone()
@@ -157,7 +157,7 @@ loop.run_until_complete(async_tidb_test())
 
 # sqlite3 异步测试
 async def async_sqlite3_test():
-    cur = await options.sqlite3.cursor()
+    cur = await DsHelper("sqlite3").pool.cursor()
     await cur.execute("SELECT 1")
     row = await cur.fetchone()
     print(row)
@@ -167,7 +167,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_sqlite3_test())
 
 # sqlite3 同步测试
-cursor = options.sqlite3.cursor()
+cursor = DsHelper("sqlite3").pool.cursor()
 cursor.execute('select 1')
 row = cursor.fetchone()
 print(row)
@@ -181,7 +181,7 @@ body = {
     },
     "size": 1
 }
-resp = options.es.search(
+resp = DsHelper("es").pool.search(
     index="test",
     body=body
 )
@@ -190,7 +190,7 @@ print(resp)
 
 # es异步测试，async_enable=True
 async def async_es_test():
-    resp = await options.es.search(
+    resp = await DsHelper("es").pool.search(
         index="test",
         body={"query": {"match_all": {}}},
         size=1,
@@ -202,7 +202,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_es_test())
 
 # sql server同步测试
-cursor = options.mssql.cursor()
+cursor = DsHelper("mssql").pool.cursor()
 cursor.execute('SELECT 1')
 row = cursor.fetchone()
 print(row)
@@ -210,7 +210,7 @@ print(row)
 # sql server暂不支持异步测试
 
 # oracle 同步测试
-cursor = options.oracle.cursor()
+cursor = DsHelper("oracle").pool.cursor()
 cursor.execute('select 1')
 row = cursor.fetchone()
 print(row)
@@ -219,12 +219,12 @@ print(row)
 
 
 # mongo同步测试，async_enable=False
-print(options.mongo.test.test.find_one())
+print(DsHelper("mongo").pool.test.test.find_one())
 
 
 # mongo异步测试，async_enable=True
 async def async_mongo_test():
-    resp = await options.mongo.test.test.find_one()
+    resp = await DsHelper("mongo").pool.test.test.find_one()
     print(resp)
 
 
@@ -232,15 +232,16 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_mongo_test())
 
 # nebula同步测试，async_enable=False
-with options.nebula.session_context("root", "nebula") as session:
-    session.execute(f'USE test')
-    result = session.execute("match (t:Test) return t limit 1")
+with DsHelper("nebula").make_nebula_session() as session:
+    session.execute(f'USE core')
+    result = session.execute("match (c:Company) return c limit 1")
     print(result)
 
+print(DsHelper("nebula").exec_nebula_gql("match (c:Company) return c limit 1", "core"))
 # nebula暂不支持异步
 
 # postgresql同步测试，async_enable=False
-with options.postgresql.connection() as conn:
+with DsHelper("postgresql").pool.connection() as conn:
     with conn.cursor() as cursor:
         cursor.execute("select 1")
         rs = cursor.fetchone()
@@ -249,7 +250,7 @@ with options.postgresql.connection() as conn:
 
 # postgresql异步测试，async_enable=True
 async def async_pg_test():
-    async with options.postgresql.acquire() as conn:
+    async with DsHelper("postgresql").pool.acquire() as conn:
         async with conn.cursor() as cur:
             await cur.execute("select 1")
             rs = await cur.fetchone()
@@ -260,12 +261,12 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(async_pg_test())
 
 # redis 同步测试，async_enable=False
-print(options.redis.exists("test"))
+print(DsHelper("redis").pool.exists("test"))
 
 
 # redis 异步测试，async_enable=True
 async def async_redis_test():
-    rs = await options.redis.exists("test")
+    rs = await DsHelper("redis").pool.exists("test")
     print(rs)
 
 
@@ -279,52 +280,49 @@ t1 = Table("test_user", meta, Column("name", VARCHAR(collation='utf8mb3_bin', le
                   server_default=None))
 
 # sqlalchemy同步测试，async_enable=False
-with sessionmaker(bind=options.sqlalchemy)() as session:
+with DsHelper("sqlalchemy").make_sqlalchemy_session() as session:
     cur = session.execute(select(t1))
     print(cur.fetchall())
 
 
 # sqlalchemy异步测试，async_enable=True
 async def async_sqlalchemy_test():
-    async with async_sessionmaker(options.sqlalchemy)() as session:
+    async with DsHelper("sqlalchemy").async_make_sqlalchemy_session() as session:
         cur = await session.execute(select(t1))
-
         print(cur.fetchall())
 
 
 loop = asyncio.get_event_loop()
 loop.run_until_complete(async_sqlalchemy_test())
 
-
 # neo4j同步测试
 def query(tx):
-    nql = "MATCH (c:Company) return c limit 1"
+    nql = "match (p:Person) return p"
     for record in tx.run(nql):
         print(record)
 
 
-with options.neo4j.session(database="invest") as session:
+with DsHelper("neo4j").make_neo4j_session() as session:
     session.execute_read(query)
 
-
 # neo4j异步测试
 async def query(tx):
-    nql = "MATCH (c:Company) return c limit 1"
+    nql = "match (p:Person) return p"
     res = await tx.run(nql)
     async for record in res:
         print(record)
 
-
 async def async_neo4j_test():
-    async with options.neo4j.session(database="invest") as session:
+    async with DsHelper("neo4j").async_make_neo4j_session() as session:
         await session.execute_read(query)
 
 
 loop = asyncio.get_event_loop()
 loop.run_until_complete(async_neo4j_test())
 
+
 # clickhouse 同步测试
-with options.clickhouse as conn:
+with DsHelper("clickhouse").pool.dedicated_connection() as conn:
     with conn.cursor() as cursor:
         cursor.execute('SELECT 1')
         print(cursor.fetchall())
@@ -332,7 +330,7 @@ with options.clickhouse as conn:
 
 # clickhouse 异步测试测试
 async def async_clickhouse_test():
-    async with options.clickhouse.acquire() as conn:
+    async with DsHelper("clickhouse").pool.acquire() as conn:
         async with conn.cursor() as cursor:
             await cursor.execute("SELECT 1")
             ret = await cursor.fetchone()
@@ -342,5 +340,4 @@ async def async_clickhouse_test():
 loop = asyncio.get_event_loop()
 loop.run_until_complete(async_clickhouse_test())
 
-
 ```

lesscode_database-0.0.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+lesscode_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lesscode_database/connect_pool.py,sha256=w6qmo3Zj3aUmw8G83LMoMU3D-sz7rN6_QGcQqy39Y1w,39145
+lesscode_database/connection_info.py,sha256=HMlA-hA0LE7jGUS8crZAgrBMB-o6B9mxrWYEywgqXHg,1307
+lesscode_database/db_options.py,sha256=Z8Iy3pqDYW5YVVfvoFSsAYecK9LfiwRasYc3fzqIBt8,1928
+lesscode_database/ds_helper.py,sha256=MKAh7BUKWmGCnTPExiXQ9bzvSjY_gZU1isjtAkN-3rQ,3324
+lesscode_database/dynamic_import_package.py,sha256=J8hgGRHe6KrprOgOq-xbKHVAYHSjUBcNyTaSPvBmvIk,164
+lesscode_database/version.py,sha256=QiiYsv0kcJaB8wCWyT-FnI2b6be87HA-CrrIUn8LQhg,22
+lesscode_database-0.0.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lesscode_database-0.0.6.dist-info/METADATA,sha256=HVI7lXSlWpSX51Yg_7MuSYHhbWmXI1FQiQQvmtYsOeE,11059
+lesscode_database-0.0.6.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+lesscode_database-0.0.6.dist-info/top_level.txt,sha256=h6cg13be6kkDfNaX9nWeDcfducTb5bKG5iYRO2JPmAM,18
+lesscode_database-0.0.6.dist-info/RECORD,,

lesscode_database-0.0.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-lesscode_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lesscode_database/connect_pool.py,sha256=TBtr0qWEflTHl2c_5mLYSqVweLrnO0Mm62Ms7j6PnRA,39136
-lesscode_database/connection_info.py,sha256=atUWd3lr8G67ZtNPEA2sw_rlAsxVoz6OJasWVzU8els,1194
-lesscode_database/options.py,sha256=zrXxWXmTg5NpgdfzWoG7nIx259QQ6R-87Q7ZDMyUv7c,1900
-lesscode_database/version.py,sha256=1mptEzQihbdyqqzMgdns_j5ZGK9gz7hR2bsgA_TnjO4,22
-lesscode_database-0.0.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lesscode_database-0.0.4.dist-info/METADATA,sha256=gV9fjgRtugsQdZGbdc2ip3dHjZHJFrLh3n1ksFTSBQA,10787
-lesscode_database-0.0.4.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-lesscode_database-0.0.4.dist-info/top_level.txt,sha256=h6cg13be6kkDfNaX9nWeDcfducTb5bKG5iYRO2JPmAM,18
-lesscode_database-0.0.4.dist-info/RECORD,,