new

sqlmaps_executor.go

@@ -13,6 +13,11 @@ type SqlMapsExecutor struct {
 }
 
 func (sqlMapsExecutor *SqlMapsExecutor) Execute() ([][]map[string]interface{}, map[string][]map[string]interface{}, error) {
+	defer sqlMapsExecutor.session.resetStatement()
+	if sqlMapsExecutor.session.IsAutoClose {
+		defer sqlMapsExecutor.session.Close()
+	}
+
 	if sqlMapsExecutor.err != nil {
 		return nil, nil, sqlMapsExecutor.err
 	}
@@ -23,51 +28,85 @@ func (sqlMapsExecutor *SqlMapsExecutor) Execute() ([][]map[string]interface{}, m
 
 	sqlModel := 1
 
+	if sqlMapsExecutor.session.IsSqlFuc == true {
+		err := sqlMapsExecutor.session.Begin()
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
 	switch sqlMapsExecutor.sqlkeys.(type) {
 	case string:
-		sqlkey := strings.TrimSpace(sqlMapsExecutor.sqlkeys.(string))
+		sqlkey := sqlMapsExecutor.sqlkeys.(string)
 		sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkey)
+		sqlStr = strings.TrimSpace(sqlStr)
 		sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
 
 		if sqlMapsExecutor.parmas == nil {
 			switch sqlCmd {
 			case "select", "desc":
 				model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey).Query()
-			case "insert", "delete", "update", "create":
+				sqlModel = 1
+			case "insert", "delete", "update", "create", "drop":
 				model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey).Execute()
 				sqlModel = 2
+			default:
+				sqlModel = 3
 			}
 		} else {
 			switch sqlMapsExecutor.parmas.(type) {
 			case []map[string]interface{}:
 				parmaMap, ok := sqlMapsExecutor.parmas.([]map[string]interface{})
 				if !ok {
+					if sqlMapsExecutor.session.IsSqlFuc == true {
+						err1 := sqlMapsExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
+						}
+					}
 					return nil, nil, ErrParamsType
 				}
 				switch sqlCmd {
 				case "select", "desc":
 					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap[0]).Query()
-
-				case "insert", "delete", "update", "create":
+					sqlModel = 1
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap[0]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
 
 			case map[string]interface{}:
 				parmaMap, ok := sqlMapsExecutor.parmas.(map[string]interface{})
 				if !ok {
+					if sqlMapsExecutor.session.IsSqlFuc == true {
+						err1 := sqlMapsExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
+						}
+					}
 					return nil, nil, ErrParamsType
 				}
 
 				switch sqlCmd {
 				case "select", "desc":
 					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap).Query()
-				case "insert", "delete", "update", "create":
+					sqlModel = 1
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
 
 			default:
+				if sqlMapsExecutor.session.IsSqlFuc == true {
+					err1 := sqlMapsExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
 				return nil, nil, ErrParamsType
 			}
 		}
