BatisX 2.2.1__tar.gz → 2.2.2__tar.gz

{batisx-2.2.1 → batisx-2.2.2}/PKG-INFO

@@ -1,165 +1,165 @@
-Metadata-Version: 2.1
-Name: batisx
-Version: 2.2.1
-Summary: A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.
-Home-page: https://gitee.com/summry/batisx
-Author: summy
-Author-email: xiazhongbiao@126.com
-License: UNKNOWN
-Keywords: sql,MySQL,PostgreSQL,MyBatis,python
-Platform: UNKNOWN
-Requires-Python: >=3.5
-Description-Content-Type: text/markdown
-
-Mapper file
-'''''''''''
-
-Create a mapper file in 'mapper' folder, you can named
-'person_mapper.xml', like follow:
-
-.. code:: xml
-
-       <?xml version="1.0" encoding="UTF-8"?>
-       <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://gitee.com/summry/batisx/blob/master/dtd/mapper.dtd">
-       <mapper namespace="person">
-           <select id="select_all">
-               select id, name, age from person
-            </select>
-
-            <select id="select_by_name">
-               select id, name, age from person where name = ?
-            </select>
-
-            <select id="select_by_name2">
-               select id, name, age from person where name = :name
-            </select>
-
-            <select id="select_include" include="select_all">
-               {{ select_all }}
-                 {% if name -%}
-                  where name = :name
-                 {%- endif -%}
-            </select>
-       </mapper>
-
-Usage Sample
-''''''''''''
-
-.. code:: python
-
-    from typing import List, Tuple, Mapping
-    from batisx import mapper, sql, dbx, init_db
-
-    @mapper(namespace='person')
-    def select_all(): List
-
-    @mapper(namespace='person')
-    def select_by_name(name: str): List
-
-    @mapper(namespace='person')
-    def select_by_name2(name: str): List
-
-    @mapper(namespace='person')
-    def select_include(name: str): List
-
-    @sql('select id, name, age from person where name = ?')
-    def query_by_name(name: str): List(Mapping)
-
-    @sql('select id, name, age from person where name = :name')
-    def query_by_name2(name: str): List(Mapping)
-
-    if __name__ == '__main__':
-        # init_db('test.db', driver='sqlite3', show_sql=True, debug=True, mapper_path='./mapper')
-        # init_db("postgres://user:password@127.0.0.1:5432/testdb", driver='psycopg2', pool_size=5, mapper_path='./mapper')
-        init_db(host='127.0.0.1', port='3306', user='xxx', password='xxx', database='test', pool_size=5, show_sql=True, mapper_path='./mapper')
-
-        persons = select_all()
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-
-        persons = select_by_name('zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = select_by_name2(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = select_include(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = query_by_name('zhangsan')
-        # result:
-        # {'id': 3, 'name': 'zhangsan', 'age': 15}
-
-        persons = query_by_name2(name='zhangsan')
-        # result:
-        # {'id': 3, 'name': 'zhangsan', 'age': 15}
-       
-        # you can use dbx execute mapper sql with full sql id: namespace join sql id
-        persons = dbx.select('person.select_all')  # 'person' is namespace, 'select_all' is sql id
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-
-        persons = dbx.select('person.select_by_name', name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = dbx.sql('person.select_by_name').select(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        # you can direct execute sql with db
-        effected_rowcount = db.insert(table='person', name='zhaoliu', age=66)
-
-        persons = db.select('select id, name, age from person')
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-        # (6, 'zhaoliu', 45)
-
-        persons = db.query('select id, name, age from person name = :name', name='zhangsan')
-        # result:
-        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
-
-        persons = db.sql('select id, name, age from person name = :name').query(name='zhangsan')
-        # result:
-        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
-
-        persons = db.select('select id, name, age from person where name = ?', 'zhangsan')
-        # result:
-        # [(3, 'zhangsan', 15)]
-
-
-Transaction
-'''''''''''
-
-.. code:: python
-
-        from batisx import with_transaction, transaction
-
-        @with_transaction
-        def test_transaction():
-            insert_func(....)
-            update_func(....)
-
-
-        def test_transaction2():
-            with transaction():
-                insert_func(....)
-                update_func(....)
-
-
-If you want to operate MySQL database, may be you need MySqlx: https://pypi.org/project/mysqlx
-
-If you want to operate PostgreSQL database, may be you need MySqlx: https://pypi.org/project/pgsqlx
-
-If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlx-exec
-
-
+Metadata-Version: 2.1
+Name: batisx
+Version: 2.2.2
+Summary: A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.
+Home-page: https://gitee.com/summry/batisx
+Author: summy
+Author-email: xiazhongbiao@126.com
+License: UNKNOWN
+Keywords: sql,MySQL,PostgreSQL,MyBatis,python
+Platform: UNKNOWN
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+
+Mapper file
+'''''''''''
+
+Create a mapper file in 'mapper' folder, you can named
+'person_mapper.xml', like follow:
+
+.. code:: xml
+
+       <?xml version="1.0" encoding="UTF-8"?>
+       <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://gitee.com/summry/batisx/blob/master/dtd/mapper.dtd">
+       <mapper namespace="person">
+           <select id="select_all">
+               select id, name, age from person
+            </select>
+
+            <select id="select_by_name">
+               select id, name, age from person where name = ?
+            </select>
+
+            <select id="select_by_name2">
+               select id, name, age from person where name = :name
+            </select>
+
+            <select id="select_include" include="select_all">
+               {{ select_all }}
+                 {% if name -%}
+                  where name = :name
+                 {%- endif -%}
+            </select>
+       </mapper>
+
+Usage Sample
+''''''''''''
+
+.. code:: python
+
+    from typing import List, Tuple, Mapping
+    from batisx import mapper, sql, dbx, init_db
+
+    @mapper(namespace='person')
+    def select_all(): List
+
+    @mapper(namespace='person')
+    def select_by_name(name: str): List
+
+    @mapper(namespace='person')
+    def select_by_name2(name: str): List
+
+    @mapper(namespace='person')
+    def select_include(name: str): List
+
+    @sql('select id, name, age from person where name = ?')
+    def query_by_name(name: str): List(Mapping)
+
+    @sql('select id, name, age from person where name = :name')
+    def query_by_name2(name: str): List(Mapping)
+
+    if __name__ == '__main__':
+        # init_db('test.db', driver='sqlite3', show_sql=True, debug=True, mapper_path='./mapper')
+        # init_db("postgres://user:password@127.0.0.1:5432/testdb", driver='psycopg2', pool_size=5, mapper_path='./mapper')
+        init_db(host='127.0.0.1', port='3306', user='xxx', password='xxx', database='test', pool_size=5, show_sql=True, mapper_path='./mapper')
+
+        persons = select_all()
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+
+        persons = select_by_name('zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = select_by_name2(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = select_include(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = query_by_name('zhangsan')
+        # result:
+        # {'id': 3, 'name': 'zhangsan', 'age': 15}
+
+        persons = query_by_name2(name='zhangsan')
+        # result:
+        # {'id': 3, 'name': 'zhangsan', 'age': 15}
+       
+        # you can use dbx execute mapper sql with full sql id: namespace join sql id
+        persons = dbx.select('person.select_all')  # 'person' is namespace, 'select_all' is sql id
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+
+        persons = dbx.select('person.select_by_name', name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = dbx.sql('person.select_by_name').select(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        # you can direct execute sql with db
+        effected_rowcount = db.insert(table='person', name='zhaoliu', age=66)
+
+        persons = db.select('select id, name, age from person')
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+        # (6, 'zhaoliu', 45)
+
+        persons = db.query('select id, name, age from person name = :name', name='zhangsan')
+        # result:
+        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
+
+        persons = db.sql('select id, name, age from person name = :name').query(name='zhangsan')
+        # result:
+        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
+
+        persons = db.select('select id, name, age from person where name = ?', 'zhangsan')
+        # result:
+        # [(3, 'zhangsan', 15)]
+
+
+Transaction
+'''''''''''
+
+.. code:: python
+
+        from batisx import with_transaction, transaction
+
+        @with_transaction
+        def test_transaction():
+            insert_func(....)
+            update_func(....)
+
+
+        def test_transaction2():
+            with transaction():
+                insert_func(....)
+                update_func(....)
+
+
+If you want to operate MySQL database, may be you need MySqlx: https://pypi.org/project/mysqlx
+
+If you want to operate PostgreSQL database, may be you need MySqlx: https://pypi.org/project/pgsqlx
+
+If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlexecx
+
+

