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 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 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 __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 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 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_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 __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_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 __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_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 __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)