@@ -76,14 +115,26 @@ func (sqlMapsExecutor *SqlMapsExecutor) Execute() ([][]map[string]interface{}, m
 
 		if sqlModel == 1 {
 			if model_1_results.Error != nil {
+				if sqlMapsExecutor.session.IsSqlFuc == true {
+					err1 := sqlMapsExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
 				return nil, nil, model_1_results.Error
 			}
 
 			resultSlice[0] = make([]map[string]interface{}, len(model_1_results.Results))
 			resultSlice[0] = model_1_results.Results
 			return resultSlice, nil, nil
-		} else {
+		} else if sqlModel == 2 {
 			if err != nil {
+				if sqlMapsExecutor.session.IsSqlFuc == true {
+					err1 := sqlMapsExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
 				return nil, nil, err
 			}
 
@@ -101,206 +152,366 @@ func (sqlMapsExecutor *SqlMapsExecutor) Execute() ([][]map[string]interface{}, m
 			resultMap[0]["RowsAffected"] = RowsAffected
 			resultSlice[0] = resultMap
 			return resultSlice, nil, nil
+		} else {
+			resultSlice[0] = nil
 		}
 	case []string:
-		if sqlMapsExecutor.session.IsSqlFuc == true {
-			err := sqlMapsExecutor.session.Begin()
-			if err != nil {
-				return nil, nil, err
-			}
-		}
+
 		sqlkeysSlice := sqlMapsExecutor.sqlkeys.([]string)
 		n := len(sqlkeysSlice)
 		resultSlice := make([][]map[string]interface{}, n)
 		parmaSlice := make([]map[string]interface{}, n)
-		switch sqlMapsExecutor.parmas.(type) {
-		case []map[string]interface{}:
-			parmaSlice = sqlMapsExecutor.parmas.([]map[string]interface{})
-
-		default:
-			if sqlMapsExecutor.session.IsSqlFuc == true {
-				err := sqlMapsExecutor.session.Rollback()
-				if err != nil {
-					return nil, nil, err
-				}
-			}
-			return nil, nil, ErrParamsType
-		}
 
-		for i, _ := range sqlkeysSlice {
-			sqlkey := strings.TrimSpace(sqlkeysSlice[i])
-			sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkey)
-			sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
-			if parmaSlice[i] == nil {
-				switch sqlCmd {
-				case "select", "desc":
-					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey).Query()
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey).Execute()
-					sqlModel = 2
-				}
-			} else {
+		if sqlMapsExecutor.parmas == nil {
+			for i, _ := range sqlkeysSlice {
+				sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkeysSlice[i])
+				sqlStr = strings.TrimSpace(sqlStr)
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
+
 				switch sqlCmd {
 				case "select", "desc":
-					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaSlice[i]).Query()
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaSlice[i]).Execute()
+					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i]).Query()
+					sqlModel = 1
+				case "insert", "delete", "update", "create", "drop":
+					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
-			}
 
-			if sqlModel == 1 {
-				if model_1_results.Error != nil {
-					if sqlMapsExecutor.session.IsSqlFuc == true {
-						err := sqlMapsExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, model_1_results.Error
 					}
-					return nil, nil, model_1_results.Error
-				}
 
-				resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
-				resultSlice[i] = model_1_results.Results
+					resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultSlice[i] = model_1_results.Results
 
-			} else {
-				if err != nil {
-					if sqlMapsExecutor.session.IsSqlFuc == true {
-						err := sqlMapsExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, err
 					}
-					return nil, nil, err
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultSlice[i] = make([]map[string]interface{}, 1)
+					resultSlice[i] = resultMap
+
+				} else {
+					resultSlice[i] = nil
 				}
 
-				resultMap := make([]map[string]interface{}, 1)
-				resultMap[0] = make(map[string]interface{})
+			}
+
+		} else {
+			switch sqlMapsExecutor.parmas.(type) {
+			case []map[string]interface{}:
+				parmaSlice = sqlMapsExecutor.parmas.([]map[string]interface{})
 
-				//todo all database support LastInsertId
-				LastInsertId, _ := model_2_results.LastInsertId()
+			default:
+				if sqlMapsExecutor.session.IsSqlFuc == true {
+					err1 := sqlMapsExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
+				return nil, nil, ErrParamsType
+			}
 
-				resultMap[0]["LastInsertId"] = LastInsertId
-				RowsAffected, err := model_2_results.RowsAffected()
-				if err != nil {
-					return nil, nil, err
+			for i, _ := range sqlkeysSlice {
+				sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkeysSlice[i])
+				sqlStr = strings.TrimSpace(sqlStr)
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
+
+				if parmaSlice[i] == nil {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				} else {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i], &parmaSlice[i]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysSlice[i], &parmaSlice[i]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
 				}
-				resultMap[0]["RowsAffected"] = RowsAffected
-				resultSlice[i] = make([]map[string]interface{}, 1)
-				resultSlice[i] = resultMap
 
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, model_1_results.Error
+					}
+
+					resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultSlice[i] = model_1_results.Results
+
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultSlice[i] = make([]map[string]interface{}, 1)
+					resultSlice[i] = resultMap
+
+				} else {
+					resultSlice[i] = nil
+				}
 			}
