Support sqlite3.

Author: ralgond

.gitignore

@@ -163,3 +163,4 @@ cython_debug/
 
 play
 
+test.db

example.py

@@ -32,7 +32,7 @@ def main():
     # sql, param_list = mm.insert("testInsertSelective", {'name': 'Candy', 'category': "C", 'price':500})
     # print(sql, param_list)
 
-    sql, param_list = mm.insert("test_returning_id.insert", {'name': 'Candy', 'category': "C", 'price':500, '__need_returning_id__':'fid'})
+    sql, param_list = mm.insert("test_returning_id.insert", {'name': 'Candy', 'category': "C", 'price':500}, primary_key='fid')
     print(sql, param_list)
 
     # cur.execute(sql, param_list, multi=True)

mybatis/connection.py

@@ -1,4 +1,5 @@
 import re
+import sqlite3
 import time
 from abc import ABC, abstractmethod
 from typing import Optional, Sequence
@@ -11,6 +12,10 @@
 
 from .errors import DatabaseError
 
+from sqlite3 import Connection as Sqlite3ConnectionRaw
+from sqlite3 import Cursor as Sqlite3CursorRaw
+
+
 
 class AbstractCursor(ABC):
     @abstractmethod
@@ -286,6 +291,98 @@ def reconnect(self, attempts, delay):
         else:
             raise DatabaseError(str("Reconnecting failed."))
 
+class Sqlite3Cursor(AbstractCursor):
+    def __init__(self, cursor: Sqlite3CursorRaw, *args, **kwargs):
+        self.cursor = cursor
+
+    def execute(self, query: str, param_list: Sequence = None):
+        try:
+            if param_list is None:
+                return self.cursor.execute(query)
+            else:
+                return self.cursor.execute(query, param_list)
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def rowcount(self):
+        return self.cursor.rowcount
+
+    def lastrowid(self):
+        return self.cursor.lastrowid
+
+    def description(self):
+        return self.cursor.description
+
+    def fetchone(self):
+        try:
+            return self.cursor.fetchone()
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def fetchall(self):
+        try:
+            return self.cursor.fetchall()
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def fetchmany(self, size: int):
+        try:
+            return self.cursor.fetchmany(size)
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def close(self):
+        try:
+            self.cursor.close()
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cursor.close()
+        if exc_type:
+            print(f"An exception occurred: {exc_val}")
+        return False
+
+class Sqlite3Connection(AbstractConnection):
+    def __init__(self, conn: Sqlite3ConnectionRaw):
+        self.conn = conn
+
+    def cursor(self, *args, **kwargs) -> AbstractCursor:
+        prepared = False
+        if 'prepared' in kwargs:
+            prepared = kwargs['prepared']
+            del kwargs['prepared']
+        return Sqlite3Cursor(cursor=self.conn.cursor(*args, **kwargs))
+
+    def close(self):
+        self.conn.close()
+
+    def set_autocommit(self, autocommit: bool):
+        pass
+
+    def start_transaction(self):
+        pass
+
+    def commit(self):
+        try:
+            self.conn.commit()
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def rollback(self):
+        try:
+            self.conn.rollback()
+        except sqlite3.Error as err:
+            raise DatabaseError(str(err))
+
+    def need_returning_id(self):
+        return False
+
+    def reconnect(self, attempts, delay):
+        pass
 
 class ConnectionFactory(ABC):
     @staticmethod
@@ -304,5 +401,10 @@ def get_connection(*args, **kwargs) -> Optional[AbstractConnection]:
             ret_conn = PostgreSQLConnection(conn)
             ret_conn.__setattr__("connect_kwargs", kwargs)
             return ret_conn
+        elif dbms_name == 'sqlite3':
+            db_path = kwargs.get("db_path")
+            conn = sqlite3.connect(db_path)
+            ret_conn = Sqlite3Connection(conn)
+            return ret_conn
         else:
             raise NotImplementedError(dbms_name)

mybatis/mapper_manager.py

@@ -3,11 +3,10 @@
 import re
 
 class MapperManager:
-    def __init__(self, postgresql_primary_key_name=None):
+    def __init__(self):
         self.id_2_element_map = {}
         self.param_pattern = re.compile(r"#{([a-zA-Z0-9_\-]+)}")
         self.replace_pattern = re.compile(r"\${([a-zA-Z0-9_\-]+)}")
