diff --git a/bee/obj2sql.py b/bee/obj2sql.py
index 3fca8b91f92f1b5f1e7f93c975be5322de233557..e795cf5399b65db57aaacb3b2afe2f5c2b5de007 100644
--- a/bee/obj2sql.py
+++ b/bee/obj2sql.py
@@ -2,62 +2,18 @@ from bee.config import HoneyConfig
 from bee.context import HoneyContext
 from bee.key import Key
 from bee.osql.const import DatabaseConst
+from bee.osql.sqlkeyword import K
 from bee.paging import Paging
 from bee.util import HoneyUtil
 
 
 class ObjToSQL:
 
-    # def toSelectSQL(self, entity):
-    #     cls=type(entity)
-    #     classField = HoneyUtil.get_class_field(cls)  # list
-    #     fieldAndValue = HoneyUtil.get_obj_field_value(entity)  # dict
-    #
-    #     classFieldAndValue = HoneyUtil.get_class_field_value(cls)
-    #
-    #     table_name=HoneyUtil.get_table_name(entity)
-    #     if not fieldAndValue: 
-    #         return f"SELECT {', '.join(classField)} FROM {table_name}", None
-    #
-    #     # objKey = fieldAndValue.keys()
-    #     # 获取去掉前缀的键  
-    #     # objKey = [key.lstrip('_') for key in fieldAndValue.keys()]  
-    #     fieldAndValue = {key.lstrip('_'): value for key, value in fieldAndValue.items()} 
-    #     objKey = fieldAndValue.keys()
-    #     set1 = set(classField)
-    #     set2 = set(objKey)  # list转set 顺序会乱了
-    #     setExt = set2 - set1
-    #
-    #     # 默认删除动态加的属性
-    #     for k in setExt:
-    #         fieldAndValue.pop(k, None)
-    #
-    #     #若对象的属性的值是None，则使用类级别的
-    #     for name, value in fieldAndValue.items():
-    #         if value is None:
-    #             fieldAndValue[name]=classFieldAndValue[name]
-    #
-    #     print(fieldAndValue)
-    #
-    #     # 提取条件的键值对  
-    #     condition_list = []
-    #     value_list=[] 
-    #     ph=self.__getPlaceholder()
-    #     for key, value in fieldAndValue.items(): 
-    #         if value is not None:    
-    #             condition_list.append(f"{key} = {ph}")
-    #             value_list.append(value)
-    #
-    #     where_clause = " AND ".join(condition_list)  
-    #     if where_clause is not None and where_clause != '' :
-    #         sql = f"SELECT {', '.join(classField)} FROM {table_name} WHERE {where_clause}"  
-    #     else:
-    #         sql = f"SELECT {', '.join(classField)} FROM {table_name}"
-    #
-    #     return sql, value_list   #如何将值放入上下文 TODO
-    
-
-    
+    def toSelectSQL(self, entity):
+        fieldAndValue, classField = self.__getKeyValue_classField(entity)
+        
+        table_name = HoneyUtil.get_table_name(entity)
+        return self.__build_select_sql(table_name, classField, fieldAndValue);
     
     def toSelectSQLWithPaging(self, entity, start, size):
         sql, params = self.toSelectSQL(entity)
@@ -66,12 +22,6 @@ class ObjToSQL:
         sql = paging.to_page_sql(sql, start, size)
         return sql, params
     
-    def toSelectSQL(self, entity):
-        fieldAndValue, classField = self.__getKeyValue_classField(entity)
-        
-        table_name = HoneyUtil.get_table_name(entity)
-        return self.__build_select_sql(table_name, classField, fieldAndValue);
-        
     def toUpdateSQL(self, entity):
         fieldAndValue = self.__getKeyValue(entity)
         pk = HoneyUtil.get_pk(entity)
@@ -113,17 +63,13 @@ class ObjToSQL:
         cls=type(entity)
         classField = HoneyUtil.get_class_field(cls)  # list
         fieldAndValue = HoneyUtil.get_obj_field_value(entity)  # dict
-        # print(fieldAndValue) 
         
         classFieldAndValue = HoneyUtil.get_class_field_value(cls)
-        # print("aaaaa------------")
-        # print(classFieldAndValue)
         
         # 获取去掉前缀的键    TODO __ ??
         # fieldAndValue = {key.lstrip('_'): value for key, value in fieldAndValue.items()} 
         
         fieldAndValue = HoneyUtil.remove_prefix(fieldAndValue)
-          
         
         objKey = fieldAndValue.keys()
         
@@ -159,12 +105,13 @@ class ObjToSQL:
         ph=self.__getPlaceholder()
         if self.__getPlaceholderType() == 3:
             updateSet = ', '.join(f"{key} = {ph}{key}" for key in set_dict.keys())
-            condition_str = " AND ".join(f"{key} = {ph}{key}" for key in conditions.keys())
+            condition_str = f" {K.and_()} ".join(f"{key} = {ph}{key}" for key in conditions.keys())
         else:
             updateSet = ', '.join(f"{key} = {ph}" for key in set_dict.keys())
