feat: 准备迁移general service

app/general/general_utils/build_delete_sql.py

@@ -0,0 +1,18 @@
+from app.general.general_utils.sql_utils import log_sql
+
+
+def build_delete_sql(module_config, id):
+  if isinstance(id, list):
+    sql = f"delete from {module_config['tableName']} where id in ({','.join(['?'] * len(id))})"
+    values = id
+
+  else:
+    sql = f"delete from {module_config['tableName']} where id = ?"
+    values = [id]
+
+  log_sql(sql, values)
+  sql = sql.replace("?", "%s")
+  return (sql, values)
+
+# sql, values = build_delete_sql(DEMO_MODULE_CONFIG, ['111','2222'])
+# log_sql(sql, values)

app/general/general_utils/build_insert_sql.py

@@ -0,0 +1,40 @@
+from app.general.general_utils.sql_utils import format_columns, get_value, get_value_sql, log_sql
+
+
+def build_insert_sql(module_config, row):
+  column_info = format_columns(module_config["columns"])
+  sqls = [f"insert into {get_value(module_config, 'tableName')}"]
+  values = []
+
+  field_sql_left_list = []
+  field_sql_right_list = []
+  field_sql_right_values = []
+
+  for hump_name, column in column_info['hump_to_columns'].items():
+    value = get_value(row, hump_name)
+
+    # if (value === undefined) {return;}
+
+    if value is None:
+      continue;
+
+    if 't1.' not in column['query']:
+      continue
+
+    field_sql_left_list.append(column['col_name'])
+    field_sql_right_list.append(get_value_sql(
+      value=value,
+      value_type=column['valueType'],
+      sql_values=field_sql_right_values,
+    ))
+
+  sqls.append(f"( {', '.join(field_sql_left_list)} ) ")
+  sqls.append("values")
+  sqls.append(f"( {', '.join(field_sql_right_list)} )")
+  values.extend(field_sql_right_values)
+  sql = ' '.join(sqls)
+  log_sql(sql, values)
+  sql = sql.replace("?", "%s")
+  return (sql, values)
+
+# build_insert_sql(DEMO_MODULE_CONFIG, {"normalText": "123", "numberVal": 213})

app/general/general_utils/build_query_sql.py