-        self.postgresql_primary_key_name = postgresql_primary_key_name
 
     def read_mapper_xml_file(self, mapper_xml_file_path):
         namespace = ""
@@ -340,7 +339,7 @@ def delete(self, id: str, params: dict) -> Tuple[str, list]:
         sql = self._to_replace(sql, params)
         return (sql, sql_param)
 
-    def insert(self, id: str, params: dict) -> Tuple[str, list]:
+    def insert(self, id: str, params: dict, primary_key:str=None) -> Tuple[str, list]:
         if id not in self.id_2_element_map:
             raise Exception("Missing id")
         element = self.id_2_element_map[id]
@@ -358,7 +357,7 @@ def insert(self, id: str, params: dict) -> Tuple[str, list]:
         sql, sql_param = self._to_prepared_statement(ret, params)
         sql = self._to_replace(sql, params)
 
-        if self.postgresql_primary_key_name:
-            sql += (" RETURNING "+str(self.postgresql_primary_key_name))
+        if primary_key:
+            sql += (" RETURNING "+str(primary_key))
 
         return (sql, sql_param)

mybatis/mybatis.py

@@ -28,10 +28,9 @@ def fetch_rows(cursor, batch_size=1000):
 
 class Mybatis(object):
     def __init__(self, conn:AbstractConnection, mapper_path:str, cache_memory_limit:Optional[int]=None, cache_max_live_ms:int=5*1000,
-                 max_result_bytes:int=100*1024*1024, postgresql_primary_key_name=None):
+                 max_result_bytes:int=100*1024*1024):
         self.conn = conn
-        self.postgresql_primary_key_name = postgresql_primary_key_name
-        self.mapper_manager = MapperManager(postgresql_primary_key_name)
+        self.mapper_manager = MapperManager()
         self.max_result_bytes = max_result_bytes
 
         if cache_memory_limit is not None:
@@ -46,6 +45,7 @@ def __init__(self, conn:AbstractConnection, mapper_path:str, cache_memory_limit:
 
     def select_one(self, id:str, params:dict) -> Optional[Dict]:
         sql, param_list = self.mapper_manager.select(id, params)
+
         if self.cache.memory_limit > 0:
             res = self.cache.get(CacheKey(sql, param_list))
             if res is not None:
@@ -144,7 +144,9 @@ def insert(self, id:str, params:dict, primary_key:str=None) -> int:
         if self.conn.need_returning_id() and primary_key:
             params['__need_returning_id__'] = str(primary_key)
 
-        sql, param_list = self.mapper_manager.insert(id, params)
+        sql, param_list = self.mapper_manager.insert(id, params, primary_key)
+
+        print("========>",sql,param_list)
 
         res = self.cache.clear()
 

test/test_mybatis_decorator_postgresql.py

@@ -201,7 +201,7 @@ def delete(id:int):
     assert ret[0]['price'] == 100
 
 def test_insert(postgresql_db_connection):
-    mb = Mybatis(postgresql_db_connection, "mapper", postgresql_primary_key_name="id")
+    mb = Mybatis(postgresql_db_connection, "mapper")
 
     @mb.SelectMany("SELECT * FROM fruits")
     def select_many():

test/test_mybatis_postgresql.py

@@ -6,14 +6,6 @@
 
 @pytest.fixture(scope="function")
 def db_connection():
-    # 配置数据库连接
-    # connection = mysql.connector.connect(
-    #     host="localhost",
-    #     user="mybatis",
-    #     password="mybatis",
-    #     database="mybatis",
-    #     autocommit=False,
-    # )
     connection = ConnectionFactory.get_connection(
             dbms_name='postgresql',
             host="localhost",
@@ -167,8 +159,8 @@ def test_delete(db_connection):
     assert ret[0]['price'] == 100
 
 def test_insert(db_connection):
-    mb = Mybatis(db_connection, "mapper", postgresql_primary_key_name="id")
-    ret = mb.insert("testInsert", {"name": "Candy", "category": "B", "price": 200})
+    mb = Mybatis(db_connection, "mapper")
+    ret = mb.insert("testInsert", {"name": "Candy", "category": "B", "price": 200}, primary_key="id")
     assert ret == 3
 
     ret = mb.select_many('testBasicMany', {})