+
 		}
 
 		if sqlMapsExecutor.session.IsSqlFuc == true {
-			err := sqlMapsExecutor.session.Commit()
-			if err != nil {
-				return nil, nil, err
+			err1 := sqlMapsExecutor.session.Commit()
+			if err1 != nil {
+				return nil, nil, err1
 			}
 		}
 		return resultSlice, nil, nil
 
 	case map[string]string:
-		if sqlMapsExecutor.session.IsSqlFuc == true {
-			err := sqlMapsExecutor.session.Begin()
-			if err != nil {
-				return nil, nil, err
-			}
-		}
+
 		sqlkeysMap := sqlMapsExecutor.sqlkeys.(map[string]string)
 		n := len(sqlkeysMap)
 		resultsMap := make(map[string][]map[string]interface{}, n)
 		parmasMap := make(map[string]map[string]interface{}, n)
-		switch sqlMapsExecutor.parmas.(type) {
-		case map[string]map[string]interface{}:
-			parmasMap = sqlMapsExecutor.parmas.(map[string]map[string]interface{})
-
-		default:
-			if sqlMapsExecutor.session.IsSqlFuc == true {
-				err := sqlMapsExecutor.session.Rollback()
-				if err != nil {
-					return nil, nil, err
-				}
-			}
-			return nil, nil, ErrParamsType
-		}
 
-		for k, _ := range sqlkeysMap {
-			sqlkey := strings.TrimSpace(sqlkeysMap[k])
-			sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkey)
-			sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
-			if parmasMap[k] == nil {
-				switch sqlCmd {
-				case "select", "desc":
-					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey).Query()
+		if sqlMapsExecutor.parmas == nil {
+			for k, _ := range sqlkeysMap {
+				sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkeysMap[k])
+				sqlStr = strings.TrimSpace(sqlStr)
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
 
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey).Execute()
-					sqlModel = 2
-				}
-			} else {
-				parmaMap := parmasMap[k]
 				switch sqlCmd {
 				case "select", "desc":
-					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap).Query()
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkey, &parmaMap).Execute()
+					model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k]).Query()
+					sqlModel = 1
+				case "insert", "delete", "update", "create", "drop":
+					model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
-			}
 
-			if sqlModel == 1 {
-				if model_1_results.Error != nil {
-					if sqlMapsExecutor.session.IsSqlFuc == true {
-						err := sqlMapsExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, model_1_results.Error
 					}
-					return nil, nil, model_1_results.Error
-				}
 
-				resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
-				resultsMap[k] = model_1_results.Results
+					resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultsMap[k] = model_1_results.Results
 
-			} else {
-				if err != nil {
-					if sqlMapsExecutor.session.IsSqlFuc == true {
-						err := sqlMapsExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, err
 					}
-					return nil, nil, err
-				}
 
-				resultMap := make([]map[string]interface{}, 1)
-				resultMap[0] = make(map[string]interface{})
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
 
-				//todo all database support LastInsertId
-				LastInsertId, _ := model_2_results.LastInsertId()
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
 
-				resultMap[0]["LastInsertId"] = LastInsertId
-				RowsAffected, err := model_2_results.RowsAffected()
-				if err != nil {
-					if sqlMapsExecutor.session.IsSqlFuc == true {
-						err := sqlMapsExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultsMap[k] = make([]map[string]interface{}, 1)
+					resultsMap[k] = resultMap
+
+				} else {
+					resultsMap[k] = nil
+				}
+
+			}
+
+		} else {
+			switch sqlMapsExecutor.parmas.(type) {
+			case map[string]map[string]interface{}:
+				parmasMap = sqlMapsExecutor.parmas.(map[string]map[string]interface{})
+
+			default:
+				if sqlMapsExecutor.session.IsSqlFuc == true {
+					err1 := sqlMapsExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
+				return nil, nil, ErrParamsType
+			}
+
+			for k, _ := range sqlkeysMap {
+				sqlStr := sqlMapsExecutor.session.Engine.GetSql(sqlkeysMap[k])
+				sqlStr = strings.TrimSpace(sqlStr)
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
+				if parmasMap[k] == nil {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				} else {
+					parmaMap := parmasMap[k]
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k], &parmaMap).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlMapsExecutor.session.SqlMapClient(sqlkeysMap[k], &parmaMap).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
 					}
-					return nil, nil, err
 				}
