def __join_padding_str(self, n, func_name, method_info, input_params,
in_isarr, param_no, padding):
content = ""
padding_var = "padding"
content += "\t" * n + '{0}.clear();\n'.format(padding_var)
for param in input_params:
param_name = param.get(CSqlParse.PARAM_NAME)
pt = param.get(CSqlParse.PARAM_TYPE)
param_type = self.type_change(pt)
param_condition = param.get(CSqlParse.PARAM_CONDITION)
if param_condition is not None:
preix = "input{0}.".format(param_no)
if in_isarr == "true":
preix = "iter->"
str_prefix = ""
str_suffix = ""
if pt != "string":
str_prefix = "std::to_string("
str_suffix = ")"
param_condition = param_condition.replace(
"{}", '").append({2}{0}get{1}(){3}).append("'.format(
preix, CStringTools.upperFirstByte(param_name),
str_prefix, str_suffix))
content += "\t" * n + 'if ({0}get{1}Used()) {2}.append("{3}");\n'.format(
preix, CStringTools.upperFirstByte(param_name),
padding_var, param_condition)
content += "\t" * n + self.__get_input_set_posture_single(
func_name, method_info, in_isarr, input_params, param_no, padding,
padding_var)
return content
def __get_content(self):
content = ""
method_list = self.m_info_dict.get(CSqlParse.METHOD_LIST)
for method_info in method_list:
func_name = method_info.get(CSqlParse.FUNC_NAME)
define = "uint32_t {0}({1});".format(
func_name, self.get_method_param_list(func_name, method_info))
is_exist = CStringTools.is_exist(
r'(?:^|[ |\s]*?){0}'.format(
CStringTools.filter_reg_keyword(define)), self.m_content)
if is_exist is False:
content += self.write_method_define(method_info)
return content
def __read_data(self, func_name, output_params, isarr, method_info, n, param_no):
content = ""
var_type = self.get_output_class_name(func_name, method_info)
output_params_len = len(output_params)
content += "\t"*n + "std::vector<std::string> cols;\n"
content += "\t"*n + "cols.resize({0});\n".format(str(output_params_len))
content += "\t"*n + "bool b = row->scan(cols);\n"
content += "\t"*n + "if (!b) continue;\n"
if isarr is True:
content += "\t"*n + "{0} tmp;\n".format(var_type)
content += "\t"*n + "std::stringstream ss;\n"
tmp = "output{0}.".format(param_no)
if isarr is True:
tmp = "tmp."
i = 0
for param in output_params:
param_type = param.get(CSqlParse.PARAM_TYPE)
param_name = param.get(CSqlParse.PARAM_NAME)
if param_type is None or param_name is None:
continue
value = "cols[{0}]".format(i)
param_type = self.type_change(param_type)
if param_type != "std::string":
content += "\t"*n + "{0} {1} = 0;\n".format(param_type, param_name)
content += "\t"*n + "ss << cols[{0}];\n".format(i)
content += "\t"*n + "ss >> {0};\n".format(param_name)
content += "\t"*n + 'ss.clear();\n'
value = param_name
content += "\t"*n + "{0}set{1}({2});\n".format(tmp, CStringTools.upperFirstByte(param_name), value)
i += 1
if isarr is True:
# content += "\t"*1 + "}\n"
content += "\t"*n + "output{0}.push_back(tmp);\n".format(param_no)
return content
def write_set_method(self, param_type, param_name):
content = ""
param_type, is_custom_type = self.type_change(param_type)
content += "void set{0}(const {1} &{2})".format(
CStringTools.upperFirstByte(param_name), param_type, param_name)
content += " { this->" + "{0} = {0}".format(param_name) + "; }"
return content
def __replace_sql_brace(self, input_params, sql, is_group):
fulls, max_number = CStringTools.get_brace_format_list(sql)
param_len = len(input_params)
full_set = set(fulls)
full_len = len(full_set)
if is_group is False:
if param_len != full_len:
str_tmp = "[Param Length Error] may be last #define error ? fulllen length({1}) != params length({2})\n[sql] : \t{0}".format(
sql, full_len, param_len)
raise SystemExit(str_tmp)
if param_len < max_number + 1:
str_tmp = "[Param Match Error] may be last #define error ? input param length == {1}, max index == {2}\n[sql] : \t{0}".format(
sql, param_len, max_number)
raise SystemExit(str_tmp)
for number, keyword in list(full_set):
inpams = input_params[number]
tmp = ""
param_type = inpams.get(CSqlParse.PARAM_TYPE)
if inpams.get(CSqlParse.PARAM_IS_CONDITION) is False:
tmp += '\\"'
tmp += self.type2symbol(param_type)
if inpams.get(CSqlParse.PARAM_IS_CONDITION) is False:
tmp += '\\"'
sql = re.sub(keyword, tmp, sql)
return sql, fulls
def write_get_method(self, param_type, param_name):
content = ""
param_type = self.type_change(param_type)
content += "const {0} &get{1}() const".format(
param_type, CStringTools.upperFirstByte(param_name))
content += " { return this->" + param_name + "; }"
return content
def __replace_sql_brace(self, input_params, in_isarr, sql, param_no, is_group):
fulls, max_number = CStringTools.get_brace_format_list2(sql)
param_len = len(input_params)
full_set = set(fulls)
full_len = len(full_set)
if is_group is False:
if param_len != full_len:
str_tmp = "[Param Length Error] may be last #define error ? fulllen length({1}) != params length({2})\n[sql] : \t{0}".format(sql, full_len, param_len)
raise SystemExit(str_tmp)
if param_len < max_number + 1:
str_tmp = "[Param Match Error] may be last #define error ? input param length == {1}, max index == {2}\n[sql] : \t{0}".format(sql, param_len, max_number)
raise SystemExit(str_tmp)
for number, keyword, last_is_other, next_is_other in list(full_set):
inpams = input_params[number]
tmp = ""
if last_is_other is True:
tmp += '"'
if inpams.get(CSqlParse.PARAM_IS_CONDITION) is False:
tmp += """ << "'" << """
else:
tmp += " << "
value = self.__get_input_posture_single(in_isarr, inpams, param_no)
tmp += value
if inpams.get(CSqlParse.PARAM_IS_CONDITION) is False:
tmp += """ << "'" << """
else:
tmp += " << "
if next_is_other is True:
tmp += '"'
sql = re.sub(keyword, tmp, sql)
sql += '";\n'
return sql, fulls
def get_output_struct_name(self, method):
method_name = method.get(CSqlParse.FUNC_NAME)
out_class = method.get(CSqlParse.OUT_CLASS)
name = ""
if out_class is not None:
name = out_class
else:
name = method_name
return "C{0}Output".format(CStringTools.upperFirstByte(name))
def get_input_struct_name(self, method):
method_name = method.get(CSqlParse.FUNC_NAME)
in_class = method.get(CSqlParse.IN_CLASS)
name = ""
if in_class is not None:
name = in_class
else:
name = method_name
return "C{0}Input".format(CStringTools.upperFirstByte(name))
def write_set_method(self, param_type, param_name):
content = ""
param_type = self.type_change(param_type)
content += "void set{0}(const {1} &{2}, bool use = true)".format(
CStringTools.upperFirstByte(param_name), param_type, param_name)
content += " { this->" + "{0} = {0};".format(
param_name) + " this->" + "{0}Used = use;".format(
param_name) + " }"
return content
def __write_callback(self, func_name, out_isarr, output_params):
content = ""
callback_name = func_name + "Callback"
var_type = self.get_output_class_name(func_name)
isarr = False
if out_isarr is not None and out_isarr == "true":
isarr = True
var_type = "std::list<{0}>".format(var_type)
content += "int {0}(void *data, int colCount, char **colValue, char **colName)\n".format(
callback_name)
content += "{\n"
content += "\t" * 1 + "int ret = 0;\n"
content += "\n"
content += "\t" * 1 + "{0} *p = reinterpret_cast<{0}*>(data);\n".format(
var_type)
content += "\t" * 1 + "if (p == nullptr) return -1;\n"
tmp = "p->"
tmp_len = 1
if isarr is True:
tmp = "tmp."
tmp_len = 1
content += "\t" * 1 + "{0} tmp;\n".format(
self.get_output_class_name(func_name))
# content += "\t"*1 + "for (int i = 0; i < colCount; ++i)\n"
# content += "\t"*1 + "{\n"
i = 0
content += "\t" * tmp_len + "std::stringstream ss;\n"
for param in output_params:
param_type = param.get(CSqlParse.PARAM_TYPE)
param_name = param.get(CSqlParse.PARAM_NAME)
if param_type is None or param_name is None:
continue
value = "colValue[{0}]".format(i)
param_type = self.type_change(param_type)
content += "\t" * tmp_len + "if (colValue[{0}] != nullptr) ".format(
i) + "{\n"
if param_type != "std::string":
content += "\t" * (tmp_len + 1) + "{0} {1} = 0;\n".format(
param_type, param_name)
content += "\t" * (tmp_len +
1) + "ss << colValue[{0}];\n".format(i)
content += "\t" * (tmp_len +
1) + "ss >> {0};\n".format(param_name)
content += "\t" * (tmp_len + 1) + "ss.clear();\n"
value = param_name
content += "\t" * (tmp_len + 1) + "{0}set{1}({2});\n".format(
tmp, CStringTools.upperFirstByte(param_name), value)
content += "\t" * tmp_len + "}\n"
i += 1
if isarr is True:
# content += "\t"*1 + "}\n"
content += "\t" * 1 + "p->push_back(tmp);\n"
content += "\n"
content += "\t" * 1 + "return ret;\n"
content += "}\n"
return content
def __get_input_posture_single(self, in_isarr, input_param, param_no):
content = ""
preix = "input{0}.".format(param_no)
if in_isarr == "true":
preix = "iter->"
param_name = input_param.get(CSqlParse.PARAM_NAME)
param_type = input_param.get(CSqlParse.PARAM_TYPE)
content += "{0}get{1}()".format(preix, CStringTools.upperFirstByte(param_name))
if param_type == "string":
content += ".c_str()"
return content
def get_input_class_name(self, func_name, method_info):
in_class = method_info.get(CSqlParse.IN_CLASS)
name = ""
if in_class is not None:
name = in_class
else:
name = func_name
# hump_func_name = CStringTools.underling2HumpLarger(func_name)
hump_func_name = CStringTools.upperFirstByte(name)
input_name = "C{0}Input".format(hump_func_name)
return input_name
def inner(content, param_no):
sql = method.get(CSqlParse.SQL)
sql = re.sub(r"\\", "", sql)
tc = 1
var_name = "input{0}".format(str(param_no))
if in_ismul is True:
tc = 2
var_name = "v"
content += "\t" * 1 + "for _, v := range *input" + str(
param_no) + " {\n"
if output_params is not None and len(output_params) > 0:
content += "\t" * tc + "rows{0}, err := tx.Query(".format(
str(param_no))
else:
content += "\t" * tc + "result, err = tx.Exec("
sql, fulls = self.__replace_sql_brace(input_params, sql, False)
content += 'fmt.Sprintf(`{0}`'.format(sql)
if input_params is not None:
for param in input_params:
is_cond = param.get(CSqlParse.PARAM_IS_CONDITION)
if is_cond is True:
param_name = param.get(CSqlParse.PARAM_NAME)
content += ", {1}.{0}".format(
CStringTools.upperFirstByte(param_name), var_name)
content += ")"
content += self.__write_query_params(input_params, var_name, fulls)
content += ")\n"
tc = 1
end_str = "return err, rowCount"
if in_ismul is True:
tc = 2
end_str = "return err, rowCount"
content += "\t" * tc + 'if err != nil {\n'
content += "\t" * (tc + 1) + 'tx.Rollback()\n'
content += "\t" * (tc + 1) + '{0}\n'.format(end_str)
content += "\t" * tc + '}\n'
# if in_ismul is False:
# content += "\t"*1 + "tx.Commit()\n"
if output_params is not None and len(output_params) > 0:
content += "\t" * tc + 'defer rows{0}.Close()\n'.format(
str(param_no))
content += "\t" * tc + 'for rows' + str(
param_no) + '.Next() {\n'
content += "\t" * (tc + 1) + 'rowCount += 1\n'
content += self.__write_output(tc + 1, method, param_no)
content += "\t" * tc + '}\n'
else:
content += "\t" * tc + "var _ = result\n"
if in_ismul is True:
content += "\t" * 1 + '}\n'
param_no += 1
# if in_ismul is False:
# content += "\t"*1 + "tx.Commit()\n"
return content, param_no
def get_output_class_name(self, func_name, method_info):
out_class = method_info.get(CSqlParse.OUT_CLASS)
name = ""
if out_class is not None:
name = out_class
else:
name = func_name
# hump_func_name = CStringTools.underling2HumpLarger(func_name)
hump_func_name = CStringTools.upperFirstByte(name)
output_name = "C{0}Output".format(hump_func_name)
return output_name
def __write_struct(self, method, is_input, method_name, params,
struct_name):
content = ""
if self.__class_is_writed(is_input, method) is True:
return content
content += "type {0} struct".format(struct_name)
content += " {\n"
for param in params:
param_type = param.get(CSqlParse.PARAM_TYPE)
param_name = param.get(CSqlParse.PARAM_NAME)
if param_type is None or param_name is None:
raise SystemExit(
"[Error] method: {0}, type or name is none".format(
method_name))
param_type = self.type_change(param_type)
content += "\t" + "{0} {1}\n".format(
CStringTools.upperFirstByte(param_name), param_type)
content += "\t" + "{0}{1} bool\n".format(
CStringTools.upperFirstByte(param_name),
self.get_isvail_join_str())
content += "}\n\n"
return content
def __get_input_set_posture_single(self, func_name, method_info, in_isarr,
input_params, param_no, padding,
set_content):
content = ""
preix = "input{0}".format(param_no)
preix2 = "."
if in_isarr == "true":
preix = "*iter"
preix2 = "."
content += "const_cast<{4}&>({0}){1}set{2}({3});\n".format(
preix, preix2, CStringTools.upperFirstByte(padding), set_content,
self.get_input_class_name(func_name, method_info))
return content
def __write_query_params(self, input_params, var_name, fulls):
content = ""
if input_params is None:
return content
not_cond_params = []
for number, keyword in fulls:
param = input_params[number]
is_cond = param.get(CSqlParse.PARAM_IS_CONDITION)
if is_cond is True:
continue
not_cond_params.append(param)
if len(not_cond_params) > 0:
content += ", "
i = 0
for param in not_cond_params:
if i > 0:
content += ", "
i += 1
param_name = param.get(CSqlParse.PARAM_NAME)
param_type = param.get(CSqlParse.PARAM_TYPE)
content += "{0}.{1}".format(
var_name, CStringTools.upperFirstByte(param_name))
"""
not_cond_params = []
for param in input_params:
is_cond = param.get(CSqlParse.PARAM_IS_CONDITION)
if is_cond is False:
not_cond_params.append(param)
length = len(fulls)
if len(not_cond_params) > 0:
content += ", "
i = 0
forwardIsCond = False
for number, keyword in fulls:
param = input_params[number]
is_cond = param.get(CSqlParse.PARAM_IS_CONDITION)
if i > 0 and is_cond is False and forwardIsCond is False:
content += ", "
i += 1
if is_cond is True:
forwardIsCond = True
continue
else:
forwardIsCond = False
param_name = param.get(CSqlParse.PARAM_NAME)
param_type = param.get(CSqlParse.PARAM_TYPE)
content += "{0}.{1}".format(var_name, CStringTools.upperFirstByte(param_name))
"""
return content
def __get_input_posture(self, in_isarr, input_params, param_no):
content = ""
length = len(input_params)
i = 0
preix = "input{0}.".format(param_no)
if in_isarr == "true":
preix = "iter->"
for param in input_params:
i += 1
param_name = param.get(CSqlParse.PARAM_NAME)
param_type = param.get(CSqlParse.PARAM_TYPE)
content += "{0}get{1}()".format(preix, CStringTools.upperFirstByte(param_name))
if param_type == "string":
content += ".c_str()"
if i < length:
content += ", "
return content
def __get_input_brace_posture(self, in_isarr, input_params, fulls):
content = ""
length = len(fulls)
i = 0
preix = "input."
if in_isarr == "true":
preix = "iter->"
for number, keyword, last_is_other, next_is_other in fulls:
i += 1
param = input_params[number]
param_name = param.get(CSqlParse.PARAM_NAME)
param_type = param.get(CSqlParse.PARAM_TYPE)
content += "{0}get{1}()".format(preix, CStringTools.upperFirstByte(param_name))
if param_type == "string":
content += ".c_str()"
if i < length:
content += ", "
return content
def __write_output(self, tc, method, param_no):
in_isarr = method.get(CSqlParse.IN_ISARR)
out_isarr = method.get(CSqlParse.OUT_ISARR)
in_ismul = None
out_ismul = None
if in_isarr == "true":
in_ismul = True
else:
in_ismul = False
if out_isarr == "true":
out_ismul = True
else:
out_ismul = False
func_name = method.get(CSqlParse.FUNC_NAME)
output_params = method.get(CSqlParse.OUTPUT_PARAMS)
output_class_name = self.get_output_struct_name(method)
content = ""
length = 0
if output_params is not None:
length = len(output_params)
if length == 0:
return content
if out_ismul is True:
content += "\t" * tc + "tmp := {0}".format(
output_class_name) + "{}\n"
else:
pass
for param in output_params:
param_type = param.get(CSqlParse.PARAM_TYPE)
param_name = param.get(CSqlParse.PARAM_NAME)
param_type = self.type_null_change(param_type)
content += "\t" * tc + "var {0} {1}\n".format(
param_name, param_type)
content += "\t" * tc + "scanErr := rows{0}.Scan(".format(str(param_no))
i = 0
for param in output_params:
i += 1
param_name = param.get(CSqlParse.PARAM_NAME)
content += "&{0}".format(param_name)
if i < length:
content += ", "
content += ")\n"
content += "\t" * tc + "if scanErr != nil {\n"
content += "\t" * (tc + 1) + "continue\n"
content += "\t" * tc + "}\n"
pre = ""
if out_ismul is True:
pre = "tmp"
else:
pre = "output{0}".format(str(param_no))
for param in output_params:
param_type = param.get(CSqlParse.PARAM_TYPE)
param_name = param.get(CSqlParse.PARAM_NAME)
content += "\t" * tc + "{0}.{1} = {2}\n".format(
pre, CStringTools.upperFirstByte(param_name),
self.type_back(param_type, param_name))
content += "\t" * tc + "{0}.{1}{3} = {2}.Valid\n".format(
pre, CStringTools.upperFirstByte(param_name), param_name,
self.get_isvail_join_str())
if out_ismul is True:
content += "\t" * tc + "*output{0} = append(*output{0}, tmp)\n".format(
str(param_no))
return content
def __write_group(self, func_name, method_info, in_isarr, is_brace,
input_params, sql, n):
content = ""
# write implement
sql_group_info = method_info.get(CSqlParse.SQL_GROUP_INFO)
sql_group_list = sql_group_info.get(CSqlParse.SQL_GROUP_LIST)
group_input_params = method_info.get(CSqlParse.GROUP_INPUT_PARAMS)
sql_group_list_len = len(sql_group_list)
group_input_params_len = len(group_input_params)
if sql_group_list_len != group_input_params_len:
raise SystemExit("[Match Error] func_name: {0}".format(func_name))
groups = CStringTools.binary_bit_combination(sql_group_list_len)
j = 0
for group in groups:
j += 1
if j == 1:
content += "\t" * n + "if ("
else:
content += "\n" + "\t" * n + "else if ("
i = 0
group_len = len(group)
sql_tmp = sql
sql_tmp = re.sub(r"\/\*begin\{\d?\}\*\/", "", sql_tmp)
sql_tmp = re.sub(r"\/\*end\*\/", "", sql_tmp)
sql_tmp = re.sub(r"[ ]{2,}?", " ", sql_tmp)
for item in group:
i += 1
t_f = ""
if item == 0:
t_f = "false"
# replace
group_no, group_field = sql_group_list[i - 1]
index = sql_tmp.index(group_field)
pre = sql_tmp[index - 4:index].strip()
if pre == "and":
sql_tmp = self.__replace_substring_by_pos(
sql_tmp, index - 4, index, "")
size = len(group_field)
index = sql_tmp.index(group_field)
back = sql_tmp[index + size:index + size + 4].strip()
if back == "and":
sql_tmp = self.__replace_substring_by_pos(
sql_tmp, index + size, index + size + 4, "")
sql_tmp = sql_tmp.replace(group_field, "")
else:
t_f = "true"
this_field = "input."
if in_isarr == "true":
this_field = "iter->"
content += "{0}get{1}Used() == {2}".format(
this_field,
CStringTools.upperFirstByte(group_input_params[i - 1].get(
CSqlParse.PARAM_NAME)), t_f)
if i < group_len:
content += " && "
if 1 not in group:
sql_tmp = re.sub("where", "", sql_tmp)
tmp = ""
if is_brace is True:
sql_tmp, fulls = self.__replace_sql_brace(
input_params, sql_tmp, True)
tmp += "\t" * (
n + 1) + 'snprintf(buf, sizeof(buf), "{0}"'.format(sql_tmp)
if len(fulls) > 0:
tmp += "\n" + "\t" * (n + 2) + ", "
tmp += self.__get_input_brace_posture(in_isarr, input_params,
fulls)
tmp += ");"
else:
tmp += "\t" * (n +
1) + 'snprintf(buf, sizeof(buf), "{0}"'.format(
self.__replace_sql_by_input_params(
input_params, sql_tmp, True))
if len(fulls) > 0:
tmp += "\n" + "\t" * (n + 2) + ", "
tmp += self.__get_input_posture(in_isarr, input_params)
tmp += ");"
content += ") {\n" + "{0}\n".format(tmp) + "\t" * n + "}"
content += "\n"
return content
def get_output_class_name(self, func_name):
# hump_func_name = CStringTools.underling2HumpLarger(func_name)
hump_func_name = CStringTools.upperFirstByte(func_name)
output_name = "C{0}Output".format(hump_func_name)
return output_name
def get_interface_name(self, method_name): return CStringTools.upperFirstByte(method_name)