@@ -0,0 +1,427 @@
+import re
+
+from app.general.general_utils.sql_utils import format_columns, get_value, log_sql
+
+
+def query_format(query: str, value_type: str):
+  if value_type == "string" or value_type == "number":
+    return query
+  elif value_type == "date":
+    return date_format_sql(query)
+  elif value_type == "datetime":
+    return datetime_format_sql(query)
+  elif value_type == "time":
+    return time_format_sql(query)
+
+
+def date_format_sql(query: str):
+  return f"date_format({query}, '%Y-%m-%d')"
+
+
+def datetime_format_sql(query: str):
+  return f"date_format({query}, '%Y-%m-%d %H:%i:%%s')"
+
+
+def time_format_sql(query: str):
+  return f"date_format({query}, '%H:%i:%%s')"
+
+
+def format_in(value, query, not_in, value_list):
+  # value_list.append(query)
+  # 如果 value 不是列表，将其按逗号分割成列表
+  if not isinstance(value, list):
+    list_ = value.split(',')
+  else:
+    list_ = value
+
+  # 将 list_ 中的元素添加到 valueList 中
+  value_list.extend(list_)
+
+  # 生成格式化字符串
+  result = f"{query} {'not ' if not_in else ''}in ({','.join('?' for _ in list_)})"
+  return result
+
+
+def format_in_like(value, query, not_like, value_list):
+  # 如果 value 不是列表，将其按逗号分割成列表
+  if not isinstance(value, list):
+    list_ = value.split(',')
+  else:
+    list_ = value
+
+  if not_like:
+    result_list = []
+    for item in list_:
+      value_list.append(f"%{item}%")
+      result_list.append(f"{query} not like ?")
+    return f"({' and '.join(result_list)})"
+  else:
+    result_list = []
+    for item in list_:
+      value_list.append(f"%{item}%")
+      result_list.append(f"{query} like ?")
+    return f"({' or '.join(result_list)})"
+
+
+def format_string2array(val):
+  return val if isinstance(val, list) else val.split(',')
+
+
+# 测试 convertor
+# print(json.dumps(DEMO_QUERY_CONFIG, indent=4))
+# convertor['encode_list'](DEMO_QUERY_CONFIG)
+# print(json.dumps(DEMO_QUERY_CONFIG, indent=4))
+
+# print(json.dumps(format_columns(DEMO_MODULE_CONFIG['columns']), indent=4))
+
+def build_query_sql(query_config, module_config):
+  column_info = format_columns(module_config["columns"])
+
+  # print("column_info ==>>", column_info)
+
+  distinct_fields = get_value(query_config, 'distinctFields', [])
+
+  has_distinct = len(distinct_fields) > 0
+
+  # /*---------------------------------------field sql-------------------------------------------*/
+  field_sql_list = []
+  field_sql_values = []
+
+  if has_distinct:
+    print("has_distinct", distinct_fields)
+    field_sql_list.append("distinct")
+    distinct_field_strings = []
+    for item_distinct_field in distinct_fields:
+      item_column_info = get_value(get_value(column_info, 'humpToColumns'), item_distinct_field)
+      item_field_string = f"{query_format(item_column_info['query'], item_column_info['valueType'])}"
+
+      if not get_value(query_config, 'onlyCount', False):
+        item_field_string = f"{item_field_string} as '{item_column_info['hump_name']}'"
+      distinct_field_strings.append(item_field_string)
+    field_sql_list.append(','.join(distinct_field_strings))
+  else:
+    field_strings = []
+    for hump_name, _ in module_config['columns'].items():
+      item_column_info = column_info["hump_to_columns"][hump_name]
+      # 有的humpName是关键词，得用''包裹
+      field_strings.append(f"{query_format(item_column_info['query'], item_column_info['valueType'])} as '{item_column_info['hump_name']}'")
+    field_sql_list.append(','.join(field_strings))
+
+  # print("field_sql_list ==>>", field_sql_list)
+  # print("field_sql_values ==>>", field_sql_values)
+
+  # /*---------------------------------------from sql-------------------------------------------*/
+
+  from_sql_list = ['from']
+  from_sql_values = []
+
+  from_sql_list.append(f"{module_config['tableName']} t1")
+
+  join_config = get_value(module_config, 'joinConfig', [])
+  if len(join_config):
+    for item_join_config in join_config:
+      item_join_config_type = get_value(item_join_config, 'type', '')
+      if item_join_config_type != 'right join' and item_join_config_type != 'left join' and item_join_config_type != 'join':
+        raise ValueError(f"Can't recognise join type:{item_join_config_type}")
+
+      from_sql_list.append(f"{item_join_config_type} {item_join_config['table']} {item_join_config['alia']} on {item_join_config['on']}")
+
+  # /*---------------------------------------filter sql-------------------------------------------*/
+
+  filter_sql_list = []
+  filter_sql_values = []
+
+  query_config_filters = get_value(query_config, 'filters', [])
+
+  if len(query_config_filters):
+    for index, item_filter in enumerate(query_config_filters):
+      # print(index, item_filter)
+      if get_value(item_filter, 'id', None) is None:
+        item_filter['id'] = f"_{index}"
+    # print(query_config_filters)
+    filter_expression = get_value(query_config, 'filterExpression', None) or ' and '.join(item['id'] for item in query_config_filters)
+    filter_expression = re.sub(r'\s+(并且|&&)\s+', ' and ', filter_expression)
+    filter_expression = re.sub(r'\s+(或者|\|\|)\s+', ' or ', filter_expression)
+
+    id_2_filter = {item['id']: item for item in query_config_filters}
+
+    def replace_func(match):
+
+      full_match = match.group(0)
+      filter_id = full_match
+
+      if filter_id == 'and' or filter_id == 'or':
+        return filter_id
+
+      filter_info = get_value(id_2_filter, filter_id, None)
+
+      if filter_info is None:
+        return f"[NoMatchFilterForId:{filter_id}]"
+
+      filter_field = filter_info['field']
+      item_column = get_value(column_info['hump_to_columns'], filter_field, None)
+
+      if item_column is None:
+        return f"[NoMatchColumnForField:{filter_field}]"
+
+      filter_type = get_value(filter_info, 'type', None) or get_value(item_column, 'valueType', None) or 'string'
+      value = get_value(filter_info, 'value', None)
+      filter_operator = filter_info['operator']
+      query = item_column['query']
+
+      if filter_type == "string":
+        if filter_operator == '=' or filter_operator == '>' or filter_operator == '>=' or filter_operator == '<' or filter_operator == '<=':
+          filter_sql_values.append(value)
+          return f"{query} = ?"
+        elif filter_operator == '!=':
+          filter_sql_values.append(value)
+          return f"{query} != ?"
+        elif filter_operator == '~':
+          filter_sql_values.append(f"%{value}%")
+          return f"{query} like ?"
+        elif filter_operator == 'in':
+          return format_in(value, query, False, filter_sql_values)
+        elif filter_operator == 'not in':
+          return format_in(value, query, True, filter_sql_values)
+        elif filter_operator == 'in like':
+          return format_in_like(value, query, False, filter_sql_values)
+        elif filter_operator == 'not in like':
+          return format_in_like(value, query, True, filter_sql_values)
+        elif filter_operator == 'is null':
+          return f"{query} is null"
+        elif filter_operator == 'is not null':
+          return f"{query} is not null"
+      elif filter_type == "number":
+        if filter_operator == '=':
+          filter_sql_values.append(value)
+          return f"{query} = ?"
+        elif filter_operator == '!=':
+          filter_sql_values.append(value)
+          return f"{query} != ?"
+        elif filter_operator == '~':
+          filter_sql_values.append(f"%{value}%")
+          return f"{query} like ?"
+        elif filter_operator == '>':
+          filter_sql_values.append(value)
+          return f"{query} > ?"
+        elif filter_operator == '>=':
+          filter_sql_values.append(value)
+          return f"{query} >= ?"
+        elif filter_operator == '<':
+          filter_sql_values.append(value)
+          return f"{query} < ?"
+        elif filter_operator == '<=':
+          filter_sql_values.append(value)
+          return f"{query} <= ?"
+        elif filter_operator == 'in':
+          return format_in(value, query, False, filter_sql_values)
+        elif filter_operator == 'not in':
+          return format_in(value, query, True, filter_sql_values)
+        elif filter_operator == 'in like':
+          return format_in_like(value, query, False, filter_sql_values)
+        elif filter_operator == 'not in like':
+          return format_in_like(value, query, True, filter_sql_values)
+        elif filter_operator == 'is null':
+          return f"{query} is null"
+        elif filter_operator == 'is not null':
+          return f"{query} is not null"
+      elif filter_type == "date":
+        if filter_operator == '=' or filter_operator == '~':
+          filter_sql_values.append(value)
+          return f"{date_format_sql(query)} = ?"
+        elif filter_operator == '!=':
+          filter_sql_values.append(value)
+          return f"{date_format_sql(query)} != ?"
+        elif filter_operator == '>':
+          filter_sql_values.append(value)
+          return f"{query} > ?"
+        elif filter_operator == '>=':
+          filter_sql_values.append(value)
+          return f"{query} >= ?"
+        elif filter_operator == '<':
+          filter_sql_values.append(value)
+          return f"{query} < ?"
+        elif filter_operator == '<=':
+          filter_sql_values.append(value)
+          return f"{query} <= ?"
+        elif filter_operator == 'in' or filter_operator == 'in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{date_format_sql(query)} in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'not in' or filter_operator == 'not in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{date_format_sql(query)} not in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'is null':
+          return f"{query} is null"
+        elif filter_operator == 'is not null':
+          return f"{query} is not null"
+      elif filter_type == "time":
+        if filter_operator == '=' or filter_operator == '~':
+          filter_sql_values.append(value)
+          return f"{time_format_sql(query)} = ?"
+        elif filter_operator == '!=':
+          filter_sql_values.append(value)
+          return f"{time_format_sql(query)} != ?"
+        elif filter_operator == '>':
+          filter_sql_values.append(value)
+          return f"{query} > ?"
+        elif filter_operator == '>=':
+          filter_sql_values.append(value)
+          return f"{query} >= ?"
+        elif filter_operator == '<':
+          filter_sql_values.append(value)
+          return f"{query} < ?"
+        elif filter_operator == '<=':
+          filter_sql_values.append(value)
+          return f"{query} <= ?"
+        elif filter_operator == 'in' or filter_operator == 'in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{time_format_sql(query)} in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'not in' or filter_operator == 'not in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{time_format_sql(query)} not in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'is null':
+          return f"{query} is null"
+        elif filter_operator == 'is not null':
+          return f"{query} is not null"
+        return
+      elif filter_type == "datetime":
+        if filter_operator == '=' or filter_operator == '~':
+          filter_sql_values.append(value)
+          return f"{datetime_format_sql(query)} = ?"
+        elif filter_operator == '!=':
+          filter_sql_values.append(value)
+          return f"{datetime_format_sql(query)} != ?"
+        elif filter_operator == '>':
+          filter_sql_values.append(value)
+          return f"{query} > ?"
+        elif filter_operator == '>=':
+          filter_sql_values.append(value)
+          return f"{query} >= ?"
+        elif filter_operator == '<':
+          filter_sql_values.append(value)
+          return f"{query} < ?"
+        elif filter_operator == '<=':
+          filter_sql_values.append(value)
+          return f"{query} <= ?"
+        elif filter_operator == 'not in' or filter_operator == 'not in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{datetime_format_sql(query)} in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'in' or filter_operator == 'in like':
+          v_list = format_string2array(value)
+          filter_sql_values.extend(v_list)
+          return f"{datetime_format_sql(query)} not in ({','.join('?' for _ in v_list)})"
+        elif filter_operator == 'is null':
+          return f"{query} is null"
+        elif filter_operator == 'is not null':
+          return f"{query} is not null"
+        return
+      else:
+        return f"NoMatchFilterType:{filter_type}"
+
+      return f"filter type {filter_type} no match operator: ${filter_operator}"
+
+    new_filter_expression = re.sub(r'[a-zA-Z0-9_-]+', replace_func, filter_expression)
+
+    filter_sql_list.extend(['where', new_filter_expression])
+
+  # /*---------------------------------------only count-------------------------------------------*/
+
+  sqls = []
+  values = []
+
+  query_config_only_count = get_value(query_config, 'onlyCount', False)
+
+  if query_config_only_count:
+    if not has_distinct:
+      sqls.append("select count(0) as total")
+    else:
+      sqls.append(f"select count( {' '.join(field_sql_list)} ) as total")
+      values.extend(field_sql_values)
+
+    sqls.extend(from_sql_list)
+    values.extend(from_sql_values)
+
+    sqls.extend(filter_sql_list)
+    values.extend(filter_sql_values)
+  else:
+    sqls.append('select')
+
+    sqls.extend(field_sql_list)
+    values.extend(field_sql_values)
+
+    sqls.extend(from_sql_list)
+    values.extend(from_sql_values)
+
+    sqls.extend(filter_sql_list)
+    values.extend(filter_sql_values)
+
+    def get_sort_sql_value():
+      sort_sql_list = []
+      sort_sql_values = []
+
+      query_config_orders = get_value(query_config, 'orders', [])
+      query_config_orders = query_config_orders if isinstance(query_config_orders, list) else [query_config_orders]
+
+      if len(query_config_orders) > 0:
+        sort_sql_list.append("order by")
+        temp_list = []
+
+        for sort_item in query_config_orders:
+          sn = ''
+          sc = ''
+
+          if isinstance(sort_item, str):
+            sn = sort_item
+            sc = 'desc'
+          else:
+            sn = sort_item['field']
+            sc = 'desc' if sort_item['desc'] else 'asc'
+
+          column_item = get_value(column_info['hump_to_columns'], sn, None)
+
+          if column_item is None:
+            temp_list.append(f"[NoMatchSortField:{sn}]")
+          else:
+            temp_list.append(f"{column_item['query']} {sc}")
+
+        sort_sql_list.append(', '.join(temp_list))
+      return (sort_sql_list, sort_sql_values)
+
+    sort_sql_list, sort_sql_values = get_sort_sql_value()
+
+    sqls.extend(sort_sql_list)
+    values.extend(sort_sql_values)
+
+  query_config_all = get_value(query_config, 'all', False)
+
+  if not query_config_all:
+    sqls.append("limit ?,?")
+    values.extend([
+      get_value(query_config, 'offset', 0),
+      get_value(query_config, 'size', 10)
+    ])
+  # /*---------------------------------------end-------------------------------------------*/
+
+  sql = ' '.join(sqls)
+  log_sql(sql, values)
+  sql = sql.replace("?", "%s")
+
+  return (sql, values)
+
+# sql, values = build_query_sql(DEMO_MODULE_CONFIG, {
+#     "page": 0,
+#     "size": 10,
+#     "filters": [
+#         {
+#             "field": "count",
+#             "operator": "is null",
+#             "id": "query_meta_1"
+#         }
+#     ]
+# })
+# log_sql(sql, values)