-				resultMap[0]["RowsAffected"] = RowsAffected
-				resultsMap[k] = make([]map[string]interface{}, 1)
-				resultsMap[k] = resultMap
 
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, model_1_results.Error
+					}
+
+					resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultsMap[k] = model_1_results.Results
+
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlMapsExecutor.session.IsSqlFuc == true {
+							err1 := sqlMapsExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultsMap[k] = make([]map[string]interface{}, 1)
+					resultsMap[k] = resultMap
+
+				} else {
+					resultsMap[k] = nil
+				}
 			}
 		}
+
 		if sqlMapsExecutor.session.IsSqlFuc == true {
-			err := sqlMapsExecutor.session.Commit()
-			if err != nil {
-				return nil, nil, err
+			err1 := sqlMapsExecutor.session.Commit()
+			if err1 != nil {
+				return nil, nil, err1
 			}
 		}
 		return nil, resultsMap, nil

sqltemplates_executor.go

@@ -13,6 +13,11 @@ type SqlTemplatesExecutor struct {
 }
 
 func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]interface{}, map[string][]map[string]interface{}, error) {
+	defer sqlTemplatesExecutor.session.resetStatement()
+	if sqlTemplatesExecutor.session.IsAutoClose {
+		defer sqlTemplatesExecutor.session.Close()
+	}
+
 	if sqlTemplatesExecutor.err != nil {
 		return nil, nil, sqlTemplatesExecutor.err
 	}
@@ -23,6 +28,13 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 
 	sqlModel := 1
 
+	if sqlTemplatesExecutor.session.IsSqlFuc == true {
+		err := sqlTemplatesExecutor.session.Begin()
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
 	switch sqlTemplatesExecutor.sqlkeys.(type) {
 	case string:
 		sqlkey := strings.TrimSpace(sqlTemplatesExecutor.sqlkeys.(string))
@@ -30,9 +42,9 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 			sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkey).Execute(nil)
 			if err != nil {
 				if sqlTemplatesExecutor.session.IsSqlFuc == true {
-					err = sqlTemplatesExecutor.session.Rollback()
-					if err != nil {
-						return nil, nil, err
+					err1 := sqlTemplatesExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
 					}
 				}
 				return nil, nil, err
@@ -44,9 +56,11 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 			case "select", "desc":
 				model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey).Query()
 				sqlModel = 1
-			case "insert", "delete", "update", "create":
+			case "insert", "delete", "update", "create", "drop":
 				model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey).Execute()
 				sqlModel = 2
+			default:
+				sqlModel = 3
 			}
 		} else {
 			switch sqlTemplatesExecutor.parmas.(type) {
@@ -58,9 +72,9 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkey).Execute(parmaMap[0])
 				if err != nil {
 					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
 						}
 					}
 					return nil, nil, err
@@ -72,9 +86,11 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 				case "select", "desc":
 					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey, &parmaMap[0]).Query()
 					sqlModel = 1
-				case "insert", "delete", "update", "create":
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey, &parmaMap[0]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
 
 			case map[string]interface{}:
@@ -85,9 +101,9 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkey).Execute(parmaMap)
 				if err != nil {
 					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
 						}
 					}
 					return nil, nil, err
@@ -98,9 +114,11 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 				case "select", "desc":
 					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey, &parmaMap).Query()
 					sqlModel = 1
-				case "insert", "delete", "update", "create":
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkey, &parmaMap).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
 
 			default:
@@ -118,7 +136,7 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 			resultSlice[0] = make([]map[string]interface{}, len(model_1_results.Results))
 			resultSlice[0] = model_1_results.Results
 			return resultSlice, nil, nil
