数据库操作
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.

848 lines
19 KiB

3 years ago
3 years ago
3 years ago
3 years ago
3 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. if this.conn == nil {
  177. this.conn = DB
  178. }
  179. stmtSql, err := this.conn.Prepare(sql)
  180. if err != nil {
  181. return nil, err
  182. }
  183. list, err := StmtForQueryList(stmtSql, []interface{}{table, this.dbname})
  184. if err != nil {
  185. return nil, err
  186. }
  187. rows := make([]interface{}, 0, len(list))
  188. fieldName := make([]string, 0, len(list))
  189. for _, item := range list {
  190. info := map[string]interface{}{
  191. "name": "",
  192. "column_type": "",
  193. "is_null": true,
  194. "data_type": "",
  195. "comment": "",
  196. "default": "",
  197. }
  198. for _, k := range field {
  199. index := helper.StrFirstToUpper(k)
  200. if v, ok := item[index]; ok {
  201. switch k {
  202. case "COLUMN_NAME":
  203. info["name"] = v
  204. case "COLUMN_DEFAULT":
  205. info["default"] = v
  206. case "DATA_TYPE":
  207. info["data_type"] = v
  208. case "COLUMN_TYPE":
  209. info["column_type"] = helper.ToInt64(v)
  210. case "COLUMN_COMMENT":
  211. info["comment"] = helper.ToInt64(v)
  212. case "IS_NULLABLE":
  213. if v == "NO" {
  214. info["is_null"] = false
  215. }
  216. }
  217. }
  218. }
  219. name := helper.ToStr(info["name"])
  220. if name != "" {
  221. rows = append(rows, info)
  222. fieldName = append(fieldName, name)
  223. }
  224. }
  225. return map[string]interface{}{
  226. "field": fieldName,
  227. "list": rows,
  228. }, nil
  229. }
  230. //构造子查询
  231. func (this *Query) BuildSelectSql() (map[string]interface{}, error) {
  232. if this.dbname == "" && this.table == "" {
  233. return nil, errors.New("参数错误,没有数据表")
  234. }
  235. var table = ""
  236. if strings.Contains(this.table, "select ") {
  237. table = this.table
  238. } else {
  239. table = getTableName(this.dbname, this.table, this.dbtype)
  240. }
  241. // var err error
  242. var sql, title string
  243. if this.title != "" {
  244. title = this.title
  245. } else {
  246. title = "*"
  247. }
  248. if DB_PROVIDER == "TencentDB" {
  249. sql = helper.StringJoin("/*slave*/ select ", title)
  250. } else {
  251. sql = helper.StringJoin("select ", title)
  252. }
  253. if this.alias != "" {
  254. table = helper.StringJoin(table, " as ", this.alias)
  255. }
  256. sql = helper.StringJoin(sql, " from ", table)
  257. if len(this.join) > 0 {
  258. for _, joinitem := range this.join {
  259. if len(joinitem) < 2 {
  260. continue
  261. }
  262. if len(joinitem) == 3 {
  263. sql = helper.StringJoin(sql, " ", joinitem[2], " join ", getTableName(this.dbname, joinitem[0], this.dbtype), " on ", joinitem[1])
  264. } else { //默认左连接
  265. sql = helper.StringJoin(sql, " left join ", getTableName(this.dbname, joinitem[0], this.dbtype), " on ", joinitem[1])
  266. }
  267. }
  268. }
  269. if len(this.where) > 0 || len(this.where_or) > 0 {
  270. sql = helper.StringJoin(sql, " where ")
  271. }
  272. if len(this.where) > 0 {
  273. sql = helper.StringJoin(sql, " (", strings.Join(this.where, " and "), " ) ")
  274. }
  275. if len(this.where_or) > 0 {
  276. if len(this.where) > 0 {
  277. sql = helper.StringJoin(sql, " or ", strings.Join(this.where_or, " or "))
  278. } else {
  279. sql = helper.StringJoin(sql, strings.Join(this.where_or, " or "))
  280. }
  281. }
  282. if this.groupby != "" {
  283. sql = helper.StringJoin(sql, " group by ", this.groupby)
  284. }
  285. if this.having != "" {
  286. sql = helper.StringJoin(sql, " having ", this.having)
  287. }
  288. if this.orderby != "" {
  289. sql = helper.StringJoin(sql, " order by ", this.orderby)
  290. }
  291. if this.page > 0 || this.page_size > 0 {
  292. if this.page < 1 {
  293. this.page = 1
  294. }
  295. if this.page_size < 1 {
  296. this.page_size = 10
  297. }
  298. from := strconv.Itoa((this.page - 1) * this.page_size)
  299. offset := strconv.Itoa(this.page_size)
  300. if from != "" && offset != "" {
  301. sql = helper.StringJoin(sql, " limit ", from, " , ", offset)
  302. }
  303. }
  304. if this.debug {
  305. log.Println("query sql:", sql, this.value)
  306. }
  307. condition_len := 0 //所有条件数
  308. for _, ch2 := range sql {
  309. if string(ch2) == "?" {
  310. condition_len++
  311. }
  312. }
  313. if condition_len != len(this.value) {
  314. return nil, errors.New("参数错误,条件值错误")
  315. }
  316. return map[string]interface{}{
  317. "sql": sql,
  318. "value": this.value,
  319. }, nil
  320. }
  321. // 拼查询sql
  322. func (this *Query) QueryStmt() error {
  323. res := map[string]interface{}{}
  324. res, err = this.BuildSelectSql()
  325. if err != nil {
  326. return err
  327. }
  328. sql := helper.ToStr(res["sql"])
  329. if SLAVER_DB != nil {
  330. this.conn = SLAVER_DB
  331. } else {
  332. this.conn = DB
  333. }
  334. stmt, err = this.conn.Prepare(sql)
  335. if err != nil {
  336. return err
  337. }
  338. this.stmt = stmt
  339. return nil
  340. }
  341. // 拼更新sql
  342. func (this *Query) UpdateStmt() error {
  343. if this.dbname == "" && this.table == "" {
  344. return errors.New("参数错误,没有数据表")
  345. }
  346. if len(this.where) < 1 {
  347. return errors.New("参数错误,缺少条件")
  348. }
  349. dbName := getTableName(this.dbname, this.table, this.dbtype)
  350. var sql string
  351. sql = helper.StringJoin("update ", dbName, " set ", strings.Join(this.data, " , "))
  352. sql = helper.StringJoin(sql, " where ", strings.Join(this.where, " and "))
  353. if this.debug {
  354. log.Println("update sql:", sql, this.value)
  355. }
  356. condition_len := 0 //所有条件数
  357. for _, ch2 := range sql {
  358. if string(ch2) == "?" {
  359. condition_len++
  360. }
  361. }
  362. if condition_len != len(this.value) {
  363. return errors.New("参数错误,条件值错误")
  364. }
  365. if this.conn == nil {
  366. this.conn = DB
  367. }
  368. stmt, err = this.conn.Prepare(sql)
  369. if err != nil {
  370. return err
  371. }
  372. this.stmt = stmt
  373. return nil
  374. }
  375. // 拼批量存在更新不存在插入sql
  376. func (this *Query) UpdateAllStmt() error {
  377. if this.dbname == "" && this.table == "" {
  378. return errors.New("参数错误,没有数据表")
  379. }
  380. dbName := getTableName(this.dbname, this.table)
  381. var sql string
  382. var dataSql []string //一组用到的占位字符
  383. var valSql []string //占位字符组
  384. var updSql []string //更新字段的sql
  385. var updFieldLen = len(this.upd_field) //需要更新的字段数量,为0时更新除id外添加值
  386. dataLen := len(this.save_data)
  387. if dataLen > 0 {
  388. //批量操作
  389. this.data = this.data[0:0]
  390. this.value = this.value[0:0]
  391. var dataSqlText string //占位字符组
  392. for i := 0; i < dataLen; i++ {
  393. if i == 0 {
  394. //第一组时分配变量空间
  395. fieldLen := len(this.save_data[i])
  396. this.data = make([]string, 0, fieldLen)
  397. dataSql = make([]string, 0, fieldLen)
  398. this.value = make([]interface{}, 0, fieldLen*dataLen)
  399. valSql = make([]string, 0, dataLen)
  400. switch updFieldLen {
  401. case 0:
  402. //预览创建数据的长度
  403. updSql = make([]string, 0, fieldLen)
  404. default:
  405. //按照需要更新字段数长度
  406. updSql = make([]string, 0, updFieldLen)
  407. for _, k := range this.upd_field {
  408. updSql = append(updSql, k+"=values("+k+")") //存储需要更新的字段
  409. }
  410. }
  411. for k := range this.save_data[i] {
  412. this.data = append(this.data, k) //存储添加的字段
  413. dataSql = append(dataSql, "?") //存储需要的占位符
  414. if updFieldLen == 0 && k != "id" {
  415. updSql = append(updSql, k+"=values("+k+")") //存储需要更新的字段
  416. }
  417. }
  418. dataSqlText = strings.Join(dataSql, ",") //组成每组占位字符格式
  419. }
  420. for j := 0; j < len(this.data); j++ {
  421. this.value = append(this.value, this.save_data[i][this.data[j]]) //存储值
  422. }
  423. valSql = append(valSql, "("+dataSqlText+")") //组成占位字符组
  424. }
  425. } else {
  426. //添加一条(原理同上)
  427. fieldLen := len(this.data)
  428. dataSql = make([]string, 0, fieldLen)
  429. valSql = make([]string, 0, 1)
  430. switch updFieldLen {
  431. case 0:
  432. updSql = make([]string, 0, fieldLen)
  433. default:
  434. updSql = make([]string, 0, updFieldLen)
  435. for _, k := range this.upd_field {
  436. updSql = append(updSql, k+"=values("+k+")")
  437. }
  438. }
  439. for i := 0; i < fieldLen; i++ {
  440. dataSql = append(dataSql, "?")
  441. if updFieldLen == 0 && this.data[i] != "id" {
  442. updSql = append(updSql, this.data[i]+"=values("+this.data[i]+")")
  443. }
  444. }
  445. if updFieldLen > 0 {
  446. for _, k := range this.upd_field {
  447. updSql = append(updSql, k+"=values("+k+")")
  448. }
  449. }
  450. valSql = append(valSql, "("+strings.Join(dataSql, " , ")+")")
  451. }
  452. if len(this.data) == 0 {
  453. return errors.New("参数错误,没有字段值")
  454. }
  455. if len(this.value) == 0 {
  456. return errors.New("参数错误,条件值错误")
  457. }
  458. setText := " values "
  459. if len(valSql) > 1 {
  460. setText = " value "
  461. }
  462. sql = helper.StringJoin("insert into ", dbName, " (", strings.Join(this.data, " , "), ")", setText, strings.Join(valSql, ","), " ON DUPLICATE KEY UPDATE ", strings.Join(updSql, " , "))
  463. if this.debug {
  464. log.Println("insert on duplicate key update sql:", sql, this.value)
  465. }
  466. conditionLen := 0 //所有条件数
  467. for _, ch2 := range sql {
  468. if string(ch2) == "?" {
  469. conditionLen++
  470. }
  471. }
  472. if conditionLen != len(this.value) {
  473. return errors.New("参数错误,条件值数量不匹配")
  474. }
  475. if this.conn == nil {
  476. this.conn = DB
  477. }
  478. stmt, err = this.conn.Prepare(sql)
  479. if err != nil {
  480. return err
  481. }
  482. this.stmt = stmt
  483. return nil
  484. }
  485. // 拼批量插入sql
  486. func (this *Query) CreateAllStmt() error {
  487. if this.dbname == "" && this.table == "" {
  488. return errors.New("参数错误,没有数据表")
  489. }
  490. dbName := getTableName(this.dbname, this.table)
  491. var sql string
  492. var dataSql []string //一组用到的占位字符
  493. var valSql []string //占位字符组
  494. dataLen := len(this.save_data)
  495. if dataLen > 0 {
  496. //清空字段和值
  497. this.data = this.data[0:0]
  498. this.value = this.value[0:0]
  499. var dataSqlText string //占位字符组
  500. for i := 0; i < dataLen; i++ {
  501. if i == 0 {
  502. //第一组时分配变量空间
  503. fieldLen := len(this.save_data[i])
  504. this.data = make([]string, 0, fieldLen)
  505. dataSql = make([]string, 0, fieldLen)
  506. this.value = make([]interface{}, 0, fieldLen*dataLen)
  507. valSql = make([]string, 0, dataLen)
  508. for k := range this.save_data[i] {
  509. this.data = append(this.data, k) //存储字段
  510. dataSql = append(dataSql, "?") //存储需要的占位符
  511. }
  512. dataSqlText = strings.Join(dataSql, ",") //组成每组占位字符格式
  513. }
  514. for j := 0; j < len(this.data); j++ {
  515. this.value = append(this.value, this.save_data[i][this.data[j]]) //存储值
  516. }
  517. valSql = append(valSql, "("+dataSqlText+")") //组成占位字符组
  518. }
  519. } else {
  520. //添加一条(原理同上)
  521. fieldLen := len(this.data)
  522. dataSql = make([]string, 0, fieldLen)
  523. for i := 0; i < fieldLen; i++ {
  524. dataSql = append(dataSql, "?")
  525. }
  526. valSql = make([]string, 0, 1)
  527. valSql = append(valSql, "("+strings.Join(dataSql, " , ")+")")
  528. }
  529. if len(this.data) == 0 {
  530. return errors.New("参数错误,字段名错误")
  531. }
  532. if len(this.value) == 0 {
  533. return errors.New("参数错误,条件值错误")
  534. }
  535. //通过sql关键字优化批量操作和单个操作效率
  536. setText := " values "
  537. if len(valSql) > 1 {
  538. setText = " value "
  539. }
  540. sql = helper.StringJoin("insert into ", dbName, " (", strings.Join(this.data, " , "), ")", setText, strings.Join(valSql, ","))
  541. if this.debug {
  542. log.Println("insert sql:", sql, this.value)
  543. }
  544. conditionLen := 0 //所有条件数
  545. for _, ch2 := range sql {
  546. if string(ch2) == "?" {
  547. conditionLen++
  548. }
  549. }
  550. if conditionLen != len(this.value) {
  551. return errors.New("参数错误,条件值数量不匹配")
  552. }
  553. if this.conn == nil {
  554. this.conn = DB
  555. }
  556. stmt, err = this.conn.Prepare(sql)
  557. if err != nil {
  558. return err
  559. }
  560. this.stmt = stmt
  561. return nil
  562. }
  563. // 拼插入sql
  564. func (this *Query) CreateStmt() error {
  565. if this.dbname == "" && this.table == "" {
  566. return errors.New("参数错误,没有数据表")
  567. }
  568. dbName := getTableName(this.dbname, this.table, this.dbtype)
  569. var sql string
  570. sql = helper.StringJoin("insert into ", dbName, " set ", strings.Join(this.data, " , "))
  571. if this.debug {
  572. log.Println("insert sql:", sql, this.value)
  573. }
  574. condition_len := 0 //所有条件数
  575. for _, ch2 := range sql {
  576. if string(ch2) == "?" {
  577. condition_len++
  578. }
  579. }
  580. if condition_len != len(this.value) {
  581. return errors.New("参数错误,条件值错误")
  582. }
  583. if this.conn == nil {
  584. this.conn = DB
  585. }
  586. stmt, err = this.conn.Prepare(sql)
  587. if err != nil {
  588. return err
  589. }
  590. this.stmt = stmt
  591. return nil
  592. }
  593. // 拼删除sql
  594. func (this *Query) DeleteStmt() error {
  595. if this.dbname == "" && this.table == "" {
  596. return errors.New("参数错误,没有数据表")
  597. }
  598. if len(this.where) < 1 {
  599. return errors.New("参数错误,缺少条件")
  600. }
  601. dbName := getTableName(this.dbname, this.table, this.dbtype)
  602. var sql string
  603. sql = helper.StringJoin("delete from ", dbName, " where ", strings.Join(this.where, " and "))
  604. if this.page_size > 0 {
  605. sql = helper.StringJoin(sql, " limit ", strconv.Itoa(this.page_size))
  606. }
  607. if this.debug {
  608. log.Println("delete sql:", sql, this.value)
  609. }
  610. condition_len := 0 //所有条件数
  611. for _, ch2 := range sql {
  612. if string(ch2) == "?" {
  613. condition_len++
  614. }
  615. }
  616. if condition_len != len(this.value) {
  617. return errors.New("参数错误,条件值错误")
  618. }
  619. if this.conn == nil {
  620. this.conn = DB
  621. }
  622. stmt, err = this.conn.Prepare(sql)
  623. if err != nil {
  624. return err
  625. }
  626. this.stmt = stmt
  627. return nil
  628. }
  629. /**
  630. * 执行查询列表
  631. * return list error
  632. */
  633. func (this *Query) Select() ([]map[string]string, error) {
  634. _, rows, err := FetchRows(this.dbname, this.table, this.alias, this.title, this.join,
  635. this.where, this.where_or, this.value, this.orderby, this.groupby, this.having, this.page, this.page_size, this.debug)
  636. return rows, err
  637. }
  638. /**
  639. * 执行查询多条数据
  640. * return row error
  641. * 2022/01/05
  642. */
  643. func (this *Query) List() ([]map[string]string, error) {
  644. err := this.QueryStmt()
  645. if err != nil {
  646. return []map[string]string{}, err
  647. }
  648. if this.stmt == nil {
  649. return []map[string]string{}, errors.New("缺少必要参数")
  650. }
  651. return StmtForQueryList(this.stmt, this.value)
  652. }
  653. /**
  654. * 执行查询一条数据
  655. * return row error
  656. */
  657. func (this *Query) Find() (map[string]string, error) {
  658. _, row, err := GetRow(this.dbname, this.table, this.alias, this.title, this.join,
  659. this.where, this.where_or, this.value, this.orderby, this.groupby, this.having, this.debug)
  660. return row, err
  661. }
  662. /**
  663. * 执行查询一条数据
  664. * return row error
  665. * 2022/01/05
  666. */
  667. func (this *Query) Get() (map[string]string, error) {
  668. this.page = 1
  669. this.page_size = 1
  670. err := this.QueryStmt()
  671. if err != nil {
  672. return map[string]string{}, err
  673. }
  674. if this.stmt == nil {
  675. return nil, errors.New("缺少必要参数")
  676. }
  677. return StmtForQueryRow(this.stmt, this.value)
  678. }
  679. /**
  680. * 执行更新
  681. * return is_updated error
  682. */
  683. func (this *Query) Update() (int64, error) {
  684. err := this.UpdateStmt()
  685. if err != nil {
  686. return 0, err
  687. }
  688. return StmtForUpdateExec(this.stmt, this.value)
  689. }
  690. //批量更新
  691. func (this *Query) UpdateAll() (int64, error) {
  692. err := this.UpdateAllStmt()
  693. if err != nil {
  694. return 0, err
  695. }
  696. return StmtForUpdateExec(this.stmt, this.value)
  697. }
  698. /**
  699. * 执行删除
  700. * return is_delete error
  701. */
  702. func (this *Query) Delete() (int64, error) {
  703. err := this.DeleteStmt()
  704. if err != nil {
  705. return 0, err
  706. }
  707. return StmtForUpdateExec(this.stmt, this.value)
  708. }
  709. /**
  710. * 执行写入
  711. * return is_insert error
  712. */
  713. func (this *Query) Create() (int64, error) {
  714. err := this.CreateStmt()
  715. if err != nil {
  716. return 0, err
  717. }
  718. return StmtForInsertExec(this.stmt, this.value)
  719. }
  720. func (this *Query) CreateAll() (int64, error) {
  721. err := this.CreateAllStmt()
  722. if err != nil {
  723. return 0, err
  724. }
  725. return StmtForInsertExec(this.stmt, this.value)
  726. }