{batisx-2.2.1 → batisx-2.2.2}/README.rst

@@ -147,4 +147,4 @@ If you want to operate MySQL database, may be you need MySqlx: https://pypi.org/
 
 If you want to operate PostgreSQL database, may be you need MySqlx: https://pypi.org/project/pgsqlx
 
-If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlx-exec
+If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlexecx

{batisx-2.2.1 → batisx-2.2.2}/batisx/__init__.py

@@ -1,13 +1,13 @@
-from mysqlx import (
-    connection,
-    transaction,
-    with_connection,
-    with_transaction,
-    get_connection,
-    close,
-    Driver,
-    Dialect,
-    init_db
-)
-from .sql_mapper import sql, mapper
-
+from mysqlx import (
+    connection,
+    transaction,
+    with_connection,
+    with_transaction,
+    get_connection,
+    close,
+    Driver,
+    Dialect,
+    init_db
+)
+from .sql_mapper import sql, mapper
+

{batisx-2.2.1 → batisx-2.2.2}/batisx/db.py

@@ -1,33 +1,33 @@
-from mysqlx import sql_support
-# Don't remove. Import for not repetitive implementation
-from sqlexecx import save_select_key, do_save_sql_select_key
-from mysqlx.db import insert, save, execute, batch_insert, batch_execute, get, query, query_one, select, select_one, \
-    do_execute, do_get, do_query, do_query_one, do_select, do_select_one, do_select_page, do_query_page, select_page, query_page,\
-    do_save_sql, drop_table, truncate_table, sql, table, page
-
-
-def save_sql(sql: str, *args, **kwargs):
-    """
-    Insert data into table, return primary key.
-    :param select_key: sql for select primary key
-    :param sql: SQL
-    :param args:
-    :return: Primary key
-    """
-    sql, args = sql_support.try_dynamic_sql('batisx.db.save_sql', sql, *args, **kwargs)
-    return do_save_sql(sql, *args)
-
-
-def save_sql_select_key(select_key: str, sql: str, *args, **kwargs):
-    """
-    Insert data into table, return primary key.
-    :param select_key: sql for select primary key
-    :param sql: SQL
-    :param args:
-    :return: Primary key
-    """
-    sql, args = sql_support.try_dynamic_sql('batisx.db.save_sql', sql, *args, **kwargs)
-    return do_save_sql_select_key(select_key, sql, *args)
-
-
-from .sql_page_exec import sql, page
+from mysqlx import sql_support
+# Don't remove. Import for not repetitive implementation
+from sqlexecx import save_select_key, do_save_sql_select_key
+from mysqlx.db import insert, save, execute, batch_insert, batch_execute, get, query, query_one, select, select_one, \
+    do_execute, do_get, do_query, do_query_one, do_select, do_select_one, do_select_page, do_query_page, select_page, query_page,\
+    do_save_sql, drop_table, truncate_table, sql, table, page
+
+
+def save_sql(sql: str, *args, **kwargs):
+    """
+    Insert data into table, return primary key.
+    :param select_key: sql for select primary key
+    :param sql: SQL
+    :param args:
+    :return: Primary key
+    """
+    sql, args = sql_support.try_dynamic_sql('batisx.db.save_sql', sql, *args, **kwargs)
+    return do_save_sql(sql, *args)
+
+
+def save_sql_select_key(select_key: str, sql: str, *args, **kwargs):
+    """
+    Insert data into table, return primary key.
+    :param select_key: sql for select primary key
+    :param sql: SQL
+    :param args:
+    :return: Primary key
+    """
+    sql, args = sql_support.try_dynamic_sql('batisx.db.save_sql', sql, *args, **kwargs)
+    return do_save_sql_select_key(select_key, sql, *args)
+
+
+from .sql_page_exec import sql, page

