数据库操作
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

839 lines
19 KiB

3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
2 years ago
  1. package dbquery
  2. import (
  3. "database/sql"
  4. "errors"
  5. "log"
  6. "strconv"
  7. "strings"
  8. "git.tetele.net/tgo/helper"
  9. )
  10. var stmt *sql.Stmt
  11. var err error
  12. type Query struct {
  13. dbname string
  14. table string
  15. alias string
  16. title string
  17. where []string
  18. where_or []string
  19. join [][]string //[["tablea as a","a.id=b.id","left"]]
  20. save_data []map[string]interface{} //批量操作的数据[["title":"a","num":1,],["title":"a","num":1,]]
  21. upd_field []string // 批量更新时需要更新的字段,为空时按除id外的字段进行更新
  22. data []string
  23. value []interface{}
  24. orderby string
  25. groupby string
  26. having string
  27. page int
  28. page_size int
  29. stmt *sql.Stmt
  30. conn *sql.DB
  31. debug bool
  32. dbtype string
  33. }
  34. func NewQuery(t ...string) *Query {
  35. var conn_type *sql.DB = DB
  36. var db_type string = "mysql"
  37. if len(t) > 0 {
  38. switch t[0] {
  39. case "mysql":
  40. conn_type = DB
  41. db_type = "mysql"
  42. case "mssql": //sql server
  43. conn_type = MSDB_CONN
  44. db_type = "mssql"
  45. }
  46. }
  47. return &Query{
  48. conn: conn_type,
  49. dbtype: db_type,
  50. }
  51. }
  52. func (this *Query) Conn(conn *sql.DB) *Query {
  53. this.conn = conn
  54. return this
  55. }
  56. func (this *Query) Db(dbname string) *Query {
  57. this.dbname = dbname
  58. return this
  59. }
  60. func (this *Query) Table(tablename string) *Query {
  61. this.table = tablename
  62. return this
  63. }
  64. func (this *Query) Alias(tablename string) *Query {
  65. this.alias = tablename
  66. return this
  67. }
  68. func (this *Query) Title(title string) *Query {
  69. this.title = title
  70. return this
  71. }
  72. func (this *Query) Page(page int) *Query {
  73. this.page = page
  74. return this
  75. }
  76. func (this *Query) PageSize(page_num int) *Query {
  77. this.page_size = page_num
  78. return this
  79. }
  80. func (this *Query) Having(having string) *Query {
  81. this.having = having
  82. return this
  83. }
  84. func (this *Query) Orderby(orderby string) *Query {
  85. this.orderby = orderby
  86. return this
  87. }
  88. func (this *Query) Groupby(groupby string) *Query {
  89. this.groupby = groupby
  90. return this
  91. }
  92. func (this *Query) Where(where string) *Query {
  93. this.where = append(this.where, where)
  94. return this
  95. }
  96. func (this *Query) Wheres(wheres []string) *Query {
  97. if len(wheres) > 0 {
  98. this.where = append(this.where, wheres...)
  99. }
  100. return this
  101. }
  102. func (this *Query) WhereOr(where string) *Query {
  103. this.where_or = append(this.where_or, where)
  104. return this
  105. }
  106. func (this *Query) SaveData(value map[string]interface{}) *Query {
  107. this.save_data = append(this.save_data, value)
  108. return this
  109. }
  110. func (this *Query) SaveDatas(value []map[string]interface{}) *Query {
  111. this.save_data = append(this.save_data, value...)
  112. return this
  113. }
  114. func (this *Query) UpdField(value string) *Query {
  115. this.upd_field = append(this.upd_field, value)
  116. return this
  117. }
  118. func (this *Query) UpdFields(value []string) *Query {
  119. this.upd_field = append(this.upd_field, value...)
  120. return this
  121. }
  122. func (this *Query) Value(value interface{}) *Query {
  123. this.value = append(this.value, value)
  124. return this
  125. }
  126. func (this *Query) Values(values []interface{}) *Query {
  127. this.value = append(this.value, values...)
  128. return this
  129. }
  130. func (this *Query) Join(join []string) *Query {
  131. this.join = append(this.join, join)
  132. return this
  133. }
  134. func (this *Query) Data(data string) *Query {
  135. this.data = append(this.data, data)
  136. return this
  137. }
  138. func (this *Query) Datas(datas []string) *Query {
  139. this.data = append(this.data, datas...)
  140. return this
  141. }
  142. func (this *Query) Debug(debug bool) *Query {
  143. this.debug = debug
  144. return this
  145. }
  146. /*
  147. * 清理上次查询
  148. */
  149. func (this *Query) Clean() *Query {
  150. this.title = ""
  151. this.where = this.where[0:0]
  152. this.where_or = this.where_or[0:0]
  153. this.join = this.join[0:0]
  154. this.data = this.data[0:0]
  155. this.value = this.value[0:0]
  156. this.orderby = ""
  157. this.groupby = ""
  158. this.page = 0
  159. this.page_size = 0
  160. this.save_data = this.save_data[0:0]
  161. this.upd_field = this.upd_field[0:0]
  162. this.having = ""
  163. return this
  164. }
  165. //获取表格信息
  166. func (this *Query) GetTableInfo(table string) (map[string]interface{}, error) {
  167. field := []string{
  168. "COLUMN_NAME", //字段名
  169. "COLUMN_DEFAULT", //默认值
  170. "DATA_TYPE", //数据类型
  171. "COLUMN_TYPE", //数据类型+长度
  172. "COLUMN_COMMENT", //备注
  173. "IS_NULLABLE", //是否为空
  174. }
  175. sql := "select `" + strings.Join(field, "`,`") + "` from information_schema.COLUMNS where table_name = ? and table_schema = ?"
  176. stmtSql, err := this.conn.Prepare(sql)
  177. if err != nil {
  178. return nil, err
  179. }
  180. list, err := StmtForQueryList(stmtSql, []interface{}{table, this.dbname})
  181. if err != nil {
  182. return nil, err
  183. }
  184. rows := make([]interface{}, 0, len(list))
  185. fieldName := make([]string, 0, len(list))
  186. for _, item := range list {
  187. info := map[string]interface{}{
  188. "name": "",
  189. "column_type": "",
  190. "is_null": true,
  191. "data_type": "",
  192. "comment": "",
  193. "default": "",
  194. }
  195. for _, k := range field {
  196. index := helper.StrFirstToUpper(k)
  197. if v, ok := item[index]; ok {
  198. switch k {
  199. case "COLUMN_NAME":
  200. info["name"] = v
  201. case "COLUMN_DEFAULT":
  202. info["default"] = v
  203. case "DATA_TYPE":
  204. info["data_type"] = v
  205. case "COLUMN_TYPE":
  206. info["column_type"] = helper.ToInt64(v)
  207. case "COLUMN_COMMENT":
  208. info["comment"] = helper.ToInt64(v)
  209. case "IS_NULLABLE":
  210. if v == "NO" {
  211. info["is_null"] = false
  212. }
  213. }
  214. }
  215. }
  216. name := helper.ToStr(info["name"])
  217. if name != "" {
  218. rows = append(rows, info)
  219. fieldName = append(fieldName, name)
  220. }
  221. }
  222. return map[string]interface{}{
  223. "field": fieldName,
  224. "list": rows,
  225. }, nil
  226. }
  227. //构造子查询
  228. func (this *Query) BuildSelectSql() (map[string]interface{}, error) {
  229. if this.dbname == "" && this.table == "" {
  230. return nil, errors.New("参数错误,没有数据表")
  231. }
  232. var table = ""
  233. if strings.Contains(this.table, "select ") {
  234. table = this.table
  235. } else {
  236. table = getTableName(this.dbname, this.table, this.dbtype)
  237. }
  238. // var err error
  239. var sql, title string
  240. if this.title != "" {
  241. title = this.title
  242. } else {
  243. title = "*"
  244. }
  245. sql = helper.StringJoin("/*slave*/ select ", title)
  246. if this.alias != "" {
  247. table = helper.StringJoin(table, " as ", this.alias)
  248. }
  249. sql = helper.StringJoin(sql, " from ", table)
  250. if len(this.join) > 0 {
  251. for _, joinitem := range this.join {
  252. if len(joinitem) < 2 {
  253. continue
  254. }
  255. if len(joinitem) == 3 {
  256. sql = helper.StringJoin(sql, " ", joinitem[2], " join ", getTableName(this.dbname, joinitem[0], this.dbtype), " on ", joinitem[1])
  257. } else { //默认左连接
  258. sql = helper.StringJoin(sql, " left join ", getTableName(this.dbname, joinitem[0], this.dbtype), " on ", joinitem[1])
  259. }
  260. }
  261. }
  262. if len(this.where) > 0 || len(this.where_or) > 0 {
  263. sql = helper.StringJoin(sql, " where ")
  264. }
  265. if len(this.where) > 0 {
  266. sql = helper.StringJoin(sql, " (", strings.Join(this.where, " and "), " ) ")
  267. }
  268. if len(this.where_or) > 0 {
  269. if len(this.where) > 0 {
  270. sql = helper.StringJoin(sql, " or ", strings.Join(this.where_or, " or "))
  271. } else {
  272. sql = helper.StringJoin(sql, strings.Join(this.where_or, " or "))
  273. }
  274. }
  275. if this.groupby != "" {
  276. sql = helper.StringJoin(sql, " group by ", this.groupby)
  277. }
  278. if this.having != "" {
  279. sql = helper.StringJoin(sql, " having ", this.having)
  280. }
  281. if this.orderby != "" {
  282. sql = helper.StringJoin(sql, " order by ", this.orderby)
  283. }
  284. if this.page > 0 || this.page_size > 0 {
  285. if this.page < 1 {
  286. this.page = 1
  287. }
  288. if this.page_size < 1 {
  289. this.page_size = 10
  290. }
  291. from := strconv.Itoa((this.page - 1) * this.page_size)
  292. offset := strconv.Itoa(this.page_size)
  293. if from != "" && offset != "" {
  294. sql = helper.StringJoin(sql, " limit ", from, " , ", offset)
  295. }
  296. }
  297. if this.debug {
  298. log.Println("query sql:", sql, this.value)
  299. }
  300. condition_len := 0 //所有条件数
  301. for _, ch2 := range sql {
  302. if string(ch2) == "?" {
  303. condition_len++
  304. }
  305. }
  306. if condition_len != len(this.value) {
  307. return nil, errors.New("参数错误,条件值错误")
  308. }
  309. return map[string]interface{}{
  310. "sql": sql,
  311. "value": this.value,
  312. }, nil
  313. }
  314. // 拼查询sql
  315. func (this *Query) QueryStmt() error {
  316. res := map[string]interface{}{}
  317. res, err = this.BuildSelectSql()
  318. if err != nil {
  319. return err
  320. }
  321. sql := helper.ToStr(res["sql"])
  322. if this.conn == nil {
  323. this.conn = DB
  324. }
  325. stmt, err = this.conn.Prepare(sql)
  326. if err != nil {
  327. return err
  328. }
  329. this.stmt = stmt
  330. return nil
  331. }
  332. // 拼更新sql
  333. func (this *Query) UpdateStmt() error {
  334. if this.dbname == "" && this.table == "" {
  335. return errors.New("参数错误,没有数据表")
  336. }
  337. if len(this.where) < 1 {
  338. return errors.New("参数错误,缺少条件")
  339. }
  340. dbName := getTableName(this.dbname, this.table, this.dbtype)
  341. var sql string
  342. sql = helper.StringJoin("update ", dbName, " set ", strings.Join(this.data, " , "))
  343. sql = helper.StringJoin(sql, " where ", strings.Join(this.where, " and "))
  344. if this.debug {
  345. log.Println("update sql:", sql, this.value)
  346. }
  347. condition_len := 0 //所有条件数
  348. for _, ch2 := range sql {
  349. if string(ch2) == "?" {
  350. condition_len++
  351. }
  352. }
  353. if condition_len != len(this.value) {
  354. return errors.New("参数错误,条件值错误")
  355. }
  356. if this.conn == nil {
  357. this.conn = DB
  358. }
  359. stmt, err = this.conn.Prepare(sql)
  360. if err != nil {
  361. return err
  362. }
  363. this.stmt = stmt
  364. return nil
  365. }
  366. // 拼批量存在更新不存在插入sql
  367. func (this *Query) UpdateAllStmt() error {
  368. if this.dbname == "" && this.table == "" {
  369. return errors.New("参数错误,没有数据表")
  370. }
  371. dbName := getTableName(this.dbname, this.table)
  372. var sql string
  373. var dataSql []string //一组用到的占位字符
  374. var valSql []string //占位字符组
  375. var updSql []string //更新字段的sql
  376. var updFieldLen = len(this.upd_field) //需要更新的字段数量,为0时更新除id外添加值
  377. dataLen := len(this.save_data)
  378. if dataLen > 0 {
  379. //批量操作
  380. this.data = this.data[0:0]
  381. this.value = this.value[0:0]
  382. var dataSqlText string //占位字符组
  383. for i := 0; i < dataLen; i++ {
  384. if i == 0 {
  385. //第一组时分配变量空间
  386. fieldLen := len(this.save_data[i])
  387. this.data = make([]string, 0, fieldLen)
  388. dataSql = make([]string, 0, fieldLen)
  389. this.value = make([]interface{}, 0, fieldLen*dataLen)
  390. valSql = make([]string, 0, dataLen)
  391. switch updFieldLen {
  392. case 0:
  393. //预览创建数据的长度
  394. updSql = make([]string, 0, fieldLen)
  395. default:
  396. //按照需要更新字段数长度
  397. updSql = make([]string, 0, updFieldLen)
  398. for _, k := range this.upd_field {
  399. updSql = append(updSql, k+"=values("+k+")") //存储需要更新的字段
  400. }
  401. }
  402. for k := range this.save_data[i] {
  403. this.data = append(this.data, k) //存储添加的字段
  404. dataSql = append(dataSql, "?") //存储需要的占位符
  405. if updFieldLen == 0 && k != "id" {
  406. updSql = append(updSql, k+"=values("+k+")") //存储需要更新的字段
  407. }
  408. }
  409. dataSqlText = strings.Join(dataSql, ",") //组成每组占位字符格式
  410. }
  411. for j := 0; j < len(this.data); j++ {
  412. this.value = append(this.value, this.save_data[i][this.data[j]]) //存储值
  413. }
  414. valSql = append(valSql, "("+dataSqlText+")") //组成占位字符组
  415. }
  416. } else {
  417. //添加一条(原理同上)
  418. fieldLen := len(this.data)
  419. dataSql = make([]string, 0, fieldLen)
  420. valSql = make([]string, 0, 1)
  421. switch updFieldLen {
  422. case 0:
  423. updSql = make([]string, 0, fieldLen)
  424. default:
  425. updSql = make([]string, 0, updFieldLen)
  426. for _, k := range this.upd_field {
  427. updSql = append(updSql, k+"=values("+k+")")
  428. }
  429. }
  430. for i := 0; i < fieldLen; i++ {
  431. dataSql = append(dataSql, "?")
  432. if updFieldLen == 0 && this.data[i] != "id" {
  433. updSql = append(updSql, this.data[i]+"=values("+this.data[i]+")")
  434. }
  435. }
  436. if updFieldLen > 0 {
  437. for _, k := range this.upd_field {
  438. updSql = append(updSql, k+"=values("+k+")")
  439. }
  440. }
  441. valSql = append(valSql, "("+strings.Join(dataSql, " , ")+")")
  442. }
  443. if len(this.data) == 0 {
  444. return errors.New("参数错误,没有字段值")
  445. }
  446. if len(this.value) == 0 {
  447. return errors.New("参数错误,条件值错误")
  448. }
  449. setText := " values "
  450. if len(valSql) > 1 {
  451. setText = " value "
  452. }
  453. sql = helper.StringJoin("insert into ", dbName, " (", strings.Join(this.data, " , "), ")", setText, strings.Join(valSql, ","), " ON DUPLICATE KEY UPDATE ", strings.Join(updSql, " , "))
  454. if this.debug {
  455. log.Println("insert on duplicate key update sql:", sql, this.value)
  456. }
  457. conditionLen := 0 //所有条件数
  458. for _, ch2 := range sql {
  459. if string(ch2) == "?" {
  460. conditionLen++
  461. }
  462. }
  463. if conditionLen != len(this.value) {
  464. return errors.New("参数错误,条件值数量不匹配")
  465. }
  466. if this.conn == nil {
  467. this.conn = DB
  468. }
  469. stmt, err = this.conn.Prepare(sql)
  470. if err != nil {
  471. return err
  472. }
  473. this.stmt = stmt
  474. return nil
  475. }
  476. // 拼批量插入sql
  477. func (this *Query) CreateAllStmt() error {
  478. if this.dbname == "" && this.table == "" {
  479. return errors.New("参数错误,没有数据表")
  480. }
  481. dbName := getTableName(this.dbname, this.table)
  482. var sql string
  483. var dataSql []string //一组用到的占位字符
  484. var valSql []string //占位字符组
  485. dataLen := len(this.save_data)
  486. if dataLen > 0 {
  487. //清空字段和值
  488. this.data = this.data[0:0]
  489. this.value = this.value[0:0]
  490. var dataSqlText string //占位字符组
  491. for i := 0; i < dataLen; i++ {
  492. if i == 0 {
  493. //第一组时分配变量空间
  494. fieldLen := len(this.save_data[i])
  495. this.data = make([]string, 0, fieldLen)
  496. dataSql = make([]string, 0, fieldLen)
  497. this.value = make([]interface{}, 0, fieldLen*dataLen)
  498. valSql = make([]string, 0, dataLen)
  499. for k := range this.save_data[i] {
  500. this.data = append(this.data, k) //存储字段
  501. dataSql = append(dataSql, "?") //存储需要的占位符
  502. }
  503. dataSqlText = strings.Join(dataSql, ",") //组成每组占位字符格式
  504. }
  505. for j := 0; j < len(this.data); j++ {
  506. this.value = append(this.value, this.save_data[i][this.data[j]]) //存储值
  507. }
  508. valSql = append(valSql, "("+dataSqlText+")") //组成占位字符组
  509. }
  510. } else {
  511. //添加一条(原理同上)
  512. fieldLen := len(this.data)
  513. dataSql = make([]string, 0, fieldLen)
  514. for i := 0; i < fieldLen; i++ {
  515. dataSql = append(dataSql, "?")
  516. }
  517. valSql = make([]string, 0, 1)
  518. valSql = append(valSql, "("+strings.Join(dataSql, " , ")+")")
  519. }
  520. if len(this.data) == 0 {
  521. return errors.New("参数错误,字段名错误")
  522. }
  523. if len(this.value) == 0 {
  524. return errors.New("参数错误,条件值错误")
  525. }
  526. //通过sql关键字优化批量操作和单个操作效率
  527. setText := " values "
  528. if len(valSql) > 1 {
  529. setText = " value "
  530. }
  531. sql = helper.StringJoin("insert into ", dbName, " (", strings.Join(this.data, " , "), ")", setText, strings.Join(valSql, ","))
  532. if this.debug {
  533. log.Println("insert sql:", sql, this.value)
  534. }
  535. conditionLen := 0 //所有条件数
  536. for _, ch2 := range sql {
  537. if string(ch2) == "?" {
  538. conditionLen++
  539. }
  540. }
  541. if conditionLen != len(this.value) {
  542. return errors.New("参数错误,条件值数量不匹配")
  543. }
  544. if this.conn == nil {
  545. this.conn = DB
  546. }
  547. stmt, err = this.conn.Prepare(sql)
  548. if err != nil {
  549. return err
  550. }
  551. this.stmt = stmt
  552. return nil
  553. }
  554. // 拼插入sql
  555. func (this *Query) CreateStmt() error {
  556. if this.dbname == "" && this.table == "" {
  557. return errors.New("参数错误,没有数据表")
  558. }
  559. dbName := getTableName(this.dbname, this.table, this.dbtype)
  560. var sql string
  561. sql = helper.StringJoin("insert into ", dbName, " set ", strings.Join(this.data, " , "))
  562. if this.debug {
  563. log.Println("insert sql:", sql, this.value)
  564. }
  565. condition_len := 0 //所有条件数
  566. for _, ch2 := range sql {
  567. if string(ch2) == "?" {
  568. condition_len++
  569. }
  570. }
  571. if condition_len != len(this.value) {
  572. return errors.New("参数错误,条件值错误")
  573. }
  574. if this.conn == nil {
  575. this.conn = DB
  576. }
  577. stmt, err = this.conn.Prepare(sql)
  578. if err != nil {
  579. return err
  580. }
  581. this.stmt = stmt
  582. return nil
  583. }
  584. // 拼删除sql
  585. func (this *Query) DeleteStmt() error {
  586. if this.dbname == "" && this.table == "" {
  587. return errors.New("参数错误,没有数据表")
  588. }
  589. if len(this.where) < 1 {
  590. return errors.New("参数错误,缺少条件")
  591. }
  592. dbName := getTableName(this.dbname, this.table, this.dbtype)
  593. var sql string
  594. sql = helper.StringJoin("delete from ", dbName, " where ", strings.Join(this.where, " and "))
  595. if this.page_size > 0 {
  596. sql = helper.StringJoin(sql, " limit ", strconv.Itoa(this.page_size))
  597. }
  598. if this.debug {
  599. log.Println("delete sql:", sql, this.value)
  600. }
  601. condition_len := 0 //所有条件数
  602. for _, ch2 := range sql {
  603. if string(ch2) == "?" {
  604. condition_len++
  605. }
  606. }
  607. if condition_len != len(this.value) {
  608. return errors.New("参数错误,条件值错误")
  609. }
  610. if this.conn == nil {
  611. this.conn = DB
  612. }
  613. stmt, err = this.conn.Prepare(sql)
  614. if err != nil {
  615. return err
  616. }
  617. this.stmt = stmt
  618. return nil
  619. }
  620. /**
  621. * 执行查询列表
  622. * return list error
  623. */
  624. func (this *Query) Select() ([]map[string]string, error) {
  625. _, rows, err := FetchRows(this.dbname, this.table, this.alias, this.title, this.join,
  626. this.where, this.where_or, this.value, this.orderby, this.groupby, this.having, this.page, this.page_size, this.debug)
  627. return rows, err
  628. }
  629. /**
  630. * 执行查询多条数据
  631. * return row error
  632. * 2022/01/05
  633. */
  634. func (this *Query) List() ([]map[string]string, error) {
  635. err := this.QueryStmt()
  636. if err != nil {
  637. return []map[string]string{}, err
  638. }
  639. if this.stmt == nil {
  640. return []map[string]string{}, errors.New("缺少必要参数")
  641. }
  642. return StmtForQueryList(this.stmt, this.value)
  643. }
  644. /**
  645. * 执行查询一条数据
  646. * return row error
  647. */
  648. func (this *Query) Find() (map[string]string, error) {
  649. _, row, err := GetRow(this.dbname, this.table, this.alias, this.title, this.join,
  650. this.where, this.where_or, this.value, this.orderby, this.groupby, this.having, this.debug)
  651. return row, err
  652. }
  653. /**
  654. * 执行查询一条数据
  655. * return row error
  656. * 2022/01/05
  657. */
  658. func (this *Query) Get() (map[string]string, error) {
  659. this.page = 1
  660. this.page_size = 1
  661. err := this.QueryStmt()
  662. if err != nil {
  663. return map[string]string{}, err
  664. }
  665. if this.stmt == nil {
  666. return nil, errors.New("缺少必要参数")
  667. }
  668. return StmtForQueryRow(this.stmt, this.value)
  669. }
  670. /**
  671. * 执行更新
  672. * return is_updated error
  673. */
  674. func (this *Query) Update() (int64, error) {
  675. err := this.UpdateStmt()
  676. if err != nil {
  677. return 0, err
  678. }
  679. return StmtForUpdateExec(this.stmt, this.value)
  680. }
  681. //批量更新
  682. func (this *Query) UpdateAll() (int64, error) {
  683. err := this.UpdateAllStmt()
  684. if err != nil {
  685. return 0, err
  686. }
  687. return StmtForUpdateExec(this.stmt, this.value)
  688. }
  689. /**
  690. * 执行删除
  691. * return is_delete error
  692. */
  693. func (this *Query) Delete() (int64, error) {
  694. err := this.DeleteStmt()
  695. if err != nil {
  696. return 0, err
  697. }
  698. return StmtForUpdateExec(this.stmt, this.value)
  699. }
  700. /**
  701. * 执行写入
  702. * return is_insert error
  703. */
  704. func (this *Query) Create() (int64, error) {
  705. err := this.CreateStmt()
  706. if err != nil {
  707. return 0, err
  708. }
  709. return StmtForInsertExec(this.stmt, this.value)
  710. }
  711. func (this *Query) CreateAll() (int64, error) {
  712. err := this.CreateAllStmt()
  713. if err != nil {
  714. return 0, err
  715. }
  716. return StmtForInsertExec(this.stmt, this.value)
  717. }