-		} else {
+		} else if sqlModel == 2 {
 			if err != nil {
 				return nil, nil, err
 			}
@@ -137,235 +155,406 @@ func (sqlTemplatesExecutor *SqlTemplatesExecutor) Execute() ([][]map[string]inte
 			resultMap[0]["RowsAffected"] = RowsAffected
 			resultSlice[0] = resultMap
 			return resultSlice, nil, nil
+		} else {
+			resultSlice[0] = nil
 		}
 	case []string:
-		if sqlTemplatesExecutor.session.IsSqlFuc == true {
-			err := sqlTemplatesExecutor.session.Begin()
-			if err != nil {
-				return nil, nil, err
-			}
-		}
+
 		sqlkeysSlice := sqlTemplatesExecutor.sqlkeys.([]string)
 		n := len(sqlkeysSlice)
 		resultSlice := make([][]map[string]interface{}, n)
 		parmaSlice := make([]map[string]interface{}, n)
-		switch sqlTemplatesExecutor.parmas.(type) {
-		case []map[string]interface{}:
-			parmaSlice = sqlTemplatesExecutor.parmas.([]map[string]interface{})
 
-		default:
-			if sqlTemplatesExecutor.session.IsSqlFuc == true {
-				err = sqlTemplatesExecutor.session.Rollback()
+		if sqlTemplatesExecutor.parmas == nil {
+			for i, _ := range sqlkeysSlice {
+				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysSlice[i]).Execute(nil)
 				if err != nil {
-					return nil, nil, err
-				}
-			}
-			return nil, nil, ErrParamsType
-		}
-
-		for i, _ := range sqlkeysSlice {
-			sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysSlice[i]).Execute(parmaSlice[i])
-			if err != nil {
-				if sqlTemplatesExecutor.session.IsSqlFuc == true {
-					err = sqlTemplatesExecutor.session.Rollback()
-					if err != nil {
-						return nil, nil, err
+					if sqlTemplatesExecutor.session.IsSqlFuc == true {
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
+						}
 					}
+					return nil, nil, err
 				}
-				return nil, nil, err
-			}
-			sqlStr = strings.TrimSpace(sqlStr)
+				sqlStr = strings.TrimSpace(sqlStr)
 
-			sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
-			if parmaSlice[i] == nil {
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
 				switch sqlCmd {
 				case "select", "desc":
 					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i]).Query()
 					sqlModel = 1
-				case "insert", "delete", "update", "create":
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
-			} else {
-				switch sqlCmd {
-				case "select", "desc":
-					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i], &parmaSlice[i]).Query()
-					sqlModel = 1
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i], &parmaSlice[i]).Execute()
-					sqlModel = 2
-				}
-			}
 
-			if sqlModel == 1 {
-				if model_1_results.Error != nil {
-					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, model_1_results.Error
 					}
-					return nil, nil, model_1_results.Error
-				}
 
-				resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
-				resultSlice[i] = model_1_results.Results
+					resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultSlice[i] = model_1_results.Results
 
-			} else {
-				if err != nil {
-					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, err
 					}
-					return nil, nil, err
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultSlice[i] = make([]map[string]interface{}, 1)
+					resultSlice[i] = resultMap
+
+				} else {
+					resultSlice[i] = nil
 				}
 
-				resultMap := make([]map[string]interface{}, 1)
-				resultMap[0] = make(map[string]interface{})
+			}
+
+		} else {
 
-				//todo all database support LastInsertId
-				LastInsertId, _ := model_2_results.LastInsertId()
+			switch sqlTemplatesExecutor.parmas.(type) {
+			case []map[string]interface{}:
+				parmaSlice = sqlTemplatesExecutor.parmas.([]map[string]interface{})
+
+			default:
+				if sqlTemplatesExecutor.session.IsSqlFuc == true {
+					err1 := sqlTemplatesExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
+				return nil, nil, ErrParamsType
+			}
 
-				resultMap[0]["LastInsertId"] = LastInsertId
-				RowsAffected, err := model_2_results.RowsAffected()
+			for i, _ := range sqlkeysSlice {
+				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysSlice[i]).Execute(parmaSlice[i])
 				if err != nil {
 					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Commit()
-						if err != nil {
-							return nil, nil, err
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
 						}
 					}
 					return nil, nil, err
 				}
-				resultMap[0]["RowsAffected"] = RowsAffected
-				resultSlice[i] = make([]map[string]interface{}, 1)
-				resultSlice[i] = resultMap
+				sqlStr = strings.TrimSpace(sqlStr)
+
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
+				if parmaSlice[i] == nil {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				} else {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i], &parmaSlice[i]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysSlice[i], &parmaSlice[i]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				}
+
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, model_1_results.Error
+					}
+
+					resultSlice[i] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultSlice[i] = model_1_results.Results
+
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultSlice[i] = make([]map[string]interface{}, 1)
+					resultSlice[i] = resultMap
 