{batisx-2.2.1 → batisx-2.2.2}/batisx/dbx.py

@@ -1,32 +1,32 @@
-from mysqlx import sql_holder as holder
-from mysqlx.dbx import batch_execute, execute, get, query, query_one, select, select_one, select_page, query_page, sql, page
-
-from . import db
-from .log_support import logger, sql_id_log, page_sql_id_log, sql_id_select_key_log
-
-
-def save(sql_id: str, *args, **kwargs):
-    """
-    Execute insert SQL, return primary key.
-    :return: Primary key
-    """
-    sql_id_log('save', sql_id, *args, **kwargs)
-    sql_model = holder.get_sql_model(sql_id)
-    select_key = sql_model.select_key
-    sql, args = holder.do_get_sql(sql_model, False, None, *args, **kwargs)
-    if select_key:
-        return db.do_save_sql_select_key(select_key, sql, *args)
-    return db.do_save_sql(sql, *args)
-
-
-def save_select_key(select_key, sql_id: str, *args, **kwargs):
-    """
-    Execute insert SQL, return primary key.
-    :return: Primary key
-    """
-    sql_id_select_key_log('save_select_key', select_key, sql_id, *args, **kwargs)
-    sql, args = holder.get_sql(sql_id, *args, **kwargs)
-    return db.do_save_sql_select_key(select_key, sql, *args)
-
-
-from .sql_id_exec import sql, page
+from mysqlx import sql_holder as holder
+from mysqlx.dbx import batch_execute, execute, get, query, query_one, select, select_one, select_page, query_page, sql, page
+
+from . import db
+from .log_support import logger, sql_id_log, page_sql_id_log, sql_id_select_key_log
+
+
+def save(sql_id: str, *args, **kwargs):
+    """
+    Execute insert SQL, return primary key.
+    :return: Primary key
+    """
+    sql_id_log('save', sql_id, *args, **kwargs)
+    sql_model = holder.get_sql_model(sql_id)
+    select_key = sql_model.select_key
+    sql, args = holder.do_get_sql(sql_model, False, None, *args, **kwargs)
+    if select_key:
+        return db.do_save_sql_select_key(select_key, sql, *args)
+    return db.do_save_sql(sql, *args)
+
+
+def save_select_key(select_key, sql_id: str, *args, **kwargs):
+    """
+    Execute insert SQL, return primary key.
+    :return: Primary key
+    """
+    sql_id_select_key_log('save_select_key', select_key, sql_id, *args, **kwargs)
+    sql, args = holder.get_sql(sql_id, *args, **kwargs)
+    return db.do_save_sql_select_key(select_key, sql, *args)
+
+
+from .sql_id_exec import sql, page

