diff --git a/src/bee/api.py b/src/bee/api.py
index 0ed8a8ddad4b9961d0cba2211eac0a07126780c7..3a575548e7a52dd22da248bd6d82e397451badef 100644
--- a/src/bee/api.py
+++ b/src/bee/api.py
@@ -1,11 +1,12 @@
from bee import SqlUtil
+from bee.base import AbstractCommOperate
from bee.exception import BeeException, ParamBeeException
from bee.obj2sql import ObjToSQL
from bee.osql.enum import FunctionType, SuidType
from bee.osql.logger import Logger
from bee.sqllib import BeeSql
-from bee.base import AbstractCommOperate
+from bee.condition import Condition
class Suid(AbstractCommOperate):
@@ -24,7 +25,7 @@ class Suid(AbstractCommOperate):
sql, params = self.objToSQL.toSelectSQL(entity)
Logger.logsql("select SQL:", sql)
super().log_params(params)
- list_r= self.beeSql.select(sql, self.to_class_t(entity), params) # 返回值用到泛型
+ list_r = self.beeSql.select(sql, self.to_class_t(entity), params)
return list_r
except Exception as e:
raise BeeException(e)
@@ -75,6 +76,39 @@ class Suid(AbstractCommOperate):
raise BeeException(e)
finally:
super().doBeforeReturnSimple()
+
+ # since 1.6.0
+ def select2(self, entity, condition: Condition=None):
+ if entity is None:
+ return None
+
+ try:
+ super().doBeforePasreEntity(entity, SuidType.SELECT)
+ sql, params = self.objToSQL.toSelectSQL2(entity, condition)
+ Logger.logsql("select SQL:", sql)
+ super().log_params(params)
+ list_r = self.beeSql.select(sql, self.to_class_t(entity), params)
+ return list_r
+ except Exception as e:
+ raise BeeException(e)
+ finally:
+ super().doBeforeReturn(list_r)
+
+ # since 1.6.0
+ def delete2(self, entity, condition: Condition=None):
+ if entity is None:
+ return None
+
+ try:
+ super().doBeforePasreEntity(entity, SuidType.DELETE)
+ sql, params = self.objToSQL.toDeleteSQL2(entity, condition)
+ Logger.logsql("delete SQL:", sql)
+ super().log_params(params)
+ return self.beeSql.modify(sql, params)
+ except Exception as e:
+ raise BeeException(e)
+ finally:
+ super().doBeforeReturnSimple()
def to_class_t(self, entity):
return type(entity) # 返回实体的类型
@@ -115,7 +149,7 @@ class SuidRich(Suid):
sql, params = self.objToSQL.toSelectSQLWithPaging(entity, start, size)
Logger.logsql("select_paging SQL:", sql)
super().log_params(params)
- list_r= self.beeSql.select(sql, self.to_class_t(entity), params)
+ list_r = self.beeSql.select(sql, self.to_class_t(entity), params)
return list_r
except Exception as e:
raise BeeException(e)
@@ -129,7 +163,7 @@ class SuidRich(Suid):
return 0
try:
- super().doBeforePasreListEntity(entity_list)
+ super().doBeforePasreListEntity(entity_list, SuidType.INSERT)
sql, list_params = self.objToSQL.toInsertBatchSQL(entity_list)
Logger.logsql("insert batch SQL:", sql)
super().log_params(list_params)
@@ -137,7 +171,7 @@ class SuidRich(Suid):
except Exception as e:
raise BeeException(e)
finally:
- super().doBeforeReturn()
+ super().doBeforeReturnSimple()
def select_first(self, entity):
# listT = self.select_paging(entity, 0, 2)
@@ -213,6 +247,44 @@ class SuidRich(Suid):
r = self.count(entity)
return r > 0
+ # /**
+ # * Update record according to whereFields.
+ # * @param entity table's entity(do not allow null).
+ # *
Fields that are not specified as whereFields, as part of the set(only non empty and non null fields
+ # *
are processed by default).
+ # * @param condition Condition as filter the record.
+ # * @param whereFields As a field list of where part in SQL, multiple fields can separated by commas in one
+ # *
whereField parameter or use variable parameter (the fields in the list will be used as where filter)
+ # *
But if id's value is null can not as filter.
+ # *
Notice:the method op of condition also maybe converted to the where expression.
+ # * @return the numbers of update record(s) successfully,if fails, return integer less than 0.
+ # * @since 1.6.0
+ # */
+ def updateBy(self, entity, condition: Condition=None, *whereFields):
+ if entity is None:
+ return None
+
+ print(len(whereFields))
+ print(type(whereFields))
+ if whereFields is None or len(whereFields) == 0 or (len(whereFields) == 1 and (not whereFields[0] or whereFields[0].isspace())):
+ raise ParamBeeException("whereFields at least include one field.")
+
+ try:
+ super().doBeforePasreEntity(entity, SuidType.UPDATE)
+ sql, params = self.objToSQL.toUpdateBySQL2(entity, condition, whereFields)
+ Logger.logsql("updateBy SQL:", sql)
+ super().log_params(params)
+ return self.beeSql.modify(sql, params)
+ except Exception as e:
+ raise BeeException(e)
+ finally:
+ super().doBeforeReturnSimple()
+
+ # since 1.6.0
+ # * @param entity table's entity(do not allow null).
+ # *
If the field of entity is not null or empty, it will be translate to field=value in where part.Other can define with condition.
+ # def update3(self, entity, condition: Condition=None, *updateFields):
+
def create_table(self, entityClass, is_drop_exist_table=None):
if is_drop_exist_table:
sql0 = self.objToSQL.toDropTableSQL(entityClass)
@@ -254,6 +326,7 @@ class PreparedSql(AbstractCommOperate):
"""
eg:
"""
+
def select(self, sql, return_type_class, params=None, start=None, size=None):
if sql is None:
return None
@@ -264,17 +337,16 @@ class PreparedSql(AbstractCommOperate):
Logger.logsql("select SQL(PreparedSql):", sql)
super().log_params(params)
- return self.beeSql.select(sql, return_type_class, params) # 返回值用到泛型
+ return self.beeSql.select(sql, return_type_class, params)
except Exception as e:
raise BeeException(e)
-
-
"""
eg:
preparedSql=PreparedSql()
entity_list =preparedSql.select_dict("SELECT * FROM orders WHERE name=#{name} and id=#{id} and name=#{name}", Orders, params_dict ={"name":"bee1","id":4})
"""
+
def select_dict(self, sql, return_type_class, params_dict=None, start=None, size=None):
if params_dict:
sql, params_dict = SqlUtil.transform_sql(sql, params_dict)
@@ -286,6 +358,7 @@ class PreparedSql(AbstractCommOperate):
params = ('bee130', 'test-update', 1)
updateNum = preparedSql.modify(sql, params)
"""
+
# def modify(self, sql: str, params=None) -> int:
def modify(self, sql, params=None):
try:
@@ -307,7 +380,6 @@ class PreparedSql(AbstractCommOperate):
sql, params_dict = SqlUtil.transform_sql(sql, params_dict)
return self.modify(sql, params_dict)
-
def __init__(self):
super().__init__()
self._beeSql = None
diff --git a/src/bee/condition.py b/src/bee/condition.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f4b8f84e02fd4e59c4402e802f78dc23f2811a4
--- /dev/null
+++ b/src/bee/condition.py
@@ -0,0 +1,424 @@
+from abc import ABC, abstractmethod
+from typing import List, Any
+
+from bee.context import HoneyContext
+from bee.exception import ParamBeeException, BeeErrorGrammarException
+from bee.name.naming_handler import NamingHandler
+from bee.osql.enum import FunctionType, Op, OrderType, SuidType
+from bee.osql.logger import Logger
+from bee.osql.sqlkeyword import K
+
+#since 1.6.0
+class Expression:
+
+ def __init__(self, field_name: str=None, Op: Op=None, op_type=None, value: Any=None,
+ op_num: int=None, value2: Any=None, value3: Any=None, value4: Any=None):
+ self.field_name = field_name
+ self.op_type = op_type if op_type else Op.get_name() if Op else None
+ self.op = Op
+ self.value = value
+ self.op_num = op_num # if op_num is not None else 2 # Default for binary operations
+ self.value2 = value2
+ self.value3 = value3
+ self.value4 = value4
+
+ def __str__(self):
+ if self.op_num == 2: # Binary operation
+ return f"{self.field_name} {self.op} {self.value}"
+ else:
+ return str(self.__dict__)
+
+
+class PreparedValue:
+
+ def __init__(self, typeStr: str, value: Any):
+ self.typeStr = typeStr
+ self.value = value
+
+ def __repr__(self):
+ return str(self.__dict__)
+
+
+class ConditionStruct:
+
+ def __init__(self, where: str, pv: List[PreparedValue], values: List, suidType:SuidType, selectFields:str, start:int, size:int, has_for_update:bool):
+ self.where = where
+ self.pv = pv
+ self.values = values
+ self.selectFields = selectFields
+ self.start = start
+ self.size = size
+ self.suidType = suidType
+ self.has_for_update = has_for_update
+
+ def __repr__(self):
+ return str(self.__dict__)
+
+
+class Condition(ABC):
+
+ @abstractmethod
+ def op(self, field: str, Op: Op, value: Any) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def opWithField(self, field: str, op: Op, field2: str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def and_(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def or_(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def not_(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def l_parentheses(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def r_parentheses(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def between(self, field: str, low: Any, high: Any) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def groupBy(self, field:str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def having(self, functionType:FunctionType, field: str, op: Op, value: Any) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def orderBy(self, field:str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def orderBy2(self, field:str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def orderBy3(self, field:str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def selectField(self, *field:str) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def forUpdate(self) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def start(self, start:int) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def size(self, size:int) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def suidType(self, suidType:SuidType) -> 'Condition':
+ pass
+
+ @abstractmethod
+ def getSuidType(self) -> 'Condition':
+ pass
+
+
+class ConditionImpl(Condition):
+
+ def __init__(self):
+ self.expressions = [] # List of Expression objects
+ self.where_fields = set() # Fields used in WHERE clause
+ self.__isStartOrderBy = True # 实例变量
+ self.__isStartGroupBy = True
+ self.__isStartHaving = True
+ self.__suidType = SuidType.SELECT
+
+ def __check_field(self, field):
+ pass # TODO
+
+ def op(self, field: str, Op: Op, value: Any) -> 'ConditionImpl':
+ self.__check_field(field)
+ exp = Expression(field_name=field, Op=Op, value=value, op_num=2)
+ self.expressions.append(exp)
+ self.where_fields.add(field)
+ return self
+
+ def and_(self) -> 'ConditionImpl':
+ exp = Expression(op_type=K.and_(), op_num=1)
+ self.expressions.append(exp)
+ return self
+
+ def or_(self) -> 'ConditionImpl':
+ exp = Expression(op_type=K.or_(), op_num=1)
+ self.expressions.append(exp)
+ return self
+
+ def not_(self) -> 'ConditionImpl':
+ exp = Expression(op=Op.eq, op_type=K.not_(), op_num=1)
+ self.expressions.append(exp)
+ return self
+
+ def l_parentheses(self) -> 'ConditionImpl':
+ exp = Expression(value="(", op_num=-2)
+ self.expressions.append(exp)
+ return self
+
+ def r_parentheses(self) -> 'ConditionImpl':
+ exp = Expression(value=")", op_num=-1)
+ self.expressions.append(exp)
+ return self
+
+ def between(self, field: str, low: Any, high: Any) -> 'ConditionImpl':
+ self.__check_field(field)
+ exp = Expression(field_name=field, op_type=K.between(), value=low, value2=high, op_num=3)
+ self.expressions.append(exp)
+ self.where_fields.add(field)
+ return self
+
+ def opWithField(self, field: str, op: Op, field2: str) -> 'ConditionImpl':
+ self.__check_field(field)
+ self.__check_field(field2)
+ expr = Expression(field_name=field, Op=op, value=field2, op_num=-3)
+ self.expressions.append(expr)
+ self.where_fields.add(field)
+ return self
+
+ # 'forUpdate', 'groupBy', 'orderBy', 'selectField', 'size', 'start'
+
+ def groupBy(self, field:str) -> 'Condition':
+ self.__check_field(field)
+ exp = Expression(field_name=field, op_type=K.group_by(), op_num=-4)
+
+ if self.__isStartGroupBy:
+ self.__isStartGroupBy = False
+ exp.value = K.group_by()
+ else:
+ exp.value = self.COMMA
+ self.expressions.append(exp)
+ return self
+
+ # having(FunctionType.MIN, "field", Op.ge, 60)-->having min(field)>=60
+ def having(self, functionType:FunctionType, field: str, op: Op, value: Any) -> 'Condition':
+ self.__check_field(field)
+ exp = Expression(field_name=field, Op=op, value=value, op_num=5)
+ exp.value2 = functionType
+
+ if self.__isStartHaving:
+ if self.__isStartGroupBy:
+ Logger.warn("The 'having' must be after 'group by'!")
+ self.__isStartHaving = False
+ exp.op_type = K.having()
+ else:
+ exp.op_type = K.and_()
+
+ self.expressions.append(exp)
+ self.where_fields.add(field)
+ return self
+
+ __COMMA = ","
+
+ def orderBy(self, field:str) -> 'Condition':
+ self.__check_field(field)
+ exp = Expression(field_name=field, op_type=K.order_by(), op_num=12)
+ self.expressions.append(exp)
+ if self.__isStartOrderBy:
+ self.__isStartOrderBy = False
+ exp.value = K.order_by()
+ else:
+ exp.value = self.__COMMA
+ return self
+
+ def orderBy2(self, field:str, orderType:OrderType) -> 'Condition':
+ self.__check_field(field)
+ exp = Expression(field_name=field, op_type=K.order_by(), op_num=13)
+ exp.value2 = orderType.get_name()
+ self.expressions.append(exp)
+ if self.__isStartOrderBy:
+ self.__isStartOrderBy = False
+ exp.value = K.order_by()
+ else:
+ exp.value = self.__COMMA
+ return self
+
+ def orderBy3(self, functionType:FunctionType, field:str, orderType:OrderType) -> 'Condition':
+ self.__check_field(field)
+ exp = Expression(field_name=field, op_type=K.order_by(), op_num=14)
+ exp.value2 = orderType.get_name()
+ exp.value3 = functionType.get_name()
+ self.expressions.append(exp)
+ if self.__isStartOrderBy:
+ self.__isStartOrderBy = False
+ exp.value = K.order_by()
+ else:
+ exp.value = self.__COMMA
+ return self
+
+ def selectField(self, *fields:str) -> 'Condition':
+ self.__check_field(fields)
+ exp = Expression(value=fields, op_num=20)
+ self.expressions.append(exp)
+ return self
+
+ def start(self, start:int) -> 'Condition':
+ if start is None or start < 0: # if not 0: is True
+ raise ParamBeeException("Parameter 'start' need >=0 .")
+ exp = Expression(value=start, op_num=21)
+ self.expressions.append(exp)
+ return self
+
+ def size(self, size:int) -> 'Condition':
+ if not size or size <= 0:
+ raise ParamBeeException("Parameter 'size' need >0 .")
+
+ exp = Expression(value=size, op_num=22)
+ self.expressions.append(exp)
+ return self
+
+ def suidType(self, suidType:SuidType) -> 'Condition':
+ self.__suidType = suidType
+ return self
+
+ #get
+ def getSuidType(self) -> 'Condition':
+ return self.__suidType
+
+ def forUpdate(self) -> 'Condition':
+ exp = Expression(op_type=K.for_update(), op_num=30)
+ self.expressions.append(exp)
+ return self
+
+ # parse
+ def parseCondition(self) -> ConditionStruct:
+ return ParseCondition.parse(self.expressions, self)
+
+
+class ParseCondition:
+
+ @staticmethod
+ def __getPlaceholder() -> str:
+ return HoneyContext.get_placeholder()
+
+ @staticmethod
+ def parse(expressions, condition:Condition) -> ConditionStruct:
+ where_clauses = []
+ prepared_values = []
+ values = []
+
+ is_need_and = False
+ suidType = condition.getSuidType()
+
+ def adjust_and() -> bool:
+ nonlocal is_need_and
+ if is_need_and:
+ where_clauses.append(" " + K.and_() + " ")
+ is_need_and = False
+ # return False
+ return is_need_and
+
+ ph = ParseCondition.__getPlaceholder()
+
+ __has_for_update = False
+ __selectFields = None
+ __start = None
+ __size = None
+ for exp in expressions:
+ # exp.field_name ->column_name
+ column_name = NamingHandler.toColumnName(exp.field_name)
+ if exp.op_num == 2: # Binary operation
+ is_need_and = adjust_and()
+ if exp.value is None:
+ where_clause = f"{column_name} {K.isnull()}"
+ else:
+ where_clause = f"{column_name} {exp.op} {ph}"
+ prepared_values.append(PreparedValue(type(exp.value), exp.value))
+ values.append(exp.value)
+ where_clauses.append(where_clause)
+ is_need_and = True
+ elif exp.op_num == 3: # BETWEEN
+ is_need_and = adjust_and()
+ where_clause = f"{column_name} {exp.op_type} {ph} {K.and_()} {ph}"
+ where_clauses.append(where_clause)
+ prepared_values.append(PreparedValue(type(exp.value), exp.value))
+ prepared_values.append(PreparedValue(type(exp.value), exp.value2))
+ values.append(exp.value)
+ values.append(exp.value2)
+ is_need_and = True
+ elif exp.op_num == -3: # eg:field1=field2
+ is_need_and = adjust_and()
+ where_clause = f"{column_name} {exp.op} {exp.value}"
+ where_clauses.append(where_clause)
+ is_need_and = True
+ elif exp.op_num == -4: # group by
+ if suidType != SuidType.SELECT:
+ raise BeeErrorGrammarException(suidType.get_name() + " do not support 'group by' !")
+
+ where_clause = f" {exp.value} {column_name}"
+ where_clauses.append(where_clause)
+
+ elif exp.op_num == 5: # having
+ if suidType != SuidType.SELECT:
+ raise BeeErrorGrammarException(suidType.get_name() + " do not support 'having' !")
+
+ where_clause = f" {exp.op_type} {exp.value2.get_name()}({column_name}) {exp.op} {ph}"
+ where_clauses.append(where_clause)
+ prepared_values.append(PreparedValue(type(exp.value), exp.value))
+ values.append(exp.value)
+
+ elif exp.op_num == 12 or exp.op_num == 13 or exp.op_num == 14: # order by
+ if suidType != SuidType.SELECT:
+ raise BeeErrorGrammarException(suidType.get_name() + " do not support 'order by' !")
+
+ where_clauses.append(" " + exp.value + " ") # order by或者,
+ if 14 == exp.op_num: # order by max(total)
+ where_clauses.append(exp.value3)
+ where_clauses.append("(")
+ where_clauses.append(column_name)
+ where_clauses.append(")")
+ else:
+ where_clauses.append(column_name)
+
+ if 13 == exp.op_num or 14 == exp.op_num: # 指定 desc,asc
+ where_clauses.append(" ");
+ where_clauses.append(exp.value2)
+
+ elif exp.op_num == 1: # Logical operator (AND, OR, NOT)
+ if exp.op_type == K.not_():
+ is_need_and = adjust_and()
+ where_clauses.append(f" {exp.op_type} ")
+ is_need_and = False
+ elif exp.op_num == -2: # Left parenthesis
+ is_need_and = adjust_and()
+ where_clauses.append("(")
+ elif exp.op_num == -1: # Right parenthesis
+ where_clauses.append(")")
+ is_need_and = True
+
+ elif exp.op_num == 20:
+ __selectFields = exp.value
+
+ elif exp.op_num == 21:
+ __start = exp.value
+ elif exp.op_num == 22:
+ __size = exp.value
+
+ elif exp.op_num == 30: # for update TODO
+ __has_for_update = True
+ else:
+ Logger.warn(f"Unknown operation number: {exp.op_num}")
+
+ # Join all where clauses into a single string
+ where_clause_str = "".join(where_clauses)
+
+ return ConditionStruct(where_clause_str, prepared_values, values, suidType, __selectFields, __start, __size, __has_for_update)
+
diff --git a/src/bee/config.py b/src/bee/config.py
index 17531286ab45fde8d694d600a38ef97fb9f05d4f..e76f4550af39494e2fd9d6f4b959f7cc5d2b81ad 100644
--- a/src/bee/config.py
+++ b/src/bee/config.py
@@ -78,6 +78,9 @@ class HoneyConfig:
try:
config_file = cls.__adjust_config_file(cls, config_file)
+ if not os.path.isfile(config_file):
+ Logger.info("Not found the file bee.properties!")
+ return
with open(config_file, 'r') as file:
cls._loaded = True # 设置为已加载
Logger.info("Loading config file: " + config_file)
@@ -140,7 +143,7 @@ class HoneyConfig:
if path_separator not in t_database:
root_dir = PreConfig.config_path
newPath = root_dir + path_separator + t_database
- Logger.warn("adjust the SQLite db file path to: " + newPath)
+ Logger.info("adjust the SQLite db file path to: " + newPath)
if not os.path.isfile(newPath):
raise ConfigBeeException(f"File not found in current path or adjust path: {newPath}")
cls.__db_config_data['database'] = newPath
diff --git a/src/bee/exception.py b/src/bee/exception.py
index d28ffef9e522e6bdf295102eb4bee5ca64c9a690..b5a6cdc9f3b27daf4271a8de22d8e68c0819c255 100644
--- a/src/bee/exception.py
+++ b/src/bee/exception.py
@@ -46,6 +46,8 @@ class ConfigBeeException(BeeException): ...
class SqlBeeException(BeeException): ...
+class ParamBeeException(BeeException): ...
+
class BeeErrorNameException(BeeException): ...
-class ParamBeeException(BeeException): ...
+class BeeErrorGrammarException(BeeException): ...
diff --git a/src/bee/factory.py b/src/bee/factory.py
index 1ce33fdafdb51da3ccb9c7044e629ff8ff9bab33..f2cc18e7c59bbf97689666dfce1d1d6dc677b6f3 100644
--- a/src/bee/factory.py
+++ b/src/bee/factory.py
@@ -1,10 +1,13 @@
-from bee.osql.honeyfactory import HoneyFactory
+# from bee.honeyfactory import HoneyFactory
+from bee.name.naming import *
+
class BeeFactory:
__connection = None
__instance = None
+ __honeyFactory=None
def __new__(cls):
if cls.__instance is None:
@@ -17,11 +20,31 @@ class BeeFactory:
def get_connection(self):
return BeeFactory.__connection
+
+ __nameTranslate = None
+
+ def getInitNameTranslate(self) -> NameTranslate:
+
+ if self.__nameTranslate is None:
+ # int translateType=HoneyConfig.getHoneyConfig().naming_translateType;
+ translateType = 1 # TODO from config
+ if translateType == 1: __nameTranslate = UnderScoreAndCamelName()
+ elif translateType == 2: __nameTranslate = UpperUnderScoreAndCamelName()
+ elif translateType == 3: __nameTranslate = OriginalName()
+ elif translateType == 4: __nameTranslate = DbUpperAndJavaLower()
+ else:__nameTranslate = UnderScoreAndCamelName()
+
+ return __nameTranslate;
+
# def __getattribute__(self, item):
# print(f"Accessing attribute: {item}")
# return super().__getattribute__(item)
+ # def getHoneyFactory(self):
+ # if self.__honeyFactory is None:
+ # __honeyFactory = HoneyFactory()
+ # return __honeyFactory
+
+
+
- def getHoneyFactory(self):
- return HoneyFactory()
-
\ No newline at end of file
diff --git a/src/bee/honeyfactory.py b/src/bee/honeyfactory.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3e993e6e83d78b6f87e5c566b704ab27ba112e0
--- /dev/null
+++ b/src/bee/honeyfactory.py
@@ -0,0 +1,104 @@
+from bee.api import Suid, SuidRich, PreparedSql
+from bee.obj2sql import ObjToSQL
+from bee.sqllib import BeeSql
+from bee.condition import ConditionImpl
+class HoneyFactory:
+
+ __instance = None
+
+ def __new__(cls):
+ if cls.__instance is None:
+ cls.__instance = super().__new__(cls)
+ return cls.__instance
+
+ def __init__(self):
+ self.suid = None
+ self.suidRich = None
+ self.beeSql = None
+ self.objToSQL = None
+ self.objToSQLRich = None
+ self.preparedSql = None
+ self.callableSql = None
+ self.condition = None
+
+ def getSuid(self):
+ if self.suid is None:
+ return Suid()
+ return self.suid
+
+ def setSuid(self, suid):
+ self.suid = suid
+
+ def getSuidRich(self):
+ if self.suidRich is None:
+ return SuidRich()
+ return self.suidRich
+
+ def setSuidRich(self, suidRich):
+ self.suidRich = suidRich
+
+ def getBeeSql(self):
+ if self.beeSql is None:
+ return BeeSql()
+ return self.beeSql
+
+ def setBeeSql(self, beeSql):
+ self.beeSql = beeSql
+
+ def getObjToSQL(self):
+ if self.objToSQL is None:
+ return ObjToSQL()
+ return self.objToSQL
+
+ def setObjToSQL(self, objToSQL):
+ self.objToSQL = objToSQL
+
+ # def getObjToSQLRich(self):
+ # if self.objToSQLRich is None:
+ # return ObjectToSQLRich()
+ # return self.objToSQLRich
+ #
+ # def setObjToSQLRich(self, objToSQLRich):
+ # self.objToSQLRich = objToSQLRich
+
+ def getPreparedSql(self):
+ if self.preparedSql is None:
+ return PreparedSql()
+ return self.preparedSql
+
+ def setPreparedSql(self, preparedSql):
+ self.preparedSql = preparedSql
+
+ # def getCallableSql(self):
+ # if self.callableSql is None:
+ # return CallableSqlLib()
+ # return self.callableSql
+ #
+ # def setCallableSql(self, callableSql):
+ # self.callableSql = callableSql
+
+ def getCondition(self):
+ if self.condition is None:
+ return ConditionImpl()
+ return self.condition
+
+ def setCondition(self, condition):
+ if condition is not None:
+ self.condition = condition.clone()
+ else:
+ self.condition = condition
+
+
+class BF:
+
+ @staticmethod
+ def suid():
+ return HoneyFactory().getSuid()
+
+ @staticmethod
+ def suidRich():
+ return HoneyFactory().getSuidRich()
+
+ @staticmethod
+ def condition():
+ return HoneyFactory().getCondition()
diff --git a/src/bee/name/naming_handler.py b/src/bee/name/naming_handler.py
index 4601f216914e3ff0589ecc35396b5907a289b26a..db73cec27aa7b215b15fb4c0385718a6ba97b10d 100644
--- a/src/bee/name/naming_handler.py
+++ b/src/bee/name/naming_handler.py
@@ -8,7 +8,7 @@ class NamingHandler:
def getNameTranslate() -> NameTranslate:
# TODO 下一步，要支持使用实时命名规则
factory = BeeFactory()
- return factory.getHoneyFactory().getInitNameTranslate()
+ return factory.getInitNameTranslate()
@staticmethod
def toTableName(entityName) -> str:
diff --git a/src/bee/obj2sql.py b/src/bee/obj2sql.py
index 89cd5e97dfe9f6fae4966714d653fcd3e5a57cee..78d00816364864863aceb0a8bc756a68bb5d2dd3 100644
--- a/src/bee/obj2sql.py
+++ b/src/bee/obj2sql.py
@@ -1,14 +1,16 @@
+from bee import SqlUtil
from bee.config import HoneyConfig
from bee.context import HoneyContext
-from bee.exception import SqlBeeException
+from bee.exception import SqlBeeException, ParamBeeException
from bee.name import NameCheckUtil
+from bee.name.naming_handler import NamingHandler
from bee.osql.const import DatabaseConst, SysConst
+from bee.osql.enum import SuidType
from bee.osql.logger import Logger
from bee.osql.sqlkeyword import K
-from bee.paging import Paging
from bee.util import HoneyUtil
-from bee.name.naming_handler import NamingHandler
+from bee.condition import Condition
class ObjToSQL:
@@ -19,11 +21,16 @@ class ObjToSQL:
table_name = HoneyUtil.get_table_name(entity)
return self.__build_select_sql(table_name, classField, fieldAndValue)
+ def toSelectSQL2(self, entity, condition: Condition):
+ fieldAndValue, classField = self.__getKeyValue_classField(entity)
+
+ table_name = HoneyUtil.get_table_name(entity)
+ return self.__build_select_sql2(table_name, classField, fieldAndValue, condition)
+
def toSelectSQLWithPaging(self, entity, start, size):
sql, params = self.toSelectSQL(entity)
- paging = Paging()
- sql = paging.to_page_sql(sql, start, size)
+ sql = SqlUtil.add_paging(sql, start, size)
return sql, params
def toUpdateSQL(self, entity):
@@ -44,7 +51,27 @@ class ObjToSQL:
table_name = HoneyUtil.get_table_name(entity)
return self.__build_update_sql(table_name, fieldAndValue, conditions)
+ def toUpdateBySQL2(self, entity, condition, whereFields):
+
+ # fieldAndValue = self.__getKeyValue(entity)
+ fieldAndValue, classField = self.__getKeyValue_classField(entity)
+ # print(type(whereFields))
+ # print(type(classField))
+ # whereFields=list(whereFields)
+ ext=list(set(whereFields) - set(classField))
+ # print(whereFields)
+ # print(classField)
+
+ # ext=whereFields-classField
+ # print(ext)
+
+ if ext:
+ raise ParamBeeException("some fields in whereFields not in bean: ", ext)
+
+ table_name = HoneyUtil.get_table_name(entity)
+ return self.__build_update_by_sql2(table_name, fieldAndValue, condition, whereFields)
+
def toInsertSQL(self, entity):
table_name = HoneyUtil.get_table_name(entity)
fieldAndValue = self.__getKeyValue(entity)
@@ -56,6 +83,11 @@ class ObjToSQL:
fieldAndValue = self.__getKeyValue(entity)
return self.__build_delete_sql(table_name, fieldAndValue)
+ def toDeleteSQL2(self, entity, condition):
+ table_name = HoneyUtil.get_table_name(entity)
+ fieldAndValue = self.__getKeyValue(entity)
+ return self.__build_delete_sql2(table_name, fieldAndValue, condition)
+
def toInsertBatchSQL(self, entity_list):
table_name = HoneyUtil.get_table_name(entity_list[0])
# fieldAndValue = self.__getKeyValue(entity_list[0])
@@ -164,17 +196,18 @@ class ObjToSQL:
def __getPlaceholder(self):
return HoneyContext.get_placeholder()
-
- def __build_update_sql(self, table_name, set_dict, conditions):
+ #updateById
+ def __build_update_sql(self, table_name, set_dict, entityFilter):
+ # entityFilter just pk
if not set_dict:
raise SqlBeeException("Update SQL's set part is empty!")
- # if not conditions: #还没有用到
+ # if not entityFilter: #还没有用到
# Logger.warn("Update SQL's where part is empty, would update all records!")
set_dict2 = self.__toColumns_with_dict(set_dict)
- conditions2 = self.__toColumns_with_dict(conditions)
+ conditions2 = self.__toColumns_with_dict(entityFilter)
ph=self.__getPlaceholder()
if self.__getPlaceholderType() == 3:
@@ -223,20 +256,20 @@ class ObjToSQL:
def __toColumns_with_dict(self, kv):
return {NamingHandler.toColumnName(k):v for k, v in kv.items()}
- def __build_where_condition(self, conditions):
- conditions2 = self.__toColumns_with_dict(conditions)
+ def __build_where_condition(self, entityFilter):
+ entityFilter2 = self.__toColumns_with_dict(entityFilter)
ph = self.__getPlaceholder()
if self.__getPlaceholderType() == 3:
- condition_str = f" {K.and_()} ".join(f"{key} = {ph}{key}" for key in conditions2.keys())
+ condition_str = f" {K.and_()} ".join(f"{key} = {ph}{key}" for key in entityFilter2.keys())
else:
- condition_str = f" {K.and_()} ".join(f"{key} = {ph}" for key in conditions2.keys())
+ condition_str = f" {K.and_()} ".join(f"{key} = {ph}" for key in entityFilter2.keys())
return condition_str
def __toColumns(self, classField):
return [NamingHandler.toColumnName(field) for field in classField]
- def __build_select_sql(self, table_name, classField, conditions=None):
+ def __build_select_sql(self, table_name, classField, entityFilter=None):
if not classField:
raise SqlBeeException("column list is empty!")
@@ -247,29 +280,153 @@ class ObjToSQL:
#where part
params = []
- if conditions:
- condition_str=self.__build_where_condition(conditions)
+ if entityFilter:
+ condition_str=self.__build_where_condition(entityFilter)
sql += f" {K.where()} {condition_str}"
- params = list(conditions.values())
+ params = list(entityFilter.values())
return sql, params
- def __build_select_by_id_sql(self, table_name, classField, where_condition_str):
- if not classField:
+ def __build_select_sql2(self, table_name, classField, entityFilter=None, condition=None):
+
+ if condition:
+ conditionStruct=condition.parseCondition()
+ selectFields=conditionStruct.selectFields
+
+ if not selectFields and not classField:
raise SqlBeeException("column list is empty!")
- columns = self.__toColumns(classField)
+ if selectFields:
+ columns=self.__toColumns(selectFields) # TODO
+ else:
+ columns=self.__toColumns(classField)
+
sql = f"{K.select()} {', '.join(columns)} {K.from_()} {table_name}"
- return sql + where_condition_str
-
- def __build_delete_sql(self, table_name, conditions):
+
+ #where part
+ params = []
+ if entityFilter:
+ condition_str=self.__build_where_condition(entityFilter)
+ sql += f" {K.where()} {condition_str}"
+ params = list(entityFilter.values())
+
+ if conditionStruct:
+ # condition_where=conditionStruct.where
+ # if condition_where:
+ # values=conditionStruct.values
+ # if entityFilter:
+ # sql += " "+ K.and_()
+ # else:
+ # sql +=" "+ K.where()
+ # sql +=" "+condition_where
+ # params = params + values
+ sql,params=self.__appendWhere(sql, params, entityFilter, conditionStruct)
+ start = conditionStruct.start
+ size = conditionStruct.size
+ if start or size:
+ sql = SqlUtil.add_paging(sql, start, size)
+ if conditionStruct.has_for_update:
+ sql += " " + K.for_update()
+
+ return sql, params
+
+ def __appendWhere(self,sql,params,entityFilter,conditionStruct):
+ if conditionStruct:
+ condition_where=conditionStruct.where
+ if condition_where:
+ values=conditionStruct.values
+ if entityFilter:
+ sql += " "+ K.and_()
+ else:
+ sql +=" "+ K.where()
+ sql +=" "+condition_where
+ params = params + values
+ return sql,params
+
+ def __build_delete_sql2(self, table_name, entityFilter, condition=None):
sql = f"{K.delete()} {K.from_()} {table_name}"
params = []
- if conditions:
- condition_str=self.__build_where_condition(conditions)
+ if entityFilter:
+ condition_str=self.__build_where_condition(entityFilter)
sql += f" {K.where()} {condition_str}"
- params = list(conditions.values())
+ params = list(entityFilter.values())
+
+ if condition:
+ condition.suidType(SuidType.DELETE)
+ conditionStruct=condition.parseCondition()
+ sql,params=self.__appendWhere(sql, params, entityFilter, conditionStruct)
+
return sql, params
+ def __build_update_by_sql2(self, table_name, entityFilter, condition, whereFields):
+
+ where_dict = {}
+ set_dict = {}
+ for key, value in entityFilter.items():
+ if key in whereFields:
+ where_dict[key] = value
+ else:
+ set_dict[key] = value
+
+ if not set_dict:
+ raise SqlBeeException("Update SQL's set part is empty!")
+
+ no_value_filter = set(whereFields) - set(where_dict)
+ # print(no_value_filter)
+
+ if condition:
+ condition.suidType(SuidType.UPDATE)
+ conditionStruct=condition.parseCondition()
+ where=conditionStruct.where
+ if not where_dict and not where:
+ Logger.warn("Update SQL's where part is empty, would update all records!")
+
+ set_dict2 = self.__toColumns_with_dict(set_dict)
+ conditions2 = self.__toColumns_with_dict(where_dict)
+
+ ph=self.__getPlaceholder()
+ if self.__getPlaceholderType() == 3:
+ updateSet = ', '.join(f"{key} = {ph}{key}" for key in set_dict2.keys())
+ condition_str = f" {K.and_()} ".join(f"{key} = {ph}{key}" for key in conditions2.keys())
+ else:
+ updateSet = ', '.join(f"{key} = {ph}" for key in set_dict2.keys())
+ condition_str = f" {K.and_()} ".join(f"{key} = {ph}" for key in conditions2.keys())
+
+ if no_value_filter:
+ no_value_filter2 = self.__toColumns(no_value_filter)
+ if condition_str:
+ condition_str+=" " +{K.and_()}
+ condition_str += f" {K.and_()} ".join(f"{key} {K.isnull()}" for key in no_value_filter2)
+
+ # sql = f"UPDATE {table_name} SET {updateSet} WHERE {condition_str}"
+ if condition_str:
+ sql = f"{K.update()} {table_name} {K.set()} {updateSet} {K.where()} {condition_str}"
+ else:
+ sql = f"{K.update()} {table_name} {K.set()} {updateSet}"
+ params = list(set_dict2.values()) + list(conditions2.values())
+
+ if where:
+ sql,params=self.__appendWhere(sql, params, whereFields, conditionStruct)
+
+ return sql, params
+
+
+ def __build_select_by_id_sql(self, table_name, classField, where_condition_str):
+ if not classField:
+ raise SqlBeeException("column list is empty!")
+
+ columns = self.__toColumns(classField)
+ sql = f"{K.select()} {', '.join(columns)} {K.from_()} {table_name}"
+ return sql + where_condition_str
+
+ def __build_delete_sql(self, table_name, entityFilter):
+ # sql = f"{K.delete()} {K.from_()} {table_name}"
+ # params = []
+ # if entityFilter:
+ # condition_str=self.__build_where_condition(entityFilter)
+ # sql += f" {K.where()} {condition_str}"
+ # params = list(entityFilter.values())
+ # return sql, params
+ return self.__build_delete_sql2(table_name, entityFilter, None)
def __build_delete_by_id_sql(self, table_name, where_condition_str):
sql = f"{K.delete()} {K.from_()} {table_name}"
diff --git a/src/bee/osql/enum.py b/src/bee/osql/enum.py
index fa2121177486129e4d071c57de85f996a7186d18..753e906f1fc59a5c12461da3a8f2366c268be86e 100644
--- a/src/bee/osql/enum.py
+++ b/src/bee/osql/enum.py
@@ -1,6 +1,20 @@
from enum import Enum
+from bee.config import PreConfig
+
+# class EnumCaseMeta(EnumMeta):
+# def __getattribute__(self, name):
+# value = super().__getattribute__(name)
+# if isinstance(value, self._enum_type_):
+# enum_member = value
+# if PreConfig.sql_key_word_case == "upper":
+# return enum_member._name_
+# else:
+# return enum_member._name_.lower()
+# return value
+
+# class FunctionType(Enum, metaclass=EnumCaseMeta):
class FunctionType(Enum):
MAX = "max"
MIN = "min"
@@ -8,8 +22,13 @@ class FunctionType(Enum):
AVG = "avg"
COUNT = "count"
+ # def get_name(self):
+ # return self.value
def get_name(self):
- return self.value
+ if PreConfig.sql_key_word_case == "upper":
+ return self.value.upper()
+ else:
+ return self.value.lower()
class SuidType(Enum):
@@ -27,7 +46,46 @@ class SuidType(Enum):
# def getType(self): # 为了更贴近 Java 的 getter 方法命名
# return self.type
- @property # 或者使用 property 装饰器
- def type_value(self):
- return self.type
+ # @property # 或者使用 property 装饰器
+ def get_name(self):
+ return self.value
+
+
+class OrderType(Enum):
+ ASC = "asc"
+ DESC = "desc"
+
+ # def get_name(self):
+ # return self.value
+ def get_name(self):
+ if PreConfig.sql_key_word_case == "upper":
+ return self.value.upper()
+ else:
+ return self.value.lower()
+
+ def __str__(self):
+ return self.get_name()
+
+class Op(Enum):
+ eq = "="
+ gt = ">"
+ lt = "<"
+ ne = "!="
+ ge = ">="
+ le = "<="
+ like = " like "
+ like_left = " like "
+ like_right = " like "
+ like_left_right = " like "
+ # not_like = " not like "
+ in_ = " in"
+ not_in = " not in"
+ # is_null = "IS NULL"
+ # is_not_null = "IS NOT NULL"
+
+ def get_name(self):
+ return self.value
+
+ def __str__(self):
+ return self.get_name()
diff --git a/src/bee/osql/honeyfactory.py b/src/bee/osql/honeyfactory.py
deleted file mode 100644
index b267f991c9a4218aa42e17ac377e9a696280460b..0000000000000000000000000000000000000000
--- a/src/bee/osql/honeyfactory.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from bee.name.naming import NameTranslate, UnderScoreAndCamelName, \
- UpperUnderScoreAndCamelName, OriginalName, DbUpperAndJavaLower
-
-
-class HoneyFactory:
-
- __nameTranslate = None
-
- def getInitNameTranslate(self) -> NameTranslate:
-
- if self.__nameTranslate is None:
- # int translateType=HoneyConfig.getHoneyConfig().naming_translateType;
- translateType = 1 # TODO from config
- if translateType == 1: __nameTranslate = UnderScoreAndCamelName()
- elif translateType == 2: __nameTranslate = UpperUnderScoreAndCamelName()
- elif translateType == 3: __nameTranslate = OriginalName()
- elif translateType == 4: __nameTranslate = DbUpperAndJavaLower()
- else:__nameTranslate = UnderScoreAndCamelName()
-
- return __nameTranslate;
diff --git a/src/bee/sqllib.py b/src/bee/sqllib.py
index 8df096d8c22ba4b9820fc8506c050b3b2db50234..5bda5267a87ca37803723e0f0c4f2068b29cfef4 100644
--- a/src/bee/sqllib.py
+++ b/src/bee/sqllib.py
@@ -25,7 +25,7 @@ class BeeSql:
# 将行数据映射到新创建的实体对象
target_obj = HoneyUtil.transform_result(row, column_names, entityClass)
rs_list.append(target_obj)
-
+ Logger.info(" | <-- select rows: " + str(len(rs_list)))
except Exception as e:
raise SqlBeeException(e)
finally:
@@ -37,11 +37,14 @@ class BeeSql:
# def modify(self, sql: str, params=None) -> int:
def modify(self, sql, params=None):
conn = self.__getConn()
+ a = 0
try:
cursor = conn.cursor()
cursor.execute(sql, params or [])
conn.commit()
- return cursor.rowcount # 返回受影响的行数
+ a = cursor.rowcount # 返回受影响的行数
+ Logger.info(" | <-- Affected rows: " + str(a))
+ return a
except Exception as e:
Logger.error(f"Error in modify: {e}")
conn.rollback()
@@ -51,11 +54,14 @@ class BeeSql:
def batch(self, sql, params=None):
conn = self.__getConn()
+ a = 0
try:
cursor = conn.cursor()
cursor.executemany(sql, params or [])
conn.commit()
- return cursor.rowcount # 返回受影响的行数
+ a = cursor.rowcount # 返回受影响的行数
+ Logger.info(" | <-- Affected rows: " + str(a))
+ return a
except Exception as e:
Logger.error(f"Error in batch: {e}")
conn.rollback()
@@ -71,7 +77,9 @@ class BeeSql:
try:
cursor = conn.cursor()
cursor.execute(sql, params or [])
- result = cursor.fetchone() # 返回一个元组，例如 (1,)
+ result = cursor.fetchone() # 返回一个元组，例如 (1,)
+ if result[0]:
+ Logger.info(" | <-- select rows: 1" )
return result[0]
except Exception as e:
diff --git a/tests/exam/BatchInsertTest.py b/tests/exam/BatchInsertTest.py
index 669f628d0a91959ab3aac3a92b0d15a351502197..b2f3eea32af99089b1c77d6eea236cc42fbcc676 100644
--- a/tests/exam/BatchInsertTest.py
+++ b/tests/exam/BatchInsertTest.py
@@ -26,15 +26,31 @@ if __name__ == '__main__':
student0=Student2()
student0.name = "bee"
+ student0.age=20
+ student0.remark= "bee"
student1=Student2()
student1.name = "bee1"
student1.addr=""
- student1.age=40
+ student1.age=22
+ student1.remark= "bee1"
+
+ student2=Student2()
+ student2.name = "黄二"
+ student2.addr=""
+ student2.age=21
+
+ student3=Student2()
+ student3.name = "张三"
+ student3.addr=""
+ student3.age=21
+
entity_list=[]
entity_list.append(student0)
entity_list.append(student1)
+ entity_list.append(student2)
+ entity_list.append(student3)
suidRich = SuidRich()
insertNum = suidRich.insert_batch(entity_list)
diff --git a/tests/exam15/ByIdTest.py b/tests/exam15/ByIdTest.py
index 2bb2bc9c4a27fa11f58d6749353e733ebb6b005b..0542220de33856c4372d42921ccf578d822bd094 100644
--- a/tests/exam15/ByIdTest.py
+++ b/tests/exam15/ByIdTest.py
@@ -15,7 +15,8 @@ if __name__ == '__main__':
suidRich = SuidRich()
# one = suidRich.select_by_id(orders) # 1.5.4
# one = suidRich.select_by_id(Orders,"1") #1.6.0
- one = suidRich.select_by_id(Orders,'bee') #1.6.0
+ one = suidRich.select_by_id(Orders,1)
+ # one = suidRich.select_by_id(Orders,'bee') #1.6.0
print(one)
# one = suidRich.select(orders)
diff --git a/tests/exam16/SuidTest1.py b/tests/exam16/SuidTest1.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bad056b46d11f95b043130093b665fe10b5c4f6
--- /dev/null
+++ b/tests/exam16/SuidTest1.py
@@ -0,0 +1,39 @@
+# from org.teasoft.exam.entity.Orders import Orders
+# from bee.api import Suid
+
+from bee.osql.enum import Op
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Orders import Orders
+
+
+# from bee.config import PreConfig
+# from org.teasoft.exam.entity.Test import Test
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ # orders=Orders(id=1, name="bee")
+ orders=Orders()
+ # orders = Test()
+ # orders.id=1
+ orders.name = "bee"
+
+ suid = BF.suid()
+ orderList = suid.select(orders) #test
+ for one in orderList:
+ print(one)
+
+ condition = BF.condition()
+ condition.op("name", Op.ne, "bee1").op("remark", Op.ne, "new2")
+ orderList = suid.select2(orders,condition)
+ for one in orderList:
+ print(one)
+
+
+
+
+
+ print("finished")
diff --git a/tests/exam16/SuidTest2.py b/tests/exam16/SuidTest2.py
new file mode 100644
index 0000000000000000000000000000000000000000..53365624671681c4e9ae35286d40d5a0eaec42bd
--- /dev/null
+++ b/tests/exam16/SuidTest2.py
@@ -0,0 +1,53 @@
+# from org.teasoft.exam.entity.Orders import Orders
+# from bee.api import Suid
+from bee.osql.enum import Op
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+# from bee.config import PreConfig
+# from org.teasoft.exam.entity.Test import Test
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+ # stu.name='张三'
+
+ suid = BF.suid()
+ # orderList = suid.select(stu) #test
+ # for one in orderList:
+ # print(one)
+
+ condition = BF.condition()
+ condition.op("name", Op.ne, "bee1").between("age", 20, 28)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ condition = BF.condition()
+ condition.op("name", Op.ne, "bee1").or_()
+ condition.l_parentheses().between("age", 20, 28).r_parentheses()
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ condition = BF.condition()
+ condition.opWithField("name", Op.eq, "remark")
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ # condition = BF.condition()
+ # condition.groupBy("name")
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+
+
+ print("finished")
diff --git a/tests/exam16/conditionTest.py b/tests/exam16/conditionTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c8778f5512f7be87c5890c4b6776c68c52d126f
--- /dev/null
+++ b/tests/exam16/conditionTest.py
@@ -0,0 +1,68 @@
+# from org.teasoft.exam.entity.Orders import Orders
+# from bee.api import Suid
+
+# from bee.config import PreConfig
+from bee.osql.enum import Op, OrderType, FunctionType
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+# from bee.config import PreConfig
+# from org.teasoft.exam.entity.Test import Test
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+ # stu.name='张三'
+
+ suid = BF.suid()
+
+ # condition = BF.condition()
+ # condition.op("name", Op.ne, "bee1").between("age", 20, 28)
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+ #
+ #
+ # condition = BF.condition()
+ # condition.op("name", Op.ne, "bee1").or_()
+ # condition.l_parentheses().between("age", 20, 28).r_parentheses()
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+ #
+ #
+ # condition = BF.condition()
+ # condition.opWithField("name", Op.eq, "remark")
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+
+ # PreConfig.sql_key_word_case="upper"
+
+ condition = BF.condition()
+ condition.selectField("name,age")
+ condition.op("name", Op.ne, "bee1")
+ condition.groupBy("name")
+ # having(FunctionType.MIN, "field", Op.ge, 60)-->having min(field)>=60
+ condition.having(FunctionType.MIN, "age", Op.ge, 25)
+ condition.having(FunctionType.MAX, "age", Op.lt, 30)
+ condition.orderBy("name")
+ condition.orderBy2("age",OrderType.DESC)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ # condition = BF.condition()
+ # condition.groupBy("name")
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+
+
+ print("finished")
diff --git a/tests/exam16/conditionTest2.py b/tests/exam16/conditionTest2.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2cfdf444f93ed196a87067d3ba736515702c702
--- /dev/null
+++ b/tests/exam16/conditionTest2.py
@@ -0,0 +1,40 @@
+# from org.teasoft.exam.entity.Orders import Orders
+# from bee.api import Suid
+
+# from bee.config import PreConfig
+from bee.osql.enum import Op
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+# from bee.config import PreConfig
+# from org.teasoft.exam.entity.Test import Test
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+ # stu.name='张三'
+
+ suid = BF.suid()
+
+
+ # empty condition
+ condition = BF.condition()
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ # field is null
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ print("finished")
diff --git a/tests/exam16/conditionTest3_paging.py b/tests/exam16/conditionTest3_paging.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba357d1b7b0fa6db03e0c96a1bfb3d539107244d
--- /dev/null
+++ b/tests/exam16/conditionTest3_paging.py
@@ -0,0 +1,66 @@
+from bee.osql.enum import Op
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+ # stu.name='张三'
+
+ suid = BF.suid()
+
+
+ # # empty condition
+ # condition = BF.condition()
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+
+ # field is null
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+ condition.start(10).size(10)
+ # condition.start(5)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+ # condition.start(0).size(10)
+ condition.start(5)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+ # condition.start(0).size(10)
+ # condition.start(5)
+ condition.size(10)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+ # condition.start("")
+ condition.size(10)
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+
+ print("finished")
diff --git a/tests/exam16/conditionTest4_delete.py b/tests/exam16/conditionTest4_delete.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1e6ab22cd710e56073933998a14f31abeff2185
--- /dev/null
+++ b/tests/exam16/conditionTest4_delete.py
@@ -0,0 +1,53 @@
+from bee.osql.enum import Op, FunctionType
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+
+ suid = BF.suid()
+
+
+ # empty condition
+ # condition = BF.condition()
+ # orderList = suid.select2(stu,condition)
+ # for one in orderList:
+ # print(one)
+
+ # field is null
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ delNum = suid.delete2(stu,condition)
+ print(delNum)
+
+
+
+ condition = BF.condition()
+ condition.op("name", Op.eq, "黄二")
+
+ orderList = suid.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ ##check do not support
+ # condition.groupBy("name")
+ # condition.having(FunctionType.MAX, "age", Op.lt, 30)
+ # condition.orderBy("name")
+ delNum = suid.delete2(stu,condition)
+ print(delNum)
+
+
+ print("finished")
diff --git a/tests/exam16/conditionTest5_update.py b/tests/exam16/conditionTest5_update.py
new file mode 100644
index 0000000000000000000000000000000000000000..527c0a03c7f01049be8d590cd78b3a6b4e2d007c
--- /dev/null
+++ b/tests/exam16/conditionTest5_update.py
@@ -0,0 +1,42 @@
+from bee.osql.enum import Op
+
+import MyConfig
+from bee.honeyfactory import BF
+from entity.Student2 import Student2
+
+
+if __name__ == '__main__':
+ print("start")
+
+ MyConfig.init()
+
+ stu=Student2()
+
+ suidRich = BF.suidRich()
+
+
+ # field is null
+ condition = BF.condition()
+ # condition.op("remark", Op.eq, None)
+ condition.op("addr", Op.eq, None)
+
+ orderList = suidRich.select2(stu,condition)
+ for one in orderList:
+ print(one)
+
+ stu.addr="use new addr"
+ stu.remark="bee"
+ # updateNum = suidRich.updateBy(stu,condition,"remark")
+ # updateNum = suidRich.updateBy(stu,condition,"id")
+ updateNum = suidRich.updateBy(stu,condition,"name")
+ # updateNum = suidRich.updateBy(stu,condition) # check
+ # updateNum = suidRich.updateBy(stu,condition,"")# check
+ # updateNum = suidRich.updateBy(stu,condition," ")# check
+ print(updateNum)
+ # updateBy SQL: update student2 set addr = ?, remark = ? where name is null and addr is null
+
+ orderList = suidRich.select(stu)
+ for one in orderList:
+ print(one)
+
+ print("finished")