+				} else {
+					resultSlice[i] = nil
+				}
 			}
+
 		}
 
 		if sqlTemplatesExecutor.session.IsSqlFuc == true {
-			err = sqlTemplatesExecutor.session.Commit()
-			if err != nil {
-				return nil, nil, err
+			err1 := sqlTemplatesExecutor.session.Commit()
+			if err1 != nil {
+				return nil, nil, err1
 			}
 		}
 		return resultSlice, nil, nil
 
 	case map[string]string:
-		if sqlTemplatesExecutor.session.IsSqlFuc == true {
-			err = sqlTemplatesExecutor.session.Begin()
-			if err != nil {
-				return nil, nil, err
-			}
-		}
+
 		sqlkeysMap := sqlTemplatesExecutor.sqlkeys.(map[string]string)
 		n := len(sqlkeysMap)
 		resultsMap := make(map[string][]map[string]interface{}, n)
 		parmasMap := make(map[string]map[string]interface{}, n)
 
-		switch sqlTemplatesExecutor.parmas.(type) {
-		case map[string]map[string]interface{}:
-			parmasMap = sqlTemplatesExecutor.parmas.(map[string]map[string]interface{})
+		if sqlTemplatesExecutor.parmas == nil {
 
-		default:
-			if sqlTemplatesExecutor.session.IsSqlFuc == true {
-				err = sqlTemplatesExecutor.session.Rollback()
+			for k, _ := range sqlkeysMap {
+				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysMap[k]).Execute(nil)
 				if err != nil {
+					if sqlTemplatesExecutor.session.IsSqlFuc == true {
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
+						}
+					}
 					return nil, nil, err
 				}
-			}
-			return nil, nil, ErrParamsType
-		}
+				sqlStr = strings.TrimSpace(sqlStr)
 
-		for k, _ := range sqlkeysMap {
-			sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysMap[k]).Execute(parmasMap[k])
-			if err != nil {
-				if sqlTemplatesExecutor.session.IsSqlFuc == true {
-					err = sqlTemplatesExecutor.session.Rollback()
-					if err != nil {
-						return nil, nil, err
-					}
-				}
-				return nil, nil, err
-			}
-			sqlStr = strings.TrimSpace(sqlStr)
-			sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
-			if parmasMap[k] == nil {
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
 				switch sqlCmd {
 				case "select", "desc":
 					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k]).Query()
 					sqlModel = 1
-				case "insert", "delete", "update", "create":
+				case "insert", "delete", "update", "create", "drop":
 					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k]).Execute()
 					sqlModel = 2
+				default:
+					sqlModel = 3
 				}
-			} else {
-				parmaMap := parmasMap[k]
-				switch sqlCmd {
-				case "select", "desc":
-					model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k], &parmaMap).Query()
-					sqlModel = 1
-				case "insert", "delete", "update", "create":
-					model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k], &parmaMap).Execute()
-					sqlModel = 2
-				}
-			}
 
-			if sqlModel == 1 {
-				if model_1_results.Error != nil {
-					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, model_1_results.Error
 					}
-					return nil, nil, model_1_results.Error
-				}
 
-				resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
-				resultsMap[k] = model_1_results.Results
+					resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultsMap[k] = model_1_results.Results
 
-			} else {
-				if err != nil {
-					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
 						}
+						return nil, nil, err
 					}