-            condition_str = " AND ".join(f"{key} = {ph}" for key in conditions.keys())
+            condition_str = f" {K.and_()} ".join(f"{key} = {ph}" for key in conditions.keys())
         
-        sql = f"UPDATE {table_name} SET {updateSet} WHERE {condition_str}"
+        # sql = f"UPDATE {table_name} SET {updateSet} WHERE {condition_str}"
+        sql = f"{K.update()} {table_name} {K.set()} {updateSet} {K.where()} {condition_str}"
         params = list(set_dict.values()) + list(conditions.values())
         return sql, params
     
@@ -176,37 +123,38 @@ class ObjToSQL:
             placeholders = ', '.join(f" {ph}{key}" for key in data.keys())
         else:
             placeholders = ', '.join(f"{ph}" for _ in data)
-        sql = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
+        sql = f"{K.insert()} {K.into()} {table_name} ({columns}) {K.values()} ({placeholders})"
         return sql, list(data.values())
 
     def __build_where_condition(self, conditions):
         ph=self.__getPlaceholder()
         if self.__getPlaceholderType() == 3:
-            condition_str = " AND ".join(f"{key} = {ph}{key}" for key in conditions.keys())
+            condition_str = f" {K.and_()} ".join(f"{key} = {ph}{key}" for key in conditions.keys())
         else:
-            condition_str = " AND ".join(f"{key} = {ph}" for key in conditions.keys())
+            condition_str = f" {K.and_()} ".join(f"{key} = {ph}" for key in conditions.keys())
         return condition_str
     
     def __build_select_sql(self, table_name, classField, conditions=None):
         # sql = f"SELECT * FROM {table_name}"
-        sql = f"SELECT {', '.join(classField)} FROM {table_name}"
+        # sql = f"SELECT {', '.join(classField)} FROM {table_name}"
+        sql = f"{K.select()} {', '.join(classField)} {K.from_()} {table_name}"
         
         #where part
         params = []
         if conditions:
             condition_str=self.__build_where_condition(conditions)
-            sql += f" WHERE {condition_str}"
+            sql += f" {K.where()} {condition_str}"
             params = list(conditions.values())
         return sql, params
     
 
     def __build_delete_sql(self, table_name, conditions):
 
-        sql = f"DELETE FROM {table_name}"
+        sql = f"{K.delete()} {K.from_()} {table_name}"
         params = []
         if conditions:
             condition_str=self.__build_where_condition(conditions)
-            sql += f" WHERE {condition_str}"
+            sql += f" {K.where()} {condition_str}"
             params = list(conditions.values())
         return sql, params
     