app/general/general_utils/build_update_sql.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+
+from app.general.general_utils.sql_utils import get_value, format_columns, get_value_sql, log_sql
+
+UPDATE_EXCLUDE_FIELDS = ['id', 'createAt', 'createdBy']
+
+
+def build_update_sql(module_config, row, param_update_fields=None):
+  row_id = get_value(row, 'id', None)
+
+  if row_id is None:
+    raise Exception("row_id is None")
+
+  column_info = format_columns(module_config["columns"])
+  sqls = [f"update {module_config['tableName']} set"]
+  values = []
+
+  field_sql_list = []
+  for hump_name, column in column_info['hump_to_columns'].items():
+    value = get_value(row, hump_name, None)
+    if hump_name in UPDATE_EXCLUDE_FIELDS:
+      continue
+    if not column['query'].startswith('t1.'):
+      continue
+    if param_update_fields is not None and hump_name not in param_update_fields:
+      # 如果有指定更新的字段，并且humpName不在这个字段列表中，则不更新这个字段
+      continue
+    if hump_name == 'updateAt':
+      value = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    field_sql_list.append(f"{column['col_name']} = {get_value_sql(value=value, value_type=column['valueType'], sql_values=values, )}")
+  sqls.append(', '.join(field_sql_list))
+  sqls.append("where id = ?")
+  values.append(row_id)
+
+  sql = ' '.join(sqls)
+  log_sql(sql, values)
+  sql = sql.replace("?", "%s")
+  return (sql, values)
+
+# build_update_sql(DEMO_MODULE_CONFIG, DEMO_QUERY_ROWS[0],['normalText','numberVal'])