-					return nil, nil, err
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
+
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultsMap[k] = make([]map[string]interface{}, 1)
+					resultsMap[k] = resultMap
+
+				} else {
+					resultsMap[k] = nil
 				}
 
-				resultMap := make([]map[string]interface{}, 1)
-				resultMap[0] = make(map[string]interface{})
+			}
+
+		} else {
+
+			switch sqlTemplatesExecutor.parmas.(type) {
+			case map[string]map[string]interface{}:
+				parmasMap = sqlTemplatesExecutor.parmas.(map[string]map[string]interface{})
 
-				//todo all database support LastInsertId
-				LastInsertId, _ := model_2_results.LastInsertId()
+			default:
+				if sqlTemplatesExecutor.session.IsSqlFuc == true {
+					err1 := sqlTemplatesExecutor.session.Rollback()
+					if err1 != nil {
+						return nil, nil, err1
+					}
+				}
+				return nil, nil, ErrParamsType
+			}
 
-				resultMap[0]["LastInsertId"] = LastInsertId
-				RowsAffected, err := model_2_results.RowsAffected()
+			for k, _ := range sqlkeysMap {
+				sqlStr, err := sqlTemplatesExecutor.session.Engine.GetSqlTemplate(sqlkeysMap[k]).Execute(parmasMap[k])
 				if err != nil {
 					if sqlTemplatesExecutor.session.IsSqlFuc == true {
-						err = sqlTemplatesExecutor.session.Rollback()
-						if err != nil {
-							return nil, nil, err
+						err1 := sqlTemplatesExecutor.session.Rollback()
+						if err1 != nil {
+							return nil, nil, err1
 						}
 					}
 					return nil, nil, err
 				}
-				resultMap[0]["RowsAffected"] = RowsAffected
-				resultsMap[k] = make([]map[string]interface{}, 1)
-				resultsMap[k] = resultMap
+				sqlStr = strings.TrimSpace(sqlStr)
+				sqlCmd := strings.ToLower(strings.Split(sqlStr, " ")[0])
+				if parmasMap[k] == nil {
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k]).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k]).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				} else {
+					parmaMap := parmasMap[k]
+					switch sqlCmd {
+					case "select", "desc":
+						model_1_results = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k], &parmaMap).Query()
+						sqlModel = 1
+					case "insert", "delete", "update", "create", "drop":
+						model_2_results, err = sqlTemplatesExecutor.session.SqlTemplateClient(sqlkeysMap[k], &parmaMap).Execute()
+						sqlModel = 2
+					default:
+						sqlModel = 3
+					}
+				}
+
+				if sqlModel == 1 {
+					if model_1_results.Error != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, model_1_results.Error
+					}
+
+					resultsMap[k] = make([]map[string]interface{}, len(model_1_results.Results))
+					resultsMap[k] = model_1_results.Results
+
+				} else if sqlModel == 2 {
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+
+					resultMap := make([]map[string]interface{}, 1)
+					resultMap[0] = make(map[string]interface{})
 
+					//todo all database support LastInsertId
+					LastInsertId, _ := model_2_results.LastInsertId()
+
+					resultMap[0]["LastInsertId"] = LastInsertId
+					RowsAffected, err := model_2_results.RowsAffected()
+					if err != nil {
+						if sqlTemplatesExecutor.session.IsSqlFuc == true {
+							err1 := sqlTemplatesExecutor.session.Rollback()
+							if err1 != nil {
+								return nil, nil, err1
+							}
+						}
+						return nil, nil, err
+					}
+					resultMap[0]["RowsAffected"] = RowsAffected
+					resultsMap[k] = make([]map[string]interface{}, 1)
+					resultsMap[k] = resultMap
+
+				} else {
+					resultsMap[k] = nil
+				}
 			}
+
 		}
+
 		if sqlTemplatesExecutor.session.IsSqlFuc == true {
-			err = sqlTemplatesExecutor.session.Commit()
-			if err != nil {
-				return nil, nil, err
+			err1 := sqlTemplatesExecutor.session.Commit()
+			if err1 != nil {
+				return nil, nil, err1
 			}
 		}
 		return nil, resultsMap, nil