diff --git a/bee/osql/sqlkeyword.py b/bee/osql/sqlkeyword.py
new file mode 100644
index 0000000000000000000000000000000000000000..60c3a8d293b58e319377cf5c6e3bba9d6aa1c64e
--- /dev/null
+++ b/bee/osql/sqlkeyword.py
@@ -0,0 +1,663 @@
+from bee.util import HoneyUtil
+
+class SqlKeyWord:  
+    def select(self):  
+        raise NotImplementedError  
+
+    def as_(self):  
+        raise NotImplementedError  
+
+    def from_(self):  
+        raise NotImplementedError  
+
+    def where(self):  
+        raise NotImplementedError  
+
+    def insert(self):  
+        raise NotImplementedError  
+
+    def replace(self):  
+        raise NotImplementedError  
+
+    def into(self):  
+        raise NotImplementedError  
+
+    def values(self):  
+        raise NotImplementedError  
+
+    def and_(self):  
+        raise NotImplementedError  
+
+    def or_(self):  
+        raise NotImplementedError  
+
+    def not_(self):  
+        raise NotImplementedError  
+
+    def null(self):  
+        raise NotImplementedError  
+
+    def isnull(self):  
+        raise NotImplementedError  
+
+    def is_not_null(self):  
+        raise NotImplementedError  
+
+    def update(self):  
+        raise NotImplementedError  
+
+    def set(self):  
+        raise NotImplementedError  
+
+    def delete(self):  
+        raise NotImplementedError  
+
+    def order_by(self):  
+        raise NotImplementedError  
+
+    def count(self):  
+        raise NotImplementedError  
+
+    def asc(self):  
+        raise NotImplementedError  
+
+    def on(self):  
+        raise NotImplementedError  
+
+    def limit(self):  
+        raise NotImplementedError  
+
+    def offset(self):  
+        raise NotImplementedError  
+
+    def top(self):  
+        raise NotImplementedError  
+
+    def group_by(self):  
+        raise NotImplementedError  
+
+    def having(self):  
+        raise NotImplementedError  
+
+    def between(self):  
+        raise NotImplementedError  
+
+    def not_between(self):  
+        raise NotImplementedError  
+
+    def for_update(self):  
+        raise NotImplementedError  
+
+    def distinct(self):  
+        raise NotImplementedError  
+
+    def join(self):  
+        raise NotImplementedError  
+
+    def inner_join(self):  
+        raise NotImplementedError  
+
+    def left_join(self):  
+        raise NotImplementedError  
+
+    def right_join(self):  
+        raise NotImplementedError  
+
+    def in_(self):  
+        raise NotImplementedError  
+
+    def not_in(self):  
+        raise NotImplementedError  
+
+    def exists(self):  
+        raise NotImplementedError  
+
+    def not_exists(self):  
+        raise NotImplementedError  
+
+    def union(self):  
+        raise NotImplementedError  
+
+    def union_all(self):  
+        raise NotImplementedError  
+
+    def truncate(self):  
+        raise NotImplementedError  
+
+    def table(self):  
+        raise NotImplementedError  
+
+    def drop(self):  
+        raise NotImplementedError  
+
+    def if_(self):  
+        raise NotImplementedError  
+
+    def to_date(self):  
+        raise NotImplementedError  
+
+
+class UpperKey(SqlKeyWord):  
+    def select(self):  
+        return "SELECT"  
+
+    def as_(self):  
+        return "AS"  
+
+    def from_(self):  
+        return "FROM"  
+
+    def where(self):  
+        return "WHERE"  
+
+    def insert(self):  
+        return "INSERT"  
+
+    def replace(self):  
+        return "REPLACE"  
+
+    def into(self):  
+        return "INTO"  
+
+    def values(self):  
+        return "VALUES"  
+
+    def and_(self):  
+        return "AND"  
+
+    def or_(self):  
+        return "OR"  
+
+    def not_(self):  
+        # return "NOT"  
+        return "!"  
+
+    def null(self):  
+        return "NULL"  
+
+    def isnull(self):  
+        return "IS NULL"  
+
+    def is_not_null(self):  
+        return "IS NOT NULL"  
+
+    def update(self):  
+        return "UPDATE"  
+
+    def set(self):  
+        return "SET"  
+
+    def delete(self):  
+        return "DELETE"  
+
+    def order_by(self):  
+        return "ORDER BY"  
+
+    def count(self):  
+        return "COUNT"  
+
+    def asc(self):  
+        return "ASC"  
+
+    def on(self):  
+        return "ON"  
+
+    def limit(self):  
+        return "LIMIT"  
+
+    def offset(self):  
+        return "OFFSET"  
+
+    def top(self):  
+        return "TOP"  
+
+    def group_by(self):  
+        return "GROUP BY"  
+
+    def having(self):  
+        return "HAVING"  
+
+    def between(self):  
+        return "BETWEEN"  
+
+    def not_between(self):  
+        return "NOT BETWEEN"  
+
+    def for_update(self):  
+        return "FOR UPDATE"  
+
+    def distinct(self):  
+        return "DISTINCT"  
+
+    def join(self):  
+        return "JOIN"  
+
+    def inner_join(self):  
+        return "INNER JOIN"  
+
+    def left_join(self):  
+        return "LEFT JOIN"  
+
+    def right_join(self):  
+        return "RIGHT JOIN"  
+
+    def in_(self):  
+        return "IN"  
+
+    def not_in(self):  
+        return "NOT IN"  
+
+    def exists(self):  
+        return "EXISTS"  
+
+    def not_exists(self):  
+        return "NOT EXISTS"  
+
+    def union(self):  
+        return "UNION"  
+
+    def union_all(self):  
+        return "UNION ALL"  
+
+    def truncate(self):  
+        return "TRUNCATE"  
+
+    def table(self):  
+        return "TABLE"  
+
+    def drop(self):  
+        return "DROP"  
+
+    def if_(self):  
+        return "IF"  
+
+    def to_date(self):  
+        return "TO_DATE"  
+
+
+class LowerKey(SqlKeyWord):  
+    def select(self):  
+        return "select"  
+
+    def as_(self):  
+        return "as"  
+
+    def from_(self):  
+        return "from"  
+
+    def where(self):  
+        return "where"  
+
+    def insert(self):  
+        return "insert"  
+
+    def replace(self):  
+        return "replace"  
+
+    def into(self):  
+        return "into"  
+
+    def values(self):  
+        return "values"  
+
+    def and_(self):  
+        return "and"  
+
+    def or_(self):  
+        return "or"  
+
+    def not_(self):  
+        # return "not"  
+        return "!"  
+
+    def null(self):  
+        return "null"  
+
+    def isnull(self):  
+        return "is null"  
+
+    def is_not_null(self):  
+        return "is not null"  
+
+    def update(self):  
+        return "update"  
+
+    def set(self):  
+        return "set"  
+
+    def delete(self):  
+        return "delete"  
+
+    def order_by(self):  
+        return "order by"  
+
+    def count(self):  
+        return "count"  
+
+    def asc(self):  
+        return "asc"  
+
+    def on(self):  
+        return "on"  
+
+    def limit(self):  
+        return "limit"  
+
+    def offset(self):  
+        return "offset"  
+
+    def top(self):  
+        return "top"  
+
+    def group_by(self):  
+        return "group by"  
+
+    def having(self):  
+        return "having"  
+
+    def between(self):  
+        return "between"  
+
+    def not_between(self):  
+        return "not between"  
+
+    def for_update(self):  
+        return "for update"  
+
+    def distinct(self):  
+        return "distinct"  
+
+    def join(self):  
+        return "join"  
+
+    def inner_join(self):  
+        return "inner join"  
+
+    def left_join(self):  
+        return "left join"  
+
+    def right_join(self):  
+        return "right join"  
+
+    def in_(self):  
+        return "in"  
+
+    def not_in(self):  
+        return "not in"  
+
+    def exists(self):  
+        return "exists"  
+
+    def not_exists(self):  
+        return "not exists"  
+
+    def union(self):  
+        return "union"  
+
+    def union_all(self):  
+        return "union all"  
+
+    def truncate(self):  
+        return "truncate"  
+
+    def table(self):  
+        return "table"  
+
+    def drop(self):  
+        return "drop"  
+
+    def if_(self):  
+        return "if"  
+
+    def to_date(self):  
+        return "to_date"  
+
+
+class K:  
+    _sql_keywords = None  
+
+    @classmethod  
+    def _get_sql_keywords(cls):  
+        if HoneyUtil.is_sql_key_word_upper():  # 根据配置指定是用大写还是小写  
+            return UpperKey()  
+        else:  
+            return LowerKey()  # 默认使用小写  
+
+    @classmethod  
+    def _initialize(cls):  
+        if cls._sql_keywords is None:  
+            cls._sql_keywords = cls._get_sql_keywords()  
+
+    @classmethod  
+    def select(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.select()  
+
+    @classmethod  
+    def as_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.as_()  
+
+    @classmethod  
+    def from_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.from_()  
+
+    @classmethod  
+    def where(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.where()  
+
+    @classmethod  
+    def insert(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.insert()  
+
+    @classmethod  
+    def replace(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.replace()  
+
+    @classmethod  
+    def into(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.into()  
+
+    @classmethod  
+    def values(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.values()  
+
+    @classmethod  
+    def and_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.and_()  
+
+    @classmethod  
+    def or_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.or_()  
+
+    @classmethod  
+    def not_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.not_()  
+
+    @classmethod  
+    def null(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.null()  
+
+    @classmethod  
+    def isnull(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.isnull()  
+
+    @classmethod  
+    def is_not_null(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.is_not_null()  
+
+    @classmethod  
+    def update(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.update()  
+
+    @classmethod  
+    def set(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.set()  
+
+    @classmethod  
+    def delete(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.delete()  
+
+    @classmethod  
+    def order_by(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.order_by()  
+
+    @classmethod  
+    def count(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.count()  
+
+    @classmethod  
+    def asc(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.asc()  
+
+    @classmethod  
+    def on(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.on()  
+
+    @classmethod  
+    def limit(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.limit()  
+
+    @classmethod  
+    def offset(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.offset()  
+
+    @classmethod  
+    def top(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.top()  
+
+    @classmethod  
+    def group_by(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.group_by()  
+
+    @classmethod  
+    def having(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.having()  
+
+    @classmethod  
+    def between(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.between()  
+
+    @classmethod  
+    def not_between(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.not_between()  
+
+    @classmethod  
+    def for_update(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.for_update()  
+
+    @classmethod  
+    def distinct(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.distinct()  
+
+    @classmethod  
+    def join(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.join()  
+
+    @classmethod  
+    def inner_join(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.inner_join()  
+
+    @classmethod  
+    def left_join(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.left_join()  
+
+    @classmethod  
+    def right_join(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.right_join()  
+
+    @classmethod  
+    def in_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.in_()  
+
+    @classmethod  
+    def not_in(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.not_in()  
+
+    @classmethod  
+    def exists(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.exists()  
+
+    @classmethod  
+    def not_exists(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.not_exists()  
+
+    @classmethod  
+    def union(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.union()  
+
+    @classmethod  
+    def union_all(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.union_all()  
+
+    @classmethod  
+    def truncate(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.truncate()  
+
+    @classmethod  
+    def table(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.table()  
+
+    @classmethod  
+    def drop(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.drop()  
+
+    @classmethod  
+    def if_(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.if_()  
+
+    @classmethod  
+    def to_date(cls):  
+        cls._initialize()  
+        return cls._sql_keywords.to_date()  
+
+
+# 在类外部访问静态属性  
+## K._initialize()  # 确保初始化  
+# print(K.select())  # 输出: SELECT  
+# print(K.from_())   # 输出: FROM  
+# print(K.where())   # 输出: WHERE  
+# print(K.and_())    # 输出: AND  
+# print(K.union_all())  # 输出: UNION ALL
\ No newline at end of file
diff --git a/bee/paging.py b/bee/paging.py
index ef9049525cf7df04cf9d092986ee334f599df839..dfdb920d13ad5a0e96afe58c07e50edb90fed1f8 100644
--- a/bee/paging.py
+++ b/bee/paging.py
@@ -1,5 +1,6 @@
 from bee.config import HoneyConfig
 from bee.osql.const import DatabaseConst
+from bee.osql.sqlkeyword import K
 
 
 class Paging:
@@ -16,10 +17,10 @@ class Paging:
             return self.__toLimitOffsetPaging(sql, start, size)
         
     def __toPageSqlForMySql(self, sql, start, size): 
-        limitStament = " " + "limit" + " " + str(start) + ", " + str(size)
+        limitStament = " " + K.limit() + " " + str(start) + ", " + str(size)
         sql += limitStament
         return sql
     
     def __toLimitOffsetPaging(self, sql, offset, size): 
-        return sql + " " + "limit" + " " + str(size) + " " + "offset" + " " + str(offset)
+        return sql + " " + K.limit() + " " + str(size) + " " + K.offset() + " " + str(offset)
            
diff --git a/bee/util.py b/bee/util.py
index 0679de8fb29def149241b832c8fb6f985be17972..34d400439cbd6a971c245b29197903e831827feb 100644
--- a/bee/util.py
+++ b/bee/util.py
@@ -133,3 +133,8 @@ class HoneyUtil:
             setattr(obj, column_names[i], row[i])  # 像时间等类型，是否也可以自动设置？？？   TODO
         return obj
     
+    @staticmethod  
+    def is_sql_key_word_upper():  
+        # 你可以根据需要修改这个方法来决定是使用大写还是小写  
+        # return True  # 示例：返回True表示使用大写  TODO
+        return False
\ No newline at end of file
diff --git a/test/entity/Orders01.py b/test/entity/Orders01.py
new file mode 100644
index 0000000000000000000000000000000000000000..71a542687f43570cdfe6f36b56396b3f2a778bd0
--- /dev/null
+++ b/test/entity/Orders01.py
@@ -0,0 +1,20 @@
+'''
+
+这种可以不需要构造方法。
+不写属性的类型
+
+Created on 2024年10月19日
+
+'''
+
+class Orders:
+
+    _id = None  
+    _name = None 
+    _remark = None
+    
+
+    def __repr__(self):  
+        # return f"Orders(id={self.id}, name='{self.name}')"  
+        return  str(self.__dict__)
+
diff --git a/test/entity/Orders02.py b/test/entity/Orders02.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6a5fc955289d6eef2837fb6b0f21727bb8340b1
--- /dev/null
+++ b/test/entity/Orders02.py
@@ -0,0 +1,26 @@
+'''
+
+这种可以不需要构造方法。
+不写属性的类型
+
+Created on 2024年10月19日
+
+'''
+
+class Orders:
+    __id = None  
+    __name = None 
+    __remark = "init __remark"
+    
+    # def __init__(self, **kwargs):  
+    #     for key, value in kwargs.items():  
+    #         setattr(self, key, value)  
+    
+    # def __init__(self, id=None, name=None):  
+    #     self.id = id  
+    #     self.name = name  
+
+    def __repr__(self):  
+        # return f"Orders(id={self.id}, name='{self.name}')"  
+        return  str(self.__dict__)
+
diff --git a/test/entity/Orders2.py b/test/entity/Orders2.py
new file mode 100644
index 0000000000000000000000000000000000000000..4112c107f89e0afa044f3327f3e570ee8c48bc7a
--- /dev/null
+++ b/test/entity/Orders2.py
@@ -0,0 +1,27 @@
+'''
+
+这种可以不需要构造方法。
+还写明属性的类型
+
+Created on 2024年10月19日
+'''
+from dataclasses import dataclass, field  
+
+@dataclass 
+class Orders2:
+    __tablename__="orders"
+    # id: int = None
+    # name: str = None
+    id: int = field(default=None)  
+    name: str = field(default=None)  
+    remark: str = field(default=None)  
+    
+    # def __init__(self, id=None, name=None):  
+    #     self.id = id  
+    #     self.name = name  
+
+    def __repr__(self):  
+        # return f"Order(id={self.id}, name='{self.name}')"
+        return  str(self.__dict__) 
+    
+
diff --git a/test/entity/Orders3.py b/test/entity/Orders3.py
new file mode 100644
index 0000000000000000000000000000000000000000..86664c7bc3cf5367095a8d45feda6a010807cf58
--- /dev/null
+++ b/test/entity/Orders3.py
@@ -0,0 +1,29 @@
+'''
+
+对象有比类多属性；
+默认对象多的属性将被忽略；因为不安全。
+
+有构造方法
+还写明属性的类型
+
+Created on 2024年10月19日
+'''
+
+class Orders3:
+    __tablename__="orders"
+    id = None  
+    name = None
+    remark="test" 
+    
+    def __init__(self, id=None,id2=None, name=None,remark=None):  
+        self.id = id  
+        self.id2=id2
+        self.name = name 
+        self.remark=remark 
+        # 在 __init__ 方法中定义的 self.id, self.name, 和 self.remark 是实例属性。
+        # 这意味着每个实例都会有这些属性，并且它们在创建实例时通过 __init__ 方法被初始化。
+        #使用 orders=Orders3()也可以实例化，因为参数没传，就用默认值None
+
+    def __repr__(self):  
+        return  str(self.__dict__) 
+
diff --git a/test/entity/Orders4.py b/test/entity/Orders4.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c7f65adc36bec802c4e70519145bc915997c4ad
--- /dev/null
+++ b/test/entity/Orders4.py
@@ -0,0 +1,47 @@
+'''
+标准get,set Bean
+有构造方法
+
+get/set 还要测试没有构造方法的。  在Orders42,是可以的。
+'''
+
+class Orders4: 
+    __tablename__ = 'orders' 
+    
+    #可以有属性也可以没有
+    name = None
+    remark="test2"  
+
+    #可以有构造方法，也可以没有
+    def __init__(self, id: int=None, name: str=None, remark: str=None): 
+        self._id = id  
+        self._name = name  
+        self._remark = remark  
+
+    # Getter 和 Setter 方法  
+    @property  
+    def id(self): 
+        return self._id  
+
+    @id.setter  
+    def id(self, value): 
+        self._id = value  
+
+    @property  
+    def name(self): 
+        return self._name  
+
+    @name.setter  
+    def name(self, value): 
+        self._name = value  
+
+    @property  
+    def remark(self): 
+        return self._remark  
+    
+    @remark.setter  
+    def remark(self, value): 
+        self._remark = value  
+        
+    def __repr__(self): 
+        return  str(self.__dict__)
diff --git a/test/entity/Orders42.py b/test/entity/Orders42.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d28d8fb90ba822e7491aaec7f17ddfc9893f11d
--- /dev/null
+++ b/test/entity/Orders42.py
@@ -0,0 +1,36 @@
+'''
+标准get,set Bean
+有构造方法
+
+ get/set 还要测试没有构造方法的。  可以的
+'''
+
+class Orders42: 
+    __tablename__ = 'orders'  
+
+    @property  
+    def id(self): 
+        return self._id  
+
+    @id.setter  
+    def id(self, value): 
+        self._id = value  
+
+    @property  
+    def name(self): 
+        return self._name  
+
+    @name.setter  
+    def name(self, value): 
+        self._name = value  
+
+    @property  
+    def remark(self): 
+        return self._remark  
+
+    @remark.setter  
+    def remark(self, value): 
+        self._remark = value  
+        
+    def __repr__(self): 
+        return  str(self.__dict__)
diff --git a/test/entity/Orders5.py b/test/entity/Orders5.py
new file mode 100644
index 0000000000000000000000000000000000000000..88e913c087c6b3251a3417375ee7a9ae279e095a
--- /dev/null
+++ b/test/entity/Orders5.py
@@ -0,0 +1,101 @@
+'''
+sql语句中没有表的字段，将会报错。
+'''
+
+class Orders5:  
+    __tablename__ = 'orders'  
+
+    def __init__(self, id: int = None, name: str = None, price: float = None, quantity: int = None,   
+                 customer_id: int = None, order_date: str = None, status: str = None,   
+                 shipping_address: str = None, payment_method: str = None, note: str = None):  
+        self._id = id  
+        self._name = name  
+        self._price = price  
+        self._quantity = quantity  
+        self._customer_id = customer_id  
+        self._order_date = order_date  
+        self._status = status  
+        self._shipping_address = shipping_address  
+        self._payment_method = payment_method  
+        self._note = note  
+
+    # Getter 和 Setter 方法  
+    @property  
+    def id(self):  
+        return self._id  
+
+    @id.setter  
+    def id(self, value):  
+        self._id = value  
+
+    @property  
+    def name(self):  
+        return self._name  
+
+    @name.setter  
+    def name(self, value):  
+        self._name = value  
+
+    @property  
+    def price(self):  
+        return self._price  
+
+    @price.setter  
+    def price(self, value):  
+        self._price = value  
+
+    @property  
+    def quantity(self):  
+        return self._quantity  
+
+    @quantity.setter  
+    def quantity(self, value):  
+        self._quantity = value  
+
+    @property  
+    def customer_id(self):  
+        return self._customer_id  
+
+    @customer_id.setter  
+    def customer_id(self, value):  
+        self._customer_id = value  
+
+    @property  
+    def order_date(self):  
+        return self._order_date  
+
+    @order_date.setter  
+    def order_date(self, value):  
+        self._order_date = value  
+
+    @property  
+    def status(self):  
+        return self._status  
+
+    @status.setter  
+    def status(self, value):  
+        self._status = value  
+
+    @property  
+    def shipping_address(self):  
+        return self._shipping_address  
+
+    @shipping_address.setter  
+    def shipping_address(self, value):  
+        self._shipping_address = value  
+
+    @property  
+    def payment_method(self):  
+        return self._payment_method  
+
+    @payment_method.setter  
+    def payment_method(self, value):  
+        self._payment_method = value  
+
+    @property  
+    def note(self):  
+        return self._note  
+
+    @note.setter  
+    def note(self, value):  
+        self._note = value  
\ No newline at end of file
diff --git a/test/entity/Orders6.py b/test/entity/Orders6.py
new file mode 100644
index 0000000000000000000000000000000000000000..1069d5aadc0dd66711014ce55fa43c208c9c4b8f
--- /dev/null
+++ b/test/entity/Orders6.py
@@ -0,0 +1,35 @@
+
+class Orders6:  
+    __tablename__ = 'orders' 
+    
+    id = None  
+    name = None 
+    remark = None 
+
+    def __init__(self, **kwargs): 
+        # 使用 set 方法动态设置属性  
+        for key, value in kwargs.items():  
+            setattr(self, key, value)  
+            
+    def __repr__(self):  
+        return  str(self.__dict__)
+
+# 示例  
+# 创建订单实例  
+order_data = {  
+    'id': 100001,  
+    'name': "Bee(ORM Framework)",  
+    'price': 29.99,  
+    'quantity': 5,  
+    'customer_id': 123,  
+    'order_date': '2023-10-01',  
+    'status': 'Shipped',  
+    'shipping_address': '123 Main St',  
+    'payment_method': 'Credit Card',  
+    'note': 'Leave at the front door'  
+}  
+
+orders6 = Orders6(**order_data)  
+
+# 打印实例的属性以验证它们已被设置  
+print(vars(orders6))
\ No newline at end of file
diff --git a/test/entity/Orders7.py b/test/entity/Orders7.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a6d414024cd1f892314fc1d66d7e9b90d8ab3e7
--- /dev/null
+++ b/test/entity/Orders7.py
@@ -0,0 +1,29 @@
+class Orders7:  
+    __tablename__ = 'orders'  
+    
+    def __init__(self, *args, **kwargs):  
+        # 使用位置参数设置动态属性  
+        for index, value in enumerate(args):  
+            setattr(self, f'arg{index}', value)  # 使用动态生成的键  
+
+        # 使用关键字参数更新实例属性  
+        for key, value in kwargs.items():  
+            setattr(self, key, value)  
+
+# 示例  
+# 使用动态参数创建订单实例  
+orders1 = Orders7(  
+    100001,                  # 算作 arg0  
+    "Bee(ORM Framework)",    # 算作 arg1  
+    29.99,                   # 算作 arg2  
+    5,                       # 算作 arg3  
+    customer_id=123,        # 关键字参数  
+    order_date='2023-10-01',# 关键字参数  
+    status='Shipped',       # 关键字参数  
+    shipping_address='123 Main St', # 关键字参数  
+    payment_method='Credit Card',    # 关键字参数  
+    note='Leave at the front door'   # 关键字参数  
+)  
+
+# 打印实例的属性以验证它们已被设置  
+print(vars(orders1))  
\ No newline at end of file
diff --git a/test/entity/Orders8.py b/test/entity/Orders8.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2c862765ba4d21b5cb79abf92ac2fff59445399
--- /dev/null
+++ b/test/entity/Orders8.py
@@ -0,0 +1,19 @@
+'''
+
+这种可以不需要构造方法。
+写属性的类型
+
+Created on 2024年10月19日
+
+'''
+
+
+class Orders8:
+    __tablename__ = "orders"
+    id:int = None  
+    name:str = None 
+    remark:str = None
+
+    def __repr__(self): 
+        return  str(self.__dict__)
+
diff --git a/test/entity/Test.py b/test/entity/Test.py
new file mode 100644
index 0000000000000000000000000000000000000000..e871eec71880aea7da7ea0982ed0d55340f8d93b
--- /dev/null
+++ b/test/entity/Test.py
@@ -0,0 +1,16 @@
+'''
+Created on 2024年10月19日
+
+'''
+class Test:
+    id: int = None
+    name: str = None
+    
+    # def __init__(self, id=None, name=None):  
+    #     self.id = id  
+    #     self.name = name  
+
+    def __repr__(self):  
+        # return f"Order(id={self.id}, name='{self.name}')"  
+        return  str(self.__dict__)
+
diff --git a/test/exam/SuidTest11Page.py b/test/exam/SuidTest11Page.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4329a806d4ac4b31fb36ee5482c3e1435c00fd6
--- /dev/null
+++ b/test/exam/SuidTest11Page.py
@@ -0,0 +1,24 @@
+# from org.teasoft.exam.entity.Test import Test
+from bee.api import Suid
+from test.entity.Test import Test
+
+
+if __name__ == '__main__':
+    print("start")
+    
+    # config = HoneyConfig()
+    # config.dbName="mysql"
+    
+    # orders=Orders(id=1, name="bee")
+    orders=Test()
+    # orders.id=1
+    orders.name="bee"
+    
+    suid=Suid()
+    orderList = suid.select_paging(orders, 0, 10)
+    print(orderList)
+    
+    for one in orderList:  
+        print(one)  
+    
+    print("finished")
diff --git a/test/exam/SuidTest12_insert.py b/test/exam/SuidTest12_insert.py
new file mode 100644
index 0000000000000000000000000000000000000000..189c72e80df6bb16cfc8e7dc1414692fe3e5bf51
--- /dev/null
+++ b/test/exam/SuidTest12_insert.py
@@ -0,0 +1,26 @@
+from bee.api import Suid
+from test.entity.Test import Test
+
+
+if __name__ == '__main__':
+    print("start")
+    
+    # config = HoneyConfig()
+    # config.dbName="mysql"
+    
+    # orders=Orders(id=1, name="bee")
+    orders=Test()
+    orders.id=104
+    orders.name="bee"
+    orders.remark="test"
+    
+    suid=Suid()
+    suid.insert(orders)
+    
+    orderList=suid.select(orders)
+    print(orderList)
+    
+    for one in orderList:  
+        print(one)  
+    
+    print("finished")
\ No newline at end of file
diff --git a/test/exam/SuidTest13_insert.py b/test/exam/SuidTest13_insert.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa59944ed3590f86498a43e1e73a3d08f968fdee
--- /dev/null
+++ b/test/exam/SuidTest13_insert.py
@@ -0,0 +1,26 @@
+from bee.api import Suid
+from test.entity.Orders import Orders
+
+
+if __name__ == '__main__':
+    print("start")
+    
+    # config = HoneyConfig()
+    # config.dbName="mysql"
+    
+    # orders=Orders(id=1, name="bee")
+    orders=Orders()
+    orders.id=104
+    orders.name="bee"
+    orders.remark="test"
+    
+    suid=Suid()
+    suid.insert(orders)
+    
+    orderList=suid.select(orders)
+    print(orderList)
+    
+    for one in orderList:  
+        print(one)  
+    
+    print("finished")
\ No newline at end of file
diff --git a/test/exam/SuidTest32_update_delete.py b/test/exam/SuidTest32_update_delete.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e536ef76d43b614ee8c0c5083c012756150af70
--- /dev/null
+++ b/test/exam/SuidTest32_update_delete.py
@@ -0,0 +1,37 @@
+from bee.api import Suid
+from test.entity.Orders3 import Orders3
+
+
+# from test.entity import Orders3
+# from bee.HoneyUtil import HoneyUtil
+if __name__ == '__main__':
+    print("start")
+    # orders=Orders(id=1, name="bee")
+    orders=Orders3()
+    orders.name="bee130"
+    # orders.remark=None
+    orders.ext="aaa"  #实体没有字段，会被忽略。出去安全考虑
+    
+    # print(orders.__dict__)
+    # {'id': None, 'name': 'bee', 'remark': None, 'ext': 'aaa'}
+    
+    orders.id=10002
+    
+    suid = Suid()
+    n1= suid.update(orders)
+    n2= suid.delete(orders)
+    print(n1)
+    print(n2)
+    # orderList = suid.select(orders)
+    orderList = suid.select(Orders3())
+    # print(orderList)
+    if orderList is not None:
+        # print(orderList)
+        for one in orderList: 
+            # print(one.id) 
+            # print(one.name)  
+            print(one)
+    else:
+        print(" --no data!")
+    
+    print("---finished")
diff --git a/test/exam/SuidTest42.py b/test/exam/SuidTest42.py
new file mode 100644
index 0000000000000000000000000000000000000000..6bd068b3f957bb08333953d34e63b78ab08a3ed8
--- /dev/null
+++ b/test/exam/SuidTest42.py
@@ -0,0 +1,29 @@
+# from org.teasoft.exam.entity.Orders42 import Orders42
+from bee.api import Suid
+from test.entity.Orders42 import Orders42
+
+
+# from bee.HoneyUtil import HoneyUtil
+# 实例化对象  
+if __name__ == '__main__':  
+    # orders = Orders42(id=1, name="bee")  
+    
+    orders = Orders42()
+    # 使用Setter设置属性  
+    # orders.remark = 'test'  
+        
+    print("start")
+    
+    suid = Suid()
+    orderList = suid.select(orders)
+    # print(orderList)
+    if orderList is not None:
+        # print(orderList)
+        for one in orderList: 
+            # print(one.id) 
+            # print(one.name)  
+            print(one)
+    else:
+        print(" --no data!")
+    
+    print("---finished")
diff --git a/test/exam/SuidTest6.py b/test/exam/SuidTest6.py
new file mode 100644
index 0000000000000000000000000000000000000000..85a29fcdcbb5ebe22da955eb4355ce873e200826
--- /dev/null
+++ b/test/exam/SuidTest6.py
@@ -0,0 +1,17 @@
+from bee.api import Suid
+from test.entity.Orders6 import Orders6
+# from org.teasoft.exam.entity.Orders6 import Orders6
+
+if __name__ == '__main__':
+    print("start")
+    orders = Orders6(**{'name':'bee', 'remark':'test'})  
+    print(orders.__dict__)
+    print(vars(orders))
+    
+    suid = Suid()
+    orderList = suid.select(orders)
+    if orderList is not None:
+        for one in orderList: 
+            print(one)
+    
+    print("finished")