app/general/general_utils/sql_service.py

@@ -0,0 +1,362 @@
+from app.general.general_utils.build_delete_sql import build_delete_sql
+from app.general.general_utils.build_insert_sql import build_insert_sql
+from app.general.general_utils.build_query_sql import build_query_sql
+from app.general.general_utils.build_update_sql import build_update_sql
+from app.general.general_utils.sql_utils import get_value, create_convertor
+
+
+def get_default_orders(query_config, module_config):
+  orders = get_value(query_config, 'orders', None)
+  if orders is not None:
+    return orders
+  module_config_default_orders = get_value(
+    get_value(module_config, 'default', {}),
+    'orders',
+    None
+  )
+  if module_config_default_orders is not None:
+    return module_config_default_orders
+  return {"field": "createdAt", "desc": True}
+
+
+def get_id(cursor, len):
+  if len is None:
+    len = 1
+  sql = f"select {','.join([f'uuid() as _{idx}' for idx in range(len)])}"
+  cursor.execute(sql)
+  rows = cursor.fetchall()
+
+  columns = [column[0] for column in cursor.description]
+  result = [dict(zip(columns, row)) for row in rows]
+
+  return [val for key, val in result[0].items()]
+
+
+def list(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+
+  n_page = get_value(query_config, 'page', 0)
+  n_size = get_value(query_config, 'size', 5)
+  n_only_count = get_value(query_config, 'onlyCount', False)
+
+  offset = n_page * n_size
+  # 多查一条数据，方便判断是否有下一页数据
+  size = n_size + 1
+
+  target_query_config = {
+    **query_config,
+    "offset": offset,
+    "size": size,
+    "orders": get_default_orders(query_config, module_config)
+  }
+
+  sql, values = build_query_sql(target_query_config, module_config)
+
+  try:
+
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    rows = cursor.fetchall()
+
+    # 将查询结果转换为字典列表
+    columns = [column[0] for column in cursor.description]
+    result = [dict(zip(columns, row)) for row in rows]
+
+    create_convertor(module_config)['decode_list'](result)
+
+    if n_only_count:
+      return {
+        "total": result[0]['total']
+      }
+    else:
+      has_next = False if get_value(query_config, 'all', False) else len(result) == n_size + 1
+      if has_next:
+        result.pop()
+      return {
+        "hasNext": has_next,
+        "list": result,
+      }
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+def item(connect_config, query_config, module_config, debug_data=[]):
+  target_query_config = {
+    "offset": 0,
+    "size": 1,
+    "filters": [],
+    "orders": {"field": "createdAt", "desc": True},
+  }
+  for humpName, value in query_config.items():
+    target_query_config['filters'].append({
+      "field": humpName,
+      "value": value,
+      "operator": "="
+    })
+
+  result = list(connect_config=connect_config, query_config=target_query_config, module_config=module_config, debug_data=debug_data)
+
+  if "error" in result:
+    return result
+
+  return {"result": None if "list" not in result or len(result['list']) == 0 else result['list'][0]}
+
+
+def insert(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+
+  row = get_value(query_config, 'row', None)
+  if row is None:
+    return {
+      "error": "row parameter is missing",
+    }
+  create_convertor(module_config)['encode_list']([row])
+
+  row_id = get_value(row, 'id', None)
+
+  if row_id is None:
+    row_id = get_id(cursor, 1)[0]
+    row['id'] = row_id
+
+  try:
+    sql, values = build_insert_sql(module_config, row)
+
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    conn.commit()
+
+    sql, values = build_query_sql({"page": 0, "size": 1, "filters": [{"field": "id", "operator": "=", "value": row_id}]}, module_config)
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    rows = cursor.fetchall()
+
+    columns = [column[0] for column in cursor.description]
+    result = [dict(zip(columns, row)) for row in rows]
+
+    create_convertor(module_config)['decode_list'](result)
+
+    if len(result) > 0:
+      return {
+        "result": result[0]
+      }
+    else:
+      return {
+        "error": "insert failed, query result is empty",
+      }
+
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+def batch_insert(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+
+  rows = get_value(query_config, 'rows', None)
+  if rows is None or len(rows) == 0:
+    return {
+      "error": "rows parameter is missing",
+    }
+  create_convertor(module_config)['encode_list'](rows)
+
+  row_id_list = []
+  for row in rows:
+    row_id = get_value(row, 'id', None)
+    if row_id is None:
+      row_id = get_id(cursor, 1)[0]
+      row['id'] = row_id
+    row_id_list.append(row_id)
+
+  try:
+    for row in rows:
+      sql, values = build_insert_sql(module_config, row)
+      debug_data.append({"sql": sql, "values": values})
+      cursor.execute(sql, values)
+
+    conn.commit()
+
+    sql, values = build_query_sql({"all": True, "filters": [{"field": "id", "operator": "in", "value": row_id_list}]}, module_config)
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    rows = cursor.fetchall()
+
+    columns = [column[0] for column in cursor.description]
+    result = [dict(zip(columns, row)) for row in rows]
+
+    create_convertor(module_config)['decode_list'](result)
+
+    if len(result) > 0:
+      return {
+        "result": result
+      }
+    else:
+      return {
+        "error": "insert failed, query result is empty",
+      }
+
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+def update(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+
+  row = get_value(query_config, 'row', None)
+  update_fields = get_value(query_config, 'updateFields', None)
+
+  if row is None:
+    return {
+      "error": "row parameter is missing",
+    }
+
+  row_id = get_value(row, 'id', None)
+
+  if row_id is None:
+    return {
+      "error": "row is missing field: id",
+    }
+
+  create_convertor(module_config)['encode_list']([row])
+
+  try:
+    sql, values = build_update_sql(module_config, row, update_fields)
+
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    conn.commit()
+
+    sql, values = build_query_sql({"page": 0, "size": 1, "filters": [{"field": "id", "operator": "=", "value": row_id}]}, module_config)
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    rows = cursor.fetchall()
+
+    columns = [column[0] for column in cursor.description]
+    result = [dict(zip(columns, row)) for row in rows]
+
+    create_convertor(module_config)['decode_list'](result)
+
+    if len(result) > 0:
+      return {
+        "result": result[0]
+      }
+    else:
+      return {
+        "error": "update failed, query result is empty",
+      }
+
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+def batch_update(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+
+  rows = get_value(query_config, 'rows', None)
+  update_fields = get_value(query_config, 'updateFields', None)
+
+  if rows is None or len(rows) == 0:
+    return {
+      "error": "rows parameter is missing",
+    }
+  create_convertor(module_config)['encode_list'](rows)
+
+  row_id_list = []
+  for row in rows:
+    row_id = get_value(row, 'id', None)
+    if row_id is None:
+      return {
+        "error": "row is missing field: id",
+        "row": row,
+      }
+    row_id_list.append(row_id)
+
+  try:
+    for row in rows:
+      sql, values = build_update_sql(module_config, row, update_fields)
+      debug_data.append({"sql": sql, "values": values})
+      cursor.execute(sql, values)
+
+    conn.commit()
+
+    sql, values = build_query_sql({"all": True, "filters": [{"field": "id", "operator": "in", "value": row_id_list}]}, module_config)
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    rows = cursor.fetchall()
+
+    columns = [column[0] for column in cursor.description]
+    result = [dict(zip(columns, row)) for row in rows]
+
+    create_convertor(module_config)['decode_list'](result)
+
+    if len(result) > 0:
+      return {
+        "result": result
+      }
+    else:
+      return {
+        "error": "update failed, query result is empty",
+      }
+
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+def delete(connect_config, query_config, module_config, debug_data=[]):
+  conn, cursor, close = get_sql_connection(connect_config)
+  id = get_value(query_config, 'id', None)
+  if id is None:
+    return {
+      "error": "id parameter is missing",
+    }
+
+  try:
+    sql, values = build_delete_sql(module_config, id)
+    debug_data.append({"sql": sql, "values": values})
+    cursor.execute(sql, values)
+    conn.commit()
+
+    deleted_rows = cursor.rowcount
+
+    if deleted_rows >= 1:
+      return {"deletedRows": deleted_rows}
+    else:
+      return {"error": f"delete failed, delete rows is {deleted_rows}", }
+  except mysql.connector.Error as err:
+    return {
+      "error": f"Error: {err}",
+    }
+  finally:
+    close()
+
+
+class SqlService():
+  def __init__(self):
+    self.list = list
+    self.item = item
+    self.insert = insert
+    self.update = update
+    self.delete = delete
+    self.batch_insert = batch_insert
+    self.batch_update = batch_update
+
+
+sql_service = SqlService()

app/general/general_utils/sql_utils.py

@@ -0,0 +1,203 @@
+import json
+import re
+
+
+# 将json字符串中的 \u00A0 全部去掉，\u00A0 表示 &nbsp，当这个字符存在的时候会导致无法将json字符串合法地解析为对象/字典
+def format_json_string(json_str):
+  json_str = re.sub(r'\u00A0', '', json_str)
+  return json_str
+
+
+# 将值转化为json字符串
+def array_json_encoder(val):
+  return json.dumps(val, ensure_ascii=False)
+
+
+# 将json字符串转为数组
+def array_json_decoder(val):
+  try:
+    return json.loads(val)
+  except json.JSONDecodeError:
+    return ""
+
+
+# 将数组转为逗号连接的字符串
+def array_string_encoder(val):
+  return ",".join(val) if isinstance(val, list) else val
+
+
+# 将逗号连接的字符串转换为数组
+def array_string_decoder(val):
+  return val.split(",") if isinstance(val, str) else val
+
+
+# 值格式化类型arrayjson
+MODULE_CONVERT_TYPE_ARRAY_JSON = 'arrayjson'
+# 值格式化类型arraystring
+MODULE_CONVERT_TYPE_ARRAY_STRING = 'arraystring'
+
+# 转化工具
+ConvertTypes = {
+  "arrayjson": {
+    "encode": array_json_encoder,
+    "decode": array_json_decoder,
+  },
+  "arraystring": {
+    "encode": array_string_encoder,
+    "decode": array_string_decoder,
+  }
+}
+
+
+# 根据module_config创建一个转化器
+def create_convertor(config):
+  convert_columns = [(col_name, col_config) for col_name, col_config in config["columns"].items() if col_config.get("convert")]
+
+  # print('convert_columns ==>>', convert_columns)
+
+  # 将值转化为字符串
+  def encode_list(list_):
+    if not len(convert_columns):
+      return
+    for item in list_:
+      for col_name, col_config in convert_columns:
+        if get_value(item, col_name, None) is not None:
+          if not isinstance(item[col_name], str):
+            item[col_name] = ConvertTypes[col_config["convert"]]["encode"](item[col_name])
+
+  # 将字符串转化为值
+  def decode_list(list_):
+    if not len(convert_columns):
+      return
+    for item in list_:
+      for col_name, col_config in convert_columns:
+        if get_value(item, col_name, None) is not None:
+          if isinstance(item[col_name], str):
+            item[col_name] = ConvertTypes[col_config["convert"]]["decode"](item[col_name])
+
+  return {
+    "encode_list": encode_list,
+    "decode_list": decode_list
+  }
+
+
+# 将驼峰命名转换为下划线命名
+def to_line(hump_name: str) -> str:
+  return re.sub(r'([A-Z])', r'_\1', hump_name).lower()
+
+
+# 格式化字段信息
+def format_columns(columns):
+  # 通过驼峰命名找到字段信息
+  hump_to_columns = {}
+  # 通过下划线命名找到字段信息
+  line_to_columns = {}
+
+  for hump_name, col_config in columns.items():
+    line_name = to_line(hump_name)
+    query = get_value(col_config, "query", None) or f"t1.{line_name}"
+    info = {
+      **col_config,
+      "hump_name": hump_name,
+      "line_name": line_name,
+      "query": query,
+      "col_name": query.split('.')[1]
+    }
+    hump_to_columns[hump_name] = info
+    line_to_columns[line_name] = info
+  return {
+    # 通过下划线命令查找列信息
+    "hump_to_columns": hump_to_columns,
+    # 通过驼峰命名查找列信息
+    "line_to_columns": line_to_columns,
+  }
+
+
+# 通用的获取属性值的方法
+def get_value(obj, attr_name, default=None):
+  if isinstance(obj, dict):
+    return obj.get(attr_name, default)
+  else:
+    return getattr(obj, attr_name, default)
+
+
+# 获取值的sql查询语句
+def get_value_sql(value, value_type, sql_values):
+  if value_type == 'string' or value_type == 'number':
+    sql_values.append(value)
+    return '?'
+  elif value_type == 'date':
+    sql_values.append(value)
+    return "str_to_date(?, '%Y-%m-%d')"
+  elif value_type == 'datetime':
+    sql_values.append(value)
+    return "str_to_date(?, '%Y-%m-%d %H:%i:%%s')"
+  elif value_type == 'time':
+    sql_values.append(value)
+    return "str_to_date(?, '%H:%i:%%s')";
+
+
+def parse_env_content(env_content):
+  """
+  将.env文件内容解析为字典格式
+
+  Args:
+      env_content (str): .env文件的内容字符串
+
+  Returns:
+      dict: 包含所有环境变量的字典
+  """
+  config_dict = {}
+
+  # 按行分割内容
+  lines = env_content.strip().split('\n')
+
+  # 定义注释和值的正则表达式
+  pattern = r'^([^=#]+)=([^#]*)(?:#.*)?$'
+
+  for line in lines:
+    line = line.strip()
+    if line and not line.startswith('#'):  # 忽略空行和纯注释行
+      match = re.match(pattern, line)
+      if match:
+        key = match.group(1).strip()
+        value = match.group(2).strip()
+        # 移除可能存在的引号
+        if value.startswith('"') and value.endswith('"'):
+          value = value[1:-1]
+        elif value.startswith("'") and value.endswith("'"):
+          value = value[1:-1]
+        config_dict[key] = value
+
+  return config_dict
+
+
+show_sql = True
+
+
+# 一个用于打印sql的工具函数
+def log_sql(sql, values):
+  if show_sql:
+    print("\n/*---------------------------------------log sql-------------------------------------------*/\n")
+    print("\nsource sql-->>\n")
+    print(sql)
+    print("\nsql params-->>\n")
+    print(values)
+    count = 0
+
+    def replace_callback(match):
+      nonlocal count
+      val = values[count]
+      count = count + 1
+      if isinstance(val, str):
+        return val
+      if isinstance(val, list):
+        return ', '.join(map(str, val))
+      # formatDebugData 要加上''，不然有些关键词没有''当做字符串的话会报错
+      return f"'{str(val)}'"
+
+    import re
+    target_sql = re.sub(r'\?+', replace_callback, sql)
+    print("\ntarget sql-->>\n")
+    print(target_sql)
+    print("\n")