Simple and Powerful ORM for Go, support mysql,postgres,tidb,sqlite3,mssql,oracle https://xorm.io
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.

550 lines
16KB

  1. // Copyright 2016 The Xorm Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style
  3. // license that can be found in the LICENSE file.
  4. package xorm
  5. import (
  6. "errors"
  7. "fmt"
  8. "reflect"
  9. "strconv"
  10. "strings"
  11. "xorm.io/builder"
  12. "xorm.io/core"
  13. )
  14. func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string, args ...interface{}) error {
  15. if table == nil ||
  16. session.tx != nil {
  17. return ErrCacheFailed
  18. }
  19. oldhead, newsql := session.statement.convertUpdateSQL(sqlStr)
  20. if newsql == "" {
  21. return ErrCacheFailed
  22. }
  23. for _, filter := range session.engine.dialect.Filters() {
  24. newsql = filter.Do(newsql, session.engine.dialect, table)
  25. }
  26. session.engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
  27. var nStart int
  28. if len(args) > 0 {
  29. if strings.Index(sqlStr, "?") > -1 {
  30. nStart = strings.Count(oldhead, "?")
  31. } else {
  32. // only for pq, TODO: if any other databse?
  33. nStart = strings.Count(oldhead, "$")
  34. }
  35. }
  36. cacher := session.engine.getCacher(tableName)
  37. session.engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
  38. ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:])
  39. if err != nil {
  40. rows, err := session.NoCache().queryRows(newsql, args[nStart:]...)
  41. if err != nil {
  42. return err
  43. }
  44. defer rows.Close()
  45. ids = make([]core.PK, 0)
  46. for rows.Next() {
  47. var res = make([]string, len(table.PrimaryKeys))
  48. err = rows.ScanSlice(&res)
  49. if err != nil {
  50. return err
  51. }
  52. var pk core.PK = make([]interface{}, len(table.PrimaryKeys))
  53. for i, col := range table.PKColumns() {
  54. if col.SQLType.IsNumeric() {
  55. n, err := strconv.ParseInt(res[i], 10, 64)
  56. if err != nil {
  57. return err
  58. }
  59. pk[i] = n
  60. } else if col.SQLType.IsText() {
  61. pk[i] = res[i]
  62. } else {
  63. return errors.New("not supported")
  64. }
  65. }
  66. ids = append(ids, pk)
  67. }
  68. session.engine.logger.Debug("[cacheUpdate] find updated id", ids)
  69. } /*else {
  70. session.engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
  71. cacher.DelIds(tableName, genSqlKey(newsql, args))
  72. }*/
  73. for _, id := range ids {
  74. sid, err := id.ToString()
  75. if err != nil {
  76. return err
  77. }
  78. if bean := cacher.GetBean(tableName, sid); bean != nil {
  79. sqls := splitNNoCase(sqlStr, "where", 2)
  80. if len(sqls) == 0 || len(sqls) > 2 {
  81. return ErrCacheFailed
  82. }
  83. sqls = splitNNoCase(sqls[0], "set", 2)
  84. if len(sqls) != 2 {
  85. return ErrCacheFailed
  86. }
  87. kvs := strings.Split(strings.TrimSpace(sqls[1]), ",")
  88. for idx, kv := range kvs {
  89. sps := strings.SplitN(kv, "=", 2)
  90. sps2 := strings.Split(sps[0], ".")
  91. colName := sps2[len(sps2)-1]
  92. // treat quote prefix, suffix and '`' as quotes
  93. quotes := append(strings.Split(session.engine.Quote(""), ""), "`")
  94. if strings.ContainsAny(colName, strings.Join(quotes, "")) {
  95. colName = strings.TrimSpace(eraseAny(colName, quotes...))
  96. } else {
  97. session.engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
  98. return ErrCacheFailed
  99. }
  100. if col := table.GetColumn(colName); col != nil {
  101. fieldValue, err := col.ValueOf(bean)
  102. if err != nil {
  103. session.engine.logger.Error(err)
  104. } else {
  105. session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
  106. if col.IsVersion && session.statement.checkVersion {
  107. session.incrVersionFieldValue(fieldValue)
  108. } else {
  109. fieldValue.Set(reflect.ValueOf(args[idx]))
  110. }
  111. }
  112. } else {
  113. session.engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
  114. colName, table.Name)
  115. }
  116. }
  117. session.engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
  118. cacher.PutBean(tableName, sid, bean)
  119. }
  120. }
  121. session.engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
  122. cacher.ClearIds(tableName)
  123. return nil
  124. }
  125. // Update records, bean's non-empty fields are updated contents,
  126. // condiBean' non-empty filds are conditions
  127. // CAUTION:
  128. // 1.bool will defaultly be updated content nor conditions
  129. // You should call UseBool if you have bool to use.
  130. // 2.float32 & float64 may be not inexact as conditions
  131. func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
  132. if session.isAutoClose {
  133. defer session.Close()
  134. }
  135. if session.statement.lastError != nil {
  136. return 0, session.statement.lastError
  137. }
  138. v := rValue(bean)
  139. t := v.Type()
  140. var colNames []string
  141. var args []interface{}
  142. // handle before update processors
  143. for _, closure := range session.beforeClosures {
  144. closure(bean)
  145. }
  146. cleanupProcessorsClosures(&session.beforeClosures) // cleanup after used
  147. if processor, ok := interface{}(bean).(BeforeUpdateProcessor); ok {
  148. processor.BeforeUpdate()
  149. }
  150. // --
  151. var err error
  152. var isMap = t.Kind() == reflect.Map
  153. var isStruct = t.Kind() == reflect.Struct
  154. if isStruct {
  155. if err := session.statement.setRefBean(bean); err != nil {
  156. return 0, err
  157. }
  158. if len(session.statement.TableName()) <= 0 {
  159. return 0, ErrTableNotFound
  160. }
  161. if session.statement.ColumnStr == "" {
  162. colNames, args = session.statement.buildUpdates(bean, false, false,
  163. false, false, true)
  164. } else {
  165. colNames, args, err = session.genUpdateColumns(bean)
  166. if err != nil {
  167. return 0, err
  168. }
  169. }
  170. } else if isMap {
  171. colNames = make([]string, 0)
  172. args = make([]interface{}, 0)
  173. bValue := reflect.Indirect(reflect.ValueOf(bean))
  174. for _, v := range bValue.MapKeys() {
  175. colNames = append(colNames, session.engine.Quote(v.String())+" = ?")
  176. args = append(args, bValue.MapIndex(v).Interface())
  177. }
  178. } else {
  179. return 0, ErrParamsType
  180. }
  181. table := session.statement.RefTable
  182. if session.statement.UseAutoTime && table != nil && table.Updated != "" {
  183. if !session.statement.columnMap.contain(table.Updated) &&
  184. !session.statement.omitColumnMap.contain(table.Updated) {
  185. colNames = append(colNames, session.engine.Quote(table.Updated)+" = ?")
  186. col := table.UpdatedColumn()
  187. val, t := session.engine.nowTime(col)
  188. args = append(args, val)
  189. var colName = col.Name
  190. if isStruct {
  191. session.afterClosures = append(session.afterClosures, func(bean interface{}) {
  192. col := table.GetColumn(colName)
  193. setColumnTime(bean, col, t)
  194. })
  195. }
  196. }
  197. }
  198. // for update action to like "column = column + ?"
  199. incColumns := session.statement.incrColumns
  200. for i, colName := range incColumns.colNames {
  201. colNames = append(colNames, session.engine.Quote(colName)+" = "+session.engine.Quote(colName)+" + ?")
  202. args = append(args, incColumns.args[i])
  203. }
  204. // for update action to like "column = column - ?"
  205. decColumns := session.statement.decrColumns
  206. for i, colName := range decColumns.colNames {
  207. colNames = append(colNames, session.engine.Quote(colName)+" = "+session.engine.Quote(colName)+" - ?")
  208. args = append(args, decColumns.args[i])
  209. }
  210. // for update action to like "column = expression"
  211. exprColumns := session.statement.exprColumns
  212. for i, colName := range exprColumns.colNames {
  213. switch tp := exprColumns.args[i].(type) {
  214. case string:
  215. if len(tp) == 0 {
  216. tp = "''"
  217. }
  218. colNames = append(colNames, session.engine.Quote(colName)+"="+tp)
  219. case *builder.Builder:
  220. subQuery, subArgs, err := builder.ToSQL(tp)
  221. if err != nil {
  222. return 0, err
  223. }
  224. colNames = append(colNames, session.engine.Quote(colName)+"=("+subQuery+")")
  225. args = append(args, subArgs...)
  226. default:
  227. colNames = append(colNames, session.engine.Quote(colName)+"=?")
  228. args = append(args, exprColumns.args[i])
  229. }
  230. }
  231. if err = session.statement.processIDParam(); err != nil {
  232. return 0, err
  233. }
  234. var autoCond builder.Cond
  235. if !session.statement.noAutoCondition {
  236. condBeanIsStruct := false
  237. if len(condiBean) > 0 {
  238. if c, ok := condiBean[0].(map[string]interface{}); ok {
  239. autoCond = builder.Eq(c)
  240. } else {
  241. ct := reflect.TypeOf(condiBean[0])
  242. k := ct.Kind()
  243. if k == reflect.Ptr {
  244. k = ct.Elem().Kind()
  245. }
  246. if k == reflect.Struct {
  247. var err error
  248. autoCond, err = session.statement.buildConds(session.statement.RefTable, condiBean[0], true, true, false, true, false)
  249. if err != nil {
  250. return 0, err
  251. }
  252. condBeanIsStruct = true
  253. } else {
  254. return 0, ErrConditionType
  255. }
  256. }
  257. }
  258. if !condBeanIsStruct && table != nil {
  259. if col := table.DeletedColumn(); col != nil && !session.statement.unscoped { // tag "deleted" is enabled
  260. autoCond1 := session.engine.CondDeleted(session.engine.Quote(col.Name))
  261. if autoCond == nil {
  262. autoCond = autoCond1
  263. } else {
  264. autoCond = autoCond.And(autoCond1)
  265. }
  266. }
  267. }
  268. }
  269. st := &session.statement
  270. var (
  271. sqlStr string
  272. condArgs []interface{}
  273. condSQL string
  274. cond = session.statement.cond.And(autoCond)
  275. doIncVer = isStruct && (table != nil && table.Version != "" && session.statement.checkVersion)
  276. verValue *reflect.Value
  277. )
  278. if doIncVer {
  279. verValue, err = table.VersionColumn().ValueOf(bean)
  280. if err != nil {
  281. return 0, err
  282. }
  283. if verValue != nil {
  284. cond = cond.And(builder.Eq{session.engine.Quote(table.Version): verValue.Interface()})
  285. colNames = append(colNames, session.engine.Quote(table.Version)+" = "+session.engine.Quote(table.Version)+" + 1")
  286. }
  287. }
  288. condSQL, condArgs, err = builder.ToSQL(cond)
  289. if err != nil {
  290. return 0, err
  291. }
  292. if len(condSQL) > 0 {
  293. condSQL = "WHERE " + condSQL
  294. }
  295. if st.OrderStr != "" {
  296. condSQL = condSQL + fmt.Sprintf(" ORDER BY %v", st.OrderStr)
  297. }
  298. var tableName = session.statement.TableName()
  299. // TODO: Oracle support needed
  300. var top string
  301. if st.LimitN != nil {
  302. limitValue := *st.LimitN
  303. if st.Engine.dialect.DBType() == core.MYSQL {
  304. condSQL = condSQL + fmt.Sprintf(" LIMIT %d", limitValue)
  305. } else if st.Engine.dialect.DBType() == core.SQLITE {
  306. tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", limitValue)
  307. cond = cond.And(builder.Expr(fmt.Sprintf("rowid IN (SELECT rowid FROM %v %v)",
  308. session.engine.Quote(tableName), tempCondSQL), condArgs...))
  309. condSQL, condArgs, err = builder.ToSQL(cond)
  310. if err != nil {
  311. return 0, err
  312. }
  313. if len(condSQL) > 0 {
  314. condSQL = "WHERE " + condSQL
  315. }
  316. } else if st.Engine.dialect.DBType() == core.POSTGRES {
  317. tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", limitValue)
  318. cond = cond.And(builder.Expr(fmt.Sprintf("CTID IN (SELECT CTID FROM %v %v)",
  319. session.engine.Quote(tableName), tempCondSQL), condArgs...))
  320. condSQL, condArgs, err = builder.ToSQL(cond)
  321. if err != nil {
  322. return 0, err
  323. }
  324. if len(condSQL) > 0 {
  325. condSQL = "WHERE " + condSQL
  326. }
  327. } else if st.Engine.dialect.DBType() == core.MSSQL {
  328. if st.OrderStr != "" && st.Engine.dialect.DBType() == core.MSSQL &&
  329. table != nil && len(table.PrimaryKeys) == 1 {
  330. cond = builder.Expr(fmt.Sprintf("%s IN (SELECT TOP (%d) %s FROM %v%v)",
  331. table.PrimaryKeys[0], limitValue, table.PrimaryKeys[0],
  332. session.engine.Quote(tableName), condSQL), condArgs...)
  333. condSQL, condArgs, err = builder.ToSQL(cond)
  334. if err != nil {
  335. return 0, err
  336. }
  337. if len(condSQL) > 0 {
  338. condSQL = "WHERE " + condSQL
  339. }
  340. } else {
  341. top = fmt.Sprintf("TOP (%d) ", limitValue)
  342. }
  343. }
  344. }
  345. if len(colNames) <= 0 {
  346. return 0, errors.New("No content found to be updated")
  347. }
  348. var tableAlias = session.engine.Quote(tableName)
  349. var fromSQL string
  350. if session.statement.TableAlias != "" {
  351. switch session.engine.dialect.DBType() {
  352. case core.MSSQL:
  353. fromSQL = fmt.Sprintf("FROM %s %s ", tableAlias, session.statement.TableAlias)
  354. tableAlias = session.statement.TableAlias
  355. default:
  356. tableAlias = fmt.Sprintf("%s AS %s", tableAlias, session.statement.TableAlias)
  357. }
  358. }
  359. sqlStr = fmt.Sprintf("UPDATE %v%v SET %v %v%v",
  360. top,
  361. tableAlias,
  362. strings.Join(colNames, ", "),
  363. fromSQL,
  364. condSQL)
  365. res, err := session.exec(sqlStr, append(args, condArgs...)...)
  366. if err != nil {
  367. return 0, err
  368. } else if doIncVer {
  369. if verValue != nil && verValue.IsValid() && verValue.CanSet() {
  370. session.incrVersionFieldValue(verValue)
  371. }
  372. }
  373. if cacher := session.engine.getCacher(tableName); cacher != nil && session.statement.UseCache {
  374. // session.cacheUpdate(table, tableName, sqlStr, args...)
  375. session.engine.logger.Debug("[cacheUpdate] clear table ", tableName)
  376. cacher.ClearIds(tableName)
  377. cacher.ClearBeans(tableName)
  378. }
  379. // handle after update processors
  380. if session.isAutoCommit {
  381. for _, closure := range session.afterClosures {
  382. closure(bean)
  383. }
  384. if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
  385. session.engine.logger.Debug("[event]", tableName, " has after update processor")
  386. processor.AfterUpdate()
  387. }
  388. } else {
  389. lenAfterClosures := len(session.afterClosures)
  390. if lenAfterClosures > 0 {
  391. if value, has := session.afterUpdateBeans[bean]; has && value != nil {
  392. *value = append(*value, session.afterClosures...)
  393. } else {
  394. afterClosures := make([]func(interface{}), lenAfterClosures)
  395. copy(afterClosures, session.afterClosures)
  396. // FIXME: if bean is a map type, it will panic because map cannot be as map key
  397. session.afterUpdateBeans[bean] = &afterClosures
  398. }
  399. } else {
  400. if _, ok := interface{}(bean).(AfterUpdateProcessor); ok {
  401. session.afterUpdateBeans[bean] = nil
  402. }
  403. }
  404. }
  405. cleanupProcessorsClosures(&session.afterClosures) // cleanup after used
  406. // --
  407. return res.RowsAffected()
  408. }
  409. func (session *Session) genUpdateColumns(bean interface{}) ([]string, []interface{}, error) {
  410. table := session.statement.RefTable
  411. colNames := make([]string, 0, len(table.ColumnsSeq()))
  412. args := make([]interface{}, 0, len(table.ColumnsSeq()))
  413. for _, col := range table.Columns() {
  414. if !col.IsVersion && !col.IsCreated && !col.IsUpdated {
  415. if session.statement.omitColumnMap.contain(col.Name) {
  416. continue
  417. }
  418. }
  419. if col.MapType == core.ONLYFROMDB {
  420. continue
  421. }
  422. fieldValuePtr, err := col.ValueOf(bean)
  423. if err != nil {
  424. return nil, nil, err
  425. }
  426. fieldValue := *fieldValuePtr
  427. if col.IsAutoIncrement {
  428. switch fieldValue.Type().Kind() {
  429. case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int, reflect.Int64:
  430. if fieldValue.Int() == 0 {
  431. continue
  432. }
  433. case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
  434. if fieldValue.Uint() == 0 {
  435. continue
  436. }
  437. case reflect.String:
  438. if len(fieldValue.String()) == 0 {
  439. continue
  440. }
  441. case reflect.Ptr:
  442. if fieldValue.Pointer() == 0 {
  443. continue
  444. }
  445. }
  446. }
  447. if (col.IsDeleted && !session.statement.unscoped) || col.IsCreated {
  448. continue
  449. }
  450. // if only update specify columns
  451. if len(session.statement.columnMap) > 0 && !session.statement.columnMap.contain(col.Name) {
  452. continue
  453. }
  454. if session.statement.incrColumns.isColExist(col.Name) {
  455. continue
  456. } else if session.statement.decrColumns.isColExist(col.Name) {
  457. continue
  458. } else if session.statement.exprColumns.isColExist(col.Name) {
  459. continue
  460. }
  461. // !evalphobia! set fieldValue as nil when column is nullable and zero-value
  462. if _, ok := getFlagForColumn(session.statement.nullableMap, col); ok {
  463. if col.Nullable && isZeroValue(fieldValue) {
  464. var nilValue *int
  465. fieldValue = reflect.ValueOf(nilValue)
  466. }
  467. }
  468. if col.IsUpdated && session.statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
  469. // if time is non-empty, then set to auto time
  470. val, t := session.engine.nowTime(col)
  471. args = append(args, val)
  472. var colName = col.Name
  473. session.afterClosures = append(session.afterClosures, func(bean interface{}) {
  474. col := table.GetColumn(colName)
  475. setColumnTime(bean, col, t)
  476. })
  477. } else if col.IsVersion && session.statement.checkVersion {
  478. args = append(args, 1)
  479. } else {
  480. arg, err := session.value2Interface(col, fieldValue)
  481. if err != nil {
  482. return colNames, args, err
  483. }
  484. args = append(args, arg)
  485. }
  486. colNames = append(colNames, session.engine.Quote(col.Name)+" = ?")
  487. }
  488. return colNames, args, nil
  489. }