{batisx-2.2.1 → batisx-2.2.2}/batisx/log_support.py

@@ -1,13 +1,13 @@
-from mysqlx.log_support import logger
-
-
-def page_sql_id_log(function: str, sql_id: str, page_num, page_size, *args, **kwargs):
-    logger.debug("Exec func 'batisx.dbx.%s', page_num: %d, page_size: %d, sql_id: %s, args: %s, kwargs: %s" % (function, page_num, page_size, sql_id, args, kwargs))
-
-
-def sql_id_log(function: str, sql_id: str, *args, **kwargs):
-    logger.debug("Exec func '%s', sql_id: %s, args: %s, kwargs: %s" % (function, sql_id.strip(), args, kwargs))
-
-
-def sql_id_select_key_log(function: str, select_key: str, sql_id: str, *args, **kwargs):
-    logger.debug("Exec func 'batisx.dbx.%s', select_key: %s, sql_id: %s, args: %s, kwargs: %s" % (function, select_key, sql_id.strip(), args, kwargs))
+from mysqlx.log_support import logger
+
+
+def page_sql_id_log(function: str, sql_id: str, page_num, page_size, *args, **kwargs):
+    logger.debug("Exec func 'batisx.dbx.%s', page_num: %d, page_size: %d, sql_id: %s, args: %s, kwargs: %s" % (function, page_num, page_size, sql_id, args, kwargs))
+
+
+def sql_id_log(function: str, sql_id: str, *args, **kwargs):
+    logger.debug("Exec func '%s', sql_id: %s, args: %s, kwargs: %s" % (function, sql_id.strip(), args, kwargs))
+
+
+def sql_id_select_key_log(function: str, select_key: str, sql_id: str, *args, **kwargs):
+    logger.debug("Exec func 'batisx.dbx.%s', select_key: %s, sql_id: %s, args: %s, kwargs: %s" % (function, select_key, sql_id.strip(), args, kwargs))

{batisx-2.2.1 → batisx-2.2.2}/batisx/sql_id_exec.py

@@ -1,25 +1,25 @@
-from . import dbx
-from mysqlx.sql_id_exec import SqlExec as _SqlExec
-from sqlexecx.page_exec import PageExec
-
-
-class SqlExec(_SqlExec):
-
-    def save_select_key(self, select_key: str, *args, **kwargs):
-        """
-        Insert data into table, return primary key.
-
-        :param select_key: sql for select primary key
-        :param args:
-        :return: Primary key
-        """
-        return self.exec.save_select_key(select_key, self.sql, *args, **kwargs)
-
-
-def sql(sql: str) :
-    assert sql, "Parameter 'sql' must not be none"
-    return SqlExec(dbx, sql)
-
-
-def page(page_num: int, page_size: int) :
-    return PageExec(dbx, page_num, page_size)
+from . import dbx
+from mysqlx.sql_id_exec import SqlExec as _SqlExec
+from sqlexecx.page_exec import PageExec
+
+
+class SqlExec(_SqlExec):
+
+    def save_select_key(self, select_key: str, *args, **kwargs):
+        """
+        Insert data into table, return primary key.
+
+        :param select_key: sql for select primary key
+        :param args:
+        :return: Primary key
+        """
+        return self.exec.save_select_key(select_key, self.sql, *args, **kwargs)
+
+
+def sql(sql: str) :
+    assert sql, "Parameter 'sql' must not be none"
+    return SqlExec(dbx, sql)
+
+
+def page(page_num: int, page_size: int) :
+    return PageExec(dbx, page_num, page_size)

{batisx-2.2.1 → batisx-2.2.2}/batisx/sql_mapper.py

@@ -1,82 +1,82 @@
-import os
-import sqlexecx
-import functools
-from .log_support import logger
-from mysqlx.support import SqlAction, DBError
-from mysqlx.sql_support import simple_sql, get_named_sql_args
-from mysqlx.sql_holder import get_sql_model, do_get_sql, build_sql_id
-from mysqlx.sql_mapper import get_exec_func, get_select_func, before
-
-_UPDATE_ACTIONS = (SqlAction.INSERT.value, SqlAction.UPDATE.value, SqlAction.DELETE.value, SqlAction.CALL.value)
-
-
-def mapper(namespace: str = None, sql_id: str = None, batch=False, return_key=False, select_key=None):
-    def _decorator(func):
-        @functools.wraps(func)
-        def _wrapper(*args, **kwargs):
-            param_names = func.__code__.co_varnames
-            full_sql_id, func_name = before(func, namespace, sql_id, *args, **kwargs)
-            sql_model = get_sql_model(full_sql_id)
-            exec_func = get_exec_func(func, sql_model.action, batch)
-            if return_key:
-                use_select_key = select_key
-                use_sql, args = do_get_sql(sql_model, batch, param_names, *args, **kwargs)
-                if use_select_key is None:
-                    use_select_key = sql_model.select_key
-                    if use_select_key is None:
-                        try:
-                            use_select_key = sqlexecx.Dialect.get_select_key(sql=use_sql)
-                        except NotImplementedError:
-                            return DBError(
-                                f"Expect 'select_key' but not. you can set it in mapper file with 'selectKey', or @mapper with 'select_key'")
-                return sqlexecx.do_save_sql_select_key(use_select_key, use_sql, *args)
-            if batch:
-                if kwargs:
-                    logger.warning("Batch exec sql better use like '{}(args)' or '{}(*args)' then '{}(args=args)'".format(func_name, func_name, func_name))
-                    args = list(kwargs.values())[0]
-                use_sql, _ = do_get_sql(sql_model, batch, param_names, *args)
-            else:
-                use_sql, args = do_get_sql(sql_model, batch, param_names, *args, **kwargs)
-            return exec_func(use_sql, *args)
-
-        return _wrapper
-
-    return _decorator
-
-
-def sql(value: str, batch=False, return_key=False, select_key=None):
-    def _decorator(func):
-        @functools.wraps(func)
-        def _wrapper(*args, **kwargs):
-            use_sql = value
-            low_sql = value.lower()
-            if any([action in low_sql for action in _UPDATE_ACTIONS]):
-                if batch:
-                    if kwargs:
-                        args = list(kwargs.values())[0]
-                    return sqlexecx.batch_execute(use_sql, *args)
-                if return_key:
-                    use_select_key = select_key
-                    if use_select_key is None:
-                        try:
-                            use_select_key = sqlexecx.Dialect.get_select_key(sql=use_sql)
-                        except NotImplementedError:
-                            return DBError(f"Expect 'select_key' but not in func '{func.__name__}' at file: '{func.__code__.co_filename}', line {func.__code__.co_firstlineno}. you can set it @sql with 'select_key'")
-                    assert SqlAction.INSERT.value in low_sql, 'Only insert sql can return primary key.'
-                    if kwargs:
-                        use_sql, args = get_named_sql_args(use_sql, **kwargs)
-                    return sqlexecx.do_save_sql_select_key(use_select_key, use_sql, *args)
-
-                if kwargs:
-                    use_sql, args = get_named_sql_args(use_sql, **kwargs)
-                return sqlexecx.do_execute(use_sql, *args)
-            elif SqlAction.SELECT.value in low_sql:
-                select_func = get_select_func(func)
-                use_sql, args = simple_sql(use_sql, *args, **kwargs)
-                return select_func(use_sql, *args)
-            else:
-                return ValueError("Invalid sql: {}.".format(sql))
-
-        return _wrapper
-
-    return _decorator
+import os
+import sqlexecx
+import functools
+from .log_support import logger
+from mysqlx.support import SqlAction, DBError
+from mysqlx.sql_support import simple_sql, get_named_sql_args
+from mysqlx.sql_holder import get_sql_model, do_get_sql, build_sql_id
+from mysqlx.sql_mapper import get_exec_func, get_select_func, before
+
+_UPDATE_ACTIONS = (SqlAction.INSERT.value, SqlAction.UPDATE.value, SqlAction.DELETE.value, SqlAction.CALL.value)
+
+
+def mapper(namespace: str = None, sql_id: str = None, batch=False, return_key=False, select_key=None):
+    def _decorator(func):
+        @functools.wraps(func)
+        def _wrapper(*args, **kwargs):
+            param_names = func.__code__.co_varnames
+            full_sql_id, func_name = before(func, namespace, sql_id, *args, **kwargs)
+            sql_model = get_sql_model(full_sql_id)
+            exec_func = get_exec_func(func, sql_model.action, batch)
+            if return_key:
+                use_select_key = select_key
+                use_sql, args = do_get_sql(sql_model, batch, param_names, *args, **kwargs)
+                if use_select_key is None:
+                    use_select_key = sql_model.select_key
+                    if use_select_key is None:
+                        try:
+                            use_select_key = sqlexecx.Dialect.get_select_key(sql=use_sql)
+                        except NotImplementedError:
+                            return DBError(
+                                f"Expect 'select_key' but not. you can set it in mapper file with 'selectKey', or @mapper with 'select_key'")
+                return sqlexecx.do_save_sql_select_key(use_select_key, use_sql, *args)
+            if batch:
+                if kwargs:
+                    logger.warning("Batch exec sql better use like '{}(args)' or '{}(*args)' then '{}(args=args)'".format(func_name, func_name, func_name))
+                    args = list(kwargs.values())[0]
+                use_sql, _ = do_get_sql(sql_model, batch, param_names, *args)
+            else:
+                use_sql, args = do_get_sql(sql_model, batch, param_names, *args, **kwargs)
+            return exec_func(use_sql, *args)
+
+        return _wrapper
+
+    return _decorator
+
+
+def sql(value: str, batch=False, return_key=False, select_key=None):
+    def _decorator(func):
+        @functools.wraps(func)
+        def _wrapper(*args, **kwargs):
+            use_sql = value
+            low_sql = value.lower()
+            if any([action in low_sql for action in _UPDATE_ACTIONS]):
+                if batch:
+                    if kwargs:
+                        args = list(kwargs.values())[0]
+                    return sqlexecx.batch_execute(use_sql, *args)
+                if return_key:
+                    use_select_key = select_key
+                    if use_select_key is None:
+                        try:
+                            use_select_key = sqlexecx.Dialect.get_select_key(sql=use_sql)
+                        except NotImplementedError:
+                            return DBError(f"Expect 'select_key' but not in func '{func.__name__}' at file: '{func.__code__.co_filename}', line {func.__code__.co_firstlineno}. you can set it @sql with 'select_key'")
+                    assert SqlAction.INSERT.value in low_sql, 'Only insert sql can return primary key.'
+                    if kwargs:
+                        use_sql, args = get_named_sql_args(use_sql, **kwargs)
+                    return sqlexecx.do_save_sql_select_key(use_select_key, use_sql, *args)
+
+                if kwargs:
+                    use_sql, args = get_named_sql_args(use_sql, **kwargs)
+                return sqlexecx.do_execute(use_sql, *args)
+            elif SqlAction.SELECT.value in low_sql:
+                select_func = get_select_func(func)
+                use_sql, args = simple_sql(use_sql, *args, **kwargs)
+                return select_func(use_sql, *args)
+            else:
+                return ValueError("Invalid sql: {}.".format(sql))
+
+        return _wrapper
+
+    return _decorator

{batisx-2.2.1 → batisx-2.2.2}/batisx/sql_page_exec.py

@@ -1,12 +1,12 @@
-from . import db
-from sqlexecx.sql_exec import SqlExec
-from sqlexecx.page_exec import PageExec
-
-
-def sql(sql: str) :
-    assert sql, "Parameter 'sql' must not be none"
-    return SqlExec(db, sql)
-
-
-def page(page_num: int, page_size: int) :
-    return PageExec(db, page_num, page_size)
+from . import db
+from sqlexecx.sql_exec import SqlExec
+from sqlexecx.page_exec import PageExec
+
+
+def sql(sql: str) :
+    assert sql, "Parameter 'sql' must not be none"
+    return SqlExec(db, sql)
+
+
+def page(page_num: int, page_size: int) :
+    return PageExec(db, page_num, page_size)

{batisx-2.2.1 → batisx-2.2.2}/batisx.egg-info/PKG-INFO

@@ -1,165 +1,165 @@
-Metadata-Version: 2.1
-Name: batisx
-Version: 2.2.1
-Summary: A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.
-Home-page: https://gitee.com/summry/batisx
-Author: summy
-Author-email: xiazhongbiao@126.com
-License: UNKNOWN
-Keywords: sql,MySQL,PostgreSQL,MyBatis,python
-Platform: UNKNOWN
-Requires-Python: >=3.5
-Description-Content-Type: text/markdown
-
-Mapper file
-'''''''''''
-
-Create a mapper file in 'mapper' folder, you can named
-'person_mapper.xml', like follow:
-
-.. code:: xml
-
-       <?xml version="1.0" encoding="UTF-8"?>
-       <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://gitee.com/summry/batisx/blob/master/dtd/mapper.dtd">
-       <mapper namespace="person">
-           <select id="select_all">
-               select id, name, age from person
-            </select>
-
-            <select id="select_by_name">
-               select id, name, age from person where name = ?
-            </select>
-
-            <select id="select_by_name2">
-               select id, name, age from person where name = :name
-            </select>
-
-            <select id="select_include" include="select_all">
-               {{ select_all }}
-                 {% if name -%}
-                  where name = :name
-                 {%- endif -%}
-            </select>
-       </mapper>
-
-Usage Sample
-''''''''''''
-
-.. code:: python
-
-    from typing import List, Tuple, Mapping
-    from batisx import mapper, sql, dbx, init_db
-
-    @mapper(namespace='person')
-    def select_all(): List
-
-    @mapper(namespace='person')
-    def select_by_name(name: str): List
-
-    @mapper(namespace='person')
-    def select_by_name2(name: str): List
-
-    @mapper(namespace='person')
-    def select_include(name: str): List
-
-    @sql('select id, name, age from person where name = ?')
-    def query_by_name(name: str): List(Mapping)
-
-    @sql('select id, name, age from person where name = :name')
-    def query_by_name2(name: str): List(Mapping)
-
-    if __name__ == '__main__':
-        # init_db('test.db', driver='sqlite3', show_sql=True, debug=True, mapper_path='./mapper')
-        # init_db("postgres://user:password@127.0.0.1:5432/testdb", driver='psycopg2', pool_size=5, mapper_path='./mapper')
-        init_db(host='127.0.0.1', port='3306', user='xxx', password='xxx', database='test', pool_size=5, show_sql=True, mapper_path='./mapper')
-
-        persons = select_all()
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-
-        persons = select_by_name('zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = select_by_name2(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = select_include(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = query_by_name('zhangsan')
-        # result:
-        # {'id': 3, 'name': 'zhangsan', 'age': 15}
-
-        persons = query_by_name2(name='zhangsan')
-        # result:
-        # {'id': 3, 'name': 'zhangsan', 'age': 15}
-       
-        # you can use dbx execute mapper sql with full sql id: namespace join sql id
-        persons = dbx.select('person.select_all')  # 'person' is namespace, 'select_all' is sql id
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-
-        persons = dbx.select('person.select_by_name', name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        persons = dbx.sql('person.select_by_name').select(name='zhangsan')
-        # result:
-        # (3, 'zhangsan', 15)
-
-        # you can direct execute sql with db
-        effected_rowcount = db.insert(table='person', name='zhaoliu', age=66)
-
-        persons = db.select('select id, name, age from person')
-        # result:
-        # (3, 'zhangsan', 15)
-        # (4, 'lisi', 26)
-        # (5, 'wangwu', 38)
-        # (6, 'zhaoliu', 45)
-
-        persons = db.query('select id, name, age from person name = :name', name='zhangsan')
-        # result:
-        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
-
-        persons = db.sql('select id, name, age from person name = :name').query(name='zhangsan')
-        # result:
-        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
-
-        persons = db.select('select id, name, age from person where name = ?', 'zhangsan')
-        # result:
-        # [(3, 'zhangsan', 15)]
-
-
-Transaction
-'''''''''''
-
-.. code:: python
-
-        from batisx import with_transaction, transaction
-
-        @with_transaction
-        def test_transaction():
-            insert_func(....)
-            update_func(....)
-
-
-        def test_transaction2():
-            with transaction():
-                insert_func(....)
-                update_func(....)
-
-
-If you want to operate MySQL database, may be you need MySqlx: https://pypi.org/project/mysqlx
-
-If you want to operate PostgreSQL database, may be you need MySqlx: https://pypi.org/project/pgsqlx
-
-If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlx-exec
-
-
+Metadata-Version: 2.1
+Name: batisx
+Version: 2.2.2
+Summary: A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.
+Home-page: https://gitee.com/summry/batisx
+Author: summy
+Author-email: xiazhongbiao@126.com
+License: UNKNOWN
+Keywords: sql,MySQL,PostgreSQL,MyBatis,python
+Platform: UNKNOWN
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+
+Mapper file
+'''''''''''
+
+Create a mapper file in 'mapper' folder, you can named
+'person_mapper.xml', like follow:
+
+.. code:: xml
+
+       <?xml version="1.0" encoding="UTF-8"?>
+       <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://gitee.com/summry/batisx/blob/master/dtd/mapper.dtd">
+       <mapper namespace="person">
+           <select id="select_all">
+               select id, name, age from person
+            </select>
+
+            <select id="select_by_name">
+               select id, name, age from person where name = ?
+            </select>
+
+            <select id="select_by_name2">
+               select id, name, age from person where name = :name
+            </select>
+
+            <select id="select_include" include="select_all">
+               {{ select_all }}
+                 {% if name -%}
+                  where name = :name
+                 {%- endif -%}
+            </select>
+       </mapper>
+
+Usage Sample
+''''''''''''
+
+.. code:: python
+
+    from typing import List, Tuple, Mapping
+    from batisx import mapper, sql, dbx, init_db
+
+    @mapper(namespace='person')
+    def select_all(): List
+
+    @mapper(namespace='person')
+    def select_by_name(name: str): List
+
+    @mapper(namespace='person')
+    def select_by_name2(name: str): List
+
+    @mapper(namespace='person')
+    def select_include(name: str): List
+
+    @sql('select id, name, age from person where name = ?')
+    def query_by_name(name: str): List(Mapping)
+
+    @sql('select id, name, age from person where name = :name')
+    def query_by_name2(name: str): List(Mapping)
+
+    if __name__ == '__main__':
+        # init_db('test.db', driver='sqlite3', show_sql=True, debug=True, mapper_path='./mapper')
+        # init_db("postgres://user:password@127.0.0.1:5432/testdb", driver='psycopg2', pool_size=5, mapper_path='./mapper')
+        init_db(host='127.0.0.1', port='3306', user='xxx', password='xxx', database='test', pool_size=5, show_sql=True, mapper_path='./mapper')
+
+        persons = select_all()
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+
+        persons = select_by_name('zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = select_by_name2(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = select_include(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = query_by_name('zhangsan')
+        # result:
+        # {'id': 3, 'name': 'zhangsan', 'age': 15}
+
+        persons = query_by_name2(name='zhangsan')
+        # result:
+        # {'id': 3, 'name': 'zhangsan', 'age': 15}
+       
+        # you can use dbx execute mapper sql with full sql id: namespace join sql id
+        persons = dbx.select('person.select_all')  # 'person' is namespace, 'select_all' is sql id
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+
+        persons = dbx.select('person.select_by_name', name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        persons = dbx.sql('person.select_by_name').select(name='zhangsan')
+        # result:
+        # (3, 'zhangsan', 15)
+
+        # you can direct execute sql with db
+        effected_rowcount = db.insert(table='person', name='zhaoliu', age=66)
+
+        persons = db.select('select id, name, age from person')
+        # result:
+        # (3, 'zhangsan', 15)
+        # (4, 'lisi', 26)
+        # (5, 'wangwu', 38)
+        # (6, 'zhaoliu', 45)
+
+        persons = db.query('select id, name, age from person name = :name', name='zhangsan')
+        # result:
+        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
+
+        persons = db.sql('select id, name, age from person name = :name').query(name='zhangsan')
+        # result:
+        # [{'id': 3, 'name': 'zhangsan', 'age': 15}]
+
+        persons = db.select('select id, name, age from person where name = ?', 'zhangsan')
+        # result:
+        # [(3, 'zhangsan', 15)]
+
+
+Transaction
+'''''''''''
+
+.. code:: python
+
+        from batisx import with_transaction, transaction
+
+        @with_transaction
+        def test_transaction():
+            insert_func(....)
+            update_func(....)
+
+
+        def test_transaction2():
+            with transaction():
+                insert_func(....)
+                update_func(....)
+
+
+If you want to operate MySQL database, may be you need MySqlx: https://pypi.org/project/mysqlx
+
+If you want to operate PostgreSQL database, may be you need MySqlx: https://pypi.org/project/pgsqlx
+
+If you just wanted a simple sql executor, may be you need sqlx-exec: https://pypi.org/project/sqlexecx
+
+

{batisx-2.2.1 → batisx-2.2.2}/batisx.egg-info/not-zip-safe

@@ -1 +1 @@
-
+

batisx-2.2.2/batisx.egg-info/requires.txt

@@ -0,0 +1 @@
+mysqlx>=2.2.2

{batisx-2.2.1 → batisx-2.2.2}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+

{batisx-2.2.1 → batisx-2.2.2}/setup.py

@@ -1,36 +1,36 @@
-import os
-from setuptools import setup
-
-# INSTALL_PACKAGES = open(path.join(DIR, 'requirements.txt')).read().splitlines()
-def read(rel_path: str) -> str:
-    here = os.path.abspath(os.path.dirname(__file__))
-    # intentionally *not* adding an encoding option to open, See:
-    #   https://github.com/pypa/virtualenv/issues/201#issuecomment-3145690
-    with open(os.path.join(here, rel_path), 'r', encoding='UTF-8') as fp:
-        return fp.read()
-
-long_description = read("README.rst")
-
-setup(
-    name='batisx',
-    packages=['batisx'],
-    description="A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.",
-    long_description=long_description,
-    long_description_content_type='text/markdown',
-    install_requires=[
-        'mysqlx>=2.2.0',
-    ],
-    version='2.2.1',
-    url='https://gitee.com/summry/batisx',
-    author='summy',
-    author_email='xiazhongbiao@126.com',
-    keywords=['sql', 'MySQL', 'PostgreSQL', 'MyBatis', 'python'],
-    package_data={
-        # include json and txt files
-        '': ['*.rst', '*.dtd', '*.tpl'],
-    },
-    include_package_data=True,
-    python_requires='>=3.5',
-    zip_safe=False
-)
-
+import os
+from setuptools import setup
+
+# INSTALL_PACKAGES = open(path.join(DIR, 'requirements.txt')).read().splitlines()
+def read(rel_path: str) -> str:
+    here = os.path.abspath(os.path.dirname(__file__))
+    # intentionally *not* adding an encoding option to open, See:
+    #   https://github.com/pypa/virtualenv/issues/201#issuecomment-3145690
+    with open(os.path.join(here, rel_path), 'r', encoding='UTF-8') as fp:
+        return fp.read()
+
+long_description = read("README.rst")
+
+setup(
+    name='batisx',
+    packages=['batisx'],
+    description="A thread safe sql executor for Python like MyBatis with connection pool. It helps you automatically manage database connections and transactions. It also provides ORM operations for single tables.",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    install_requires=[
+        'mysqlx>=2.2.2',
+    ],
+    version='2.2.2',
+    url='https://gitee.com/summry/batisx',
+    author='summy',
+    author_email='xiazhongbiao@126.com',
+    keywords=['sql', 'MySQL', 'PostgreSQL', 'MyBatis', 'python'],
+    package_data={
+        # include json and txt files
+        '': ['*.rst', '*.dtd', '*.tpl'],
+    },
+    include_package_data=True,
+    python_requires='>=3.5',
+    zip_safe=False
+)
+

batisx-2.2.1/batisx.egg-info/requires.txt

@@ -1 +0,0 @@
-mysqlx>=2.2.0