From 6d4e8ec4d60c8c79f13945776e5517534b53d432 Mon Sep 17 00:00:00 2001 From: ying-jeanne <74549700+ying-jeanne@users.noreply.github.com> Date: Tue, 31 Jan 2023 22:43:35 +0800 Subject: [PATCH] [xorm] Remove unused functions from engine (#62590) remove unuseful functions from engine --- pkg/util/xorm/LICENSE | 27 ++ pkg/util/xorm/engine.go | 528 ---------------------------------- pkg/util/xorm/helpers.go | 174 ++--------- pkg/util/xorm/interface.go | 103 ------- pkg/util/xorm/logger.go | 29 +- pkg/util/xorm/session_cols.go | 31 -- pkg/util/xorm/session_find.go | 216 -------------- pkg/util/xorm/statement.go | 5 + pkg/util/xorm/transaction.go | 26 -- pkg/util/xorm/types.go | 16 -- 10 files changed, 57 insertions(+), 1098 deletions(-) create mode 100644 pkg/util/xorm/LICENSE delete mode 100644 pkg/util/xorm/interface.go delete mode 100644 pkg/util/xorm/transaction.go delete mode 100644 pkg/util/xorm/types.go diff --git a/pkg/util/xorm/LICENSE b/pkg/util/xorm/LICENSE new file mode 100644 index 00000000000..463b920c2c2 --- /dev/null +++ b/pkg/util/xorm/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2013 - 2015 The Xorm Authors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the {organization} nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/pkg/util/xorm/engine.go b/pkg/util/xorm/engine.go index 47608749d0d..783da30e6da 100644 --- a/pkg/util/xorm/engine.go +++ b/pkg/util/xorm/engine.go @@ -11,7 +11,6 @@ import ( "errors" "fmt" "reflect" - "strconv" "strings" "sync" "time" @@ -199,23 +198,6 @@ func (engine *Engine) quote(sql string) string { return engine.dialect.Quote(sql) } -// SqlType will be deprecated, please use SQLType instead -// -// Deprecated: use SQLType instead -func (engine *Engine) SqlType(c *core.Column) string { - return engine.SQLType(c) -} - -// SQLType A simple wrapper to dialect's core.SqlType method -func (engine *Engine) SQLType(c *core.Column) string { - return engine.dialect.SqlType(c) -} - -// AutoIncrStr Database's autoincrement statement -func (engine *Engine) AutoIncrStr() string { - return engine.dialect.AutoIncrStr() -} - // SetConnMaxLifetime sets the maximum amount of time a connection may be reused. func (engine *Engine) SetConnMaxLifetime(d time.Duration) { engine.db.SetConnMaxLifetime(d) @@ -265,14 +247,6 @@ func (engine *Engine) Ping() error { return session.Ping() } -// Sql provides raw sql input parameter. When you have a complex SQL statement -// and cannot use Where, Id, In and etc. Methods to describe, you can use SQL. -// -// Deprecated: use SQL instead. -func (engine *Engine) Sql(querystring string, args ...interface{}) *Session { - return engine.SQL(querystring, args...) -} - // SQL method let's you manually write raw SQL and operate // For example: // @@ -333,13 +307,6 @@ func (engine *Engine) Where(query interface{}, args ...interface{}) *Session { return session.Where(query, args...) } -// Id will be deprecated, please use ID instead -func (engine *Engine) Id(id interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Id(id) -} - // ID method provoide a condition as (id) = ? func (engine *Engine) ID(id interface{}) *Session { session := engine.NewSession() @@ -375,103 +342,6 @@ func (engine *Engine) StoreEngine(storeEngine string) *Session { return session.StoreEngine(storeEngine) } -// Distinct use for distinct columns. Caution: when you are using cache, -// distinct will not be cached because cache system need id, -// but distinct will not provide id -func (engine *Engine) Distinct(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Distinct(columns...) -} - -// Select customerize your select columns or contents -func (engine *Engine) Select(str string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Select(str) -} - -// Cols only use the parameters as select or update columns -func (engine *Engine) Cols(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Cols(columns...) -} - -// AllCols indicates that all columns should be use -func (engine *Engine) AllCols() *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.AllCols() -} - -// MustCols specify some columns must use even if they are empty -func (engine *Engine) MustCols(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.MustCols(columns...) -} - -// UseBool xorm automatically retrieve condition according struct, but -// if struct has bool field, it will ignore them. So use UseBool -// to tell system to do not ignore them. -// If no parameters, it will use all the bool field of struct, or -// it will use parameters's columns -func (engine *Engine) UseBool(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.UseBool(columns...) -} - -// Omit only not use the parameters as select or update columns -func (engine *Engine) Omit(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Omit(columns...) -} - -// Nullable set null when column is zero-value and nullable for update -func (engine *Engine) Nullable(columns ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Nullable(columns...) -} - -// In will generate "column IN (?, ?)" -func (engine *Engine) In(column string, args ...interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.In(column, args...) -} - -// NotIn will generate "column NOT IN (?, ?)" -func (engine *Engine) NotIn(column string, args ...interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.NotIn(column, args...) -} - -// Incr provides a update string like "column = column + ?" -func (engine *Engine) Incr(column string, arg ...interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Incr(column, arg...) -} - -// Decr provides a update string like "column = column - ?" -func (engine *Engine) Decr(column string, arg ...interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Decr(column, arg...) -} - -// SetExpr provides a update string like "column = {expression}" -func (engine *Engine) SetExpr(column string, expression interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.SetExpr(column, expression) -} - // Table temporarily change the Get, Find, Update's table func (engine *Engine) Table(tableNameOrBean interface{}) *Session { session := engine.NewSession() @@ -479,80 +349,6 @@ func (engine *Engine) Table(tableNameOrBean interface{}) *Session { return session.Table(tableNameOrBean) } -// Alias set the table alias -func (engine *Engine) Alias(alias string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Alias(alias) -} - -// Limit will generate "LIMIT start, limit" -func (engine *Engine) Limit(limit int, start ...int) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Limit(limit, start...) -} - -// Desc will generate "ORDER BY column1 DESC, column2 DESC" -func (engine *Engine) Desc(colNames ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Desc(colNames...) -} - -// Asc will generate "ORDER BY column1,column2 Asc" -// This method can chainable use. -// -// engine.Desc("name").Asc("age").Find(&users) -// // SELECT * FROM user ORDER BY name DESC, age ASC -func (engine *Engine) Asc(colNames ...string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Asc(colNames...) -} - -// OrderBy will generate "ORDER BY order" -func (engine *Engine) OrderBy(order string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.OrderBy(order) -} - -// Prepare enables prepare statement -func (engine *Engine) Prepare() *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Prepare() -} - -// Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN -func (engine *Engine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Join(joinOperator, tablename, condition, args...) -} - -// GroupBy generate group by statement -func (engine *Engine) GroupBy(keys string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.GroupBy(keys) -} - -// Having generate having statement -func (engine *Engine) Having(conditions string) *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Having(conditions) -} - -// UnMapType removes the database mapper of a type -func (engine *Engine) UnMapType(t reflect.Type) { - engine.mutex.Lock() - defer engine.mutex.Unlock() - delete(engine.Tables, t) -} - func (engine *Engine) autoMapType(v reflect.Value) (*core.Table, error) { t := v.Type() engine.mutex.Lock() @@ -589,11 +385,6 @@ type Table struct { Name string } -// IsValid if table is valid -func (t *Table) IsValid() bool { - return t.Table != nil && len(t.Name) > 0 -} - func addIndex(indexName string, table *core.Table, col *core.Column, indexType int) { if index, ok := table.Indexes[indexName]; ok { index.AddColumn(col.Name) @@ -781,13 +572,6 @@ func (engine *Engine) mapType(v reflect.Value) (*core.Table, error) { return table, nil } -// IsTableEmpty if a table has any reocrd -func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error) { - session := engine.NewSession() - defer session.Close() - return session.IsTableEmpty(bean) -} - // IsTableExist if a table is exist func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error) { session := engine.NewSession() @@ -795,109 +579,6 @@ func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error) { return session.IsTableExist(beanOrTableName) } -// IdOf get id from one struct -// -// Deprecated: use IDOf instead. -func (engine *Engine) IdOf(bean interface{}) core.PK { - return engine.IDOf(bean) -} - -// IDOf get id from one struct -func (engine *Engine) IDOf(bean interface{}) core.PK { - return engine.IdOfV(reflect.ValueOf(bean)) -} - -// IdOfV get id from one value of struct -// -// Deprecated: use IDOfV instead. -func (engine *Engine) IdOfV(rv reflect.Value) core.PK { - return engine.IDOfV(rv) -} - -// IDOfV get id from one value of struct -func (engine *Engine) IDOfV(rv reflect.Value) core.PK { - pk, err := engine.idOfV(rv) - if err != nil { - engine.logger.Error(err) - return nil - } - return pk -} - -func (engine *Engine) idOfV(rv reflect.Value) (core.PK, error) { - v := reflect.Indirect(rv) - table, err := engine.autoMapType(v) - if err != nil { - return nil, err - } - - pk := make([]interface{}, len(table.PrimaryKeys)) - for i, col := range table.PKColumns() { - var err error - - fieldName := col.FieldName - for { - parts := strings.SplitN(fieldName, ".", 2) - if len(parts) == 1 { - break - } - - v = v.FieldByName(parts[0]) - if v.Kind() == reflect.Ptr { - v = v.Elem() - } - if v.Kind() != reflect.Struct { - return nil, ErrUnSupportedType - } - fieldName = parts[1] - } - - pkField := v.FieldByName(fieldName) - switch pkField.Kind() { - case reflect.String: - pk[i], err = engine.idTypeAssertion(col, pkField.String()) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - pk[i], err = engine.idTypeAssertion(col, strconv.FormatInt(pkField.Int(), 10)) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - // id of uint will be converted to int64 - pk[i], err = engine.idTypeAssertion(col, strconv.FormatUint(pkField.Uint(), 10)) - } - - if err != nil { - return nil, err - } - } - return core.PK(pk), nil -} - -func (engine *Engine) idTypeAssertion(col *core.Column, sid string) (interface{}, error) { - if col.SQLType.IsNumeric() { - n, err := strconv.ParseInt(sid, 10, 64) - if err != nil { - return nil, err - } - return n, nil - } else if col.SQLType.IsText() { - return sid, nil - } else { - return nil, errors.New("not supported") - } -} - -// CreateIndexes create indexes -func (engine *Engine) CreateIndexes(bean interface{}) error { - session := engine.NewSession() - defer session.Close() - return session.CreateIndexes(bean) -} - -// CreateUniques create uniques -func (engine *Engine) CreateUniques(bean interface{}) error { - session := engine.NewSession() - defer session.Close() - return session.CreateUniques(bean) -} - // Sync the new struct changes to database, this method will automatically add // table, column, index, unique. but will not delete or change anything. // If you change some field, you should change the database manually. @@ -1001,53 +682,6 @@ func (engine *Engine) Sync2(beans ...interface{}) error { return s.Sync2(beans...) } -// CreateTables create tabls according bean -func (engine *Engine) CreateTables(beans ...interface{}) error { - session := engine.NewSession() - defer session.Close() - - err := session.Begin() - if err != nil { - return err - } - - for _, bean := range beans { - err = session.createTable(bean) - if err != nil { - session.Rollback() - return err - } - } - return session.Commit() -} - -// DropTables drop specify tables -func (engine *Engine) DropTables(beans ...interface{}) error { - session := engine.NewSession() - defer session.Close() - - err := session.Begin() - if err != nil { - return err - } - - for _, bean := range beans { - err = session.dropTable(bean) - if err != nil { - session.Rollback() - return err - } - } - return session.Commit() -} - -// DropIndexes drop indexes of a table -func (engine *Engine) DropIndexes(bean interface{}) error { - session := engine.NewSession() - defer session.Close() - return session.DropIndexes(bean) -} - // Exec raw sql func (engine *Engine) Exec(sqlOrArgs ...interface{}) (sql.Result, error) { session := engine.NewSession() @@ -1055,27 +689,6 @@ func (engine *Engine) Exec(sqlOrArgs ...interface{}) (sql.Result, error) { return session.Exec(sqlOrArgs...) } -// Query a raw sql and return records as []map[string][]byte -func (engine *Engine) Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error) { - session := engine.NewSession() - defer session.Close() - return session.Query(sqlOrArgs...) -} - -// QueryString runs a raw sql and return records as []map[string]string -func (engine *Engine) QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) { - session := engine.NewSession() - defer session.Close() - return session.QueryString(sqlOrArgs...) -} - -// QueryInterface runs a raw sql and return records as []map[string]interface{} -func (engine *Engine) QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) { - session := engine.NewSession() - defer session.Close() - return session.QueryInterface(sqlOrArgs...) -} - // Insert one or more records func (engine *Engine) Insert(beans ...interface{}) (int64, error) { session := engine.NewSession() @@ -1083,48 +696,6 @@ func (engine *Engine) Insert(beans ...interface{}) (int64, error) { return session.Insert(beans...) } -// InsertOne insert only one record -func (engine *Engine) InsertOne(bean interface{}) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.InsertOne(bean) -} - -// Update records, bean's non-empty fields are updated contents, -// condiBean' non-empty filds are conditions -// CAUTION: -// -// 1.bool will defaultly be updated content nor conditions -// You should call UseBool if you have bool to use. -// 2.float32 & float64 may be not inexact as conditions -func (engine *Engine) Update(bean interface{}, condiBeans ...interface{}) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.Update(bean, condiBeans...) -} - -// Delete records, bean's non-empty fields are conditions -func (engine *Engine) Delete(bean interface{}) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.Delete(bean) -} - -// Get retrieve one record from table, bean's non-empty fields -// are conditions -func (engine *Engine) Get(bean interface{}) (bool, error) { - session := engine.NewSession() - defer session.Close() - return session.Get(bean) -} - -// Exist returns true if the record exist otherwise return false -func (engine *Engine) Exist(bean ...interface{}) (bool, error) { - session := engine.NewSession() - defer session.Close() - return session.Exist(bean...) -} - // Find retrieve records from table, condiBeans's non-empty fields // are conditions. beans could be []Struct, []*Struct, map[int64]Struct // map[int64]*Struct @@ -1134,63 +705,6 @@ func (engine *Engine) Find(beans interface{}, condiBeans ...interface{}) error { return session.Find(beans, condiBeans...) } -// FindAndCount find the results and also return the counts -func (engine *Engine) FindAndCount(rowsSlicePtr interface{}, condiBean ...interface{}) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.FindAndCount(rowsSlicePtr, condiBean...) -} - -// Iterate record by record handle records from table, bean's non-empty fields -// are conditions. -func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error { - session := engine.NewSession() - defer session.Close() - return session.Iterate(bean, fun) -} - -// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields -// are conditions. -func (engine *Engine) Rows(bean interface{}) (*Rows, error) { - session := engine.NewSession() - return session.Rows(bean) -} - -// Count counts the records. bean's non-empty fields are conditions. -func (engine *Engine) Count(bean ...interface{}) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.Count(bean...) -} - -// Sum sum the records by some column. bean's non-empty fields are conditions. -func (engine *Engine) Sum(bean interface{}, colName string) (float64, error) { - session := engine.NewSession() - defer session.Close() - return session.Sum(bean, colName) -} - -// SumInt sum the records by some column. bean's non-empty fields are conditions. -func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error) { - session := engine.NewSession() - defer session.Close() - return session.SumInt(bean, colName) -} - -// Sums sum the records by some columns. bean's non-empty fields are conditions. -func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error) { - session := engine.NewSession() - defer session.Close() - return session.Sums(bean, colNames...) -} - -// SumsInt like Sums but return slice of int64 instead of float64. -func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, error) { - session := engine.NewSession() - defer session.Close() - return session.SumsInt(bean, colNames...) -} - // nowTime return current time func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) { t := time.Now() @@ -1234,45 +748,3 @@ func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{} } return } - -// GetColumnMapper returns the column name mapper -func (engine *Engine) GetColumnMapper() core.IMapper { - return engine.ColumnMapper -} - -// GetTableMapper returns the table name mapper -func (engine *Engine) GetTableMapper() core.IMapper { - return engine.TableMapper -} - -// GetTZLocation returns time zone of the application -func (engine *Engine) GetTZLocation() *time.Location { - return engine.TZLocation -} - -// SetTZLocation sets time zone of the application -func (engine *Engine) SetTZLocation(tz *time.Location) { - engine.TZLocation = tz -} - -// GetTZDatabase returns time zone of the database -func (engine *Engine) GetTZDatabase() *time.Location { - return engine.DatabaseTZ -} - -// SetTZDatabase sets time zone of the database -func (engine *Engine) SetTZDatabase(tz *time.Location) { - engine.DatabaseTZ = tz -} - -// SetSchema sets the schema of database -func (engine *Engine) SetSchema(schema string) { - engine.dialect.URI().Schema = schema -} - -// Unscoped always disable struct tag "deleted" -func (engine *Engine) Unscoped() *Session { - session := engine.NewSession() - session.isAutoClose = true - return session.Unscoped() -} diff --git a/pkg/util/xorm/helpers.go b/pkg/util/xorm/helpers.go index aadeb6dc08d..d5ce43cc7ce 100644 --- a/pkg/util/xorm/helpers.go +++ b/pkg/util/xorm/helpers.go @@ -5,116 +5,12 @@ package xorm import ( - "errors" "fmt" "reflect" "sort" - "strconv" "strings" - - "xorm.io/core" ) -// str2PK convert string value to primary key value according to tp -func str2PKValue(s string, tp reflect.Type) (reflect.Value, error) { - var err error - var result interface{} - var defReturn = reflect.Zero(tp) - - switch tp.Kind() { - case reflect.Int: - result, err = strconv.Atoi(s) - if err != nil { - return defReturn, fmt.Errorf("convert %s as int: %s", s, err.Error()) - } - case reflect.Int8: - x, err := strconv.Atoi(s) - if err != nil { - return defReturn, fmt.Errorf("convert %s as int8: %s", s, err.Error()) - } - result = int8(x) - case reflect.Int16: - x, err := strconv.Atoi(s) - if err != nil { - return defReturn, fmt.Errorf("convert %s as int16: %s", s, err.Error()) - } - result = int16(x) - case reflect.Int32: - x, err := strconv.Atoi(s) - if err != nil { - return defReturn, fmt.Errorf("convert %s as int32: %s", s, err.Error()) - } - result = int32(x) - case reflect.Int64: - result, err = strconv.ParseInt(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as int64: %s", s, err.Error()) - } - case reflect.Uint: - x, err := strconv.ParseUint(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as uint: %s", s, err.Error()) - } - result = uint(x) - case reflect.Uint8: - x, err := strconv.ParseUint(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as uint8: %s", s, err.Error()) - } - result = uint8(x) - case reflect.Uint16: - x, err := strconv.ParseUint(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as uint16: %s", s, err.Error()) - } - result = uint16(x) - case reflect.Uint32: - x, err := strconv.ParseUint(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as uint32: %s", s, err.Error()) - } - result = uint32(x) - case reflect.Uint64: - result, err = strconv.ParseUint(s, 10, 64) - if err != nil { - return defReturn, fmt.Errorf("convert %s as uint64: %s", s, err.Error()) - } - case reflect.String: - result = s - default: - return defReturn, errors.New("unsupported convert type") - } - return reflect.ValueOf(result).Convert(tp), nil -} - -func str2PK(s string, tp reflect.Type) (interface{}, error) { - v, err := str2PKValue(s, tp) - if err != nil { - return nil, err - } - return v.Interface(), nil -} - -func splitTag(tag string) (tags []string) { - tag = strings.TrimSpace(tag) - var hasQuote = false - var lastIdx = 0 - for i, t := range tag { - if t == '\'' { - hasQuote = !hasQuote - } else if t == ' ' { - if lastIdx < i && !hasQuote { - tags = append(tags, strings.TrimSpace(tag[lastIdx:i])) - lastIdx = i + 1 - } - } - } - if lastIdx < len(tag) { - tags = append(tags, strings.TrimSpace(tag[lastIdx:])) - } - return -} - type zeroable interface { IsZero() bool } @@ -190,6 +86,26 @@ func isStructZero(v reflect.Value) bool { return true } +func splitTag(tag string) (tags []string) { + tag = strings.TrimSpace(tag) + var hasQuote = false + var lastIdx = 0 + for i, t := range tag { + if t == '\'' { + hasQuote = !hasQuote + } else if t == ' ' { + if lastIdx < i && !hasQuote { + tags = append(tags, strings.TrimSpace(tag[lastIdx:i])) + lastIdx = i + 1 + } + } + } + if lastIdx < len(tag) { + tags = append(tags, strings.TrimSpace(tag[lastIdx:])) + } + return +} + func isArrayValueZero(v reflect.Value) bool { if !v.IsValid() || v.Len() == 0 { return true @@ -249,60 +165,10 @@ func int64ToInt(id int64, tp reflect.Type) interface{} { return int64ToIntValue(id, tp).Interface() } -func isPKZero(pk core.PK) bool { - for _, k := range pk { - if isZero(k) { - return true - } - } - return false -} - -func indexNoCase(s, sep string) int { - return strings.Index(strings.ToLower(s), strings.ToLower(sep)) -} - -func splitNoCase(s, sep string) []string { - idx := indexNoCase(s, sep) - if idx < 0 { - return []string{s} - } - return strings.Split(s, s[idx:idx+len(sep)]) -} - -func splitNNoCase(s, sep string, n int) []string { - idx := indexNoCase(s, sep) - if idx < 0 { - return []string{s} - } - return strings.SplitN(s, s[idx:idx+len(sep)], n) -} - -func makeArray(elem string, count int) []string { - res := make([]string, count) - for i := 0; i < count; i++ { - res[i] = elem - } - return res -} - func rValue(bean interface{}) reflect.Value { return reflect.Indirect(reflect.ValueOf(bean)) } -func rType(bean interface{}) reflect.Type { - sliceValue := reflect.Indirect(reflect.ValueOf(bean)) - // return reflect.TypeOf(sliceValue.Interface()) - return sliceValue.Type() -} - -func structName(v reflect.Type) string { - for v.Kind() == reflect.Ptr { - v = v.Elem() - } - return v.Name() -} - func sliceEq(left, right []string) bool { if len(left) != len(right) { return false diff --git a/pkg/util/xorm/interface.go b/pkg/util/xorm/interface.go deleted file mode 100644 index 4ef7fb033bc..00000000000 --- a/pkg/util/xorm/interface.go +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright 2017 The Xorm Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package xorm - -import ( - "database/sql" - "reflect" - "time" - - "xorm.io/core" -) - -// Interface defines the interface which Engine and Session will implementate. -type Interface interface { - AllCols() Interface - Alias(alias string) Interface - Asc(colNames ...string) Interface - BufferSize(size int) Interface - Cols(columns ...string) Interface - Count(...interface{}) (int64, error) - CreateIndexes(bean interface{}) error - CreateUniques(bean interface{}) error - Decr(column string, arg ...interface{}) Interface - Desc(...string) Interface - Delete(interface{}) (int64, error) - Distinct(columns ...string) Interface - DropIndexes(bean interface{}) error - Exec(sqlOrArgs ...interface{}) (sql.Result, error) - Exist(bean ...interface{}) (bool, error) - Find(interface{}, ...interface{}) error - FindAndCount(interface{}, ...interface{}) (int64, error) - Get(interface{}) (bool, error) - GroupBy(keys string) Interface - ID(interface{}) Interface - In(string, ...interface{}) Interface - Incr(column string, arg ...interface{}) Interface - Insert(...interface{}) (int64, error) - InsertOne(interface{}) (int64, error) - IsTableEmpty(bean interface{}) (bool, error) - IsTableExist(beanOrTableName interface{}) (bool, error) - Iterate(interface{}, IterFunc) error - Limit(int, ...int) Interface - MustCols(columns ...string) Interface - NoAutoCondition(...bool) Interface - NotIn(string, ...interface{}) Interface - Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session - Omit(columns ...string) Interface - OrderBy(order string) Interface - Ping() error - Query(sqlOrArgs ...interface{}) (resultsSlice []map[string][]byte, err error) - QueryInterface(sqlOrArgs ...interface{}) ([]map[string]interface{}, error) - QueryString(sqlOrArgs ...interface{}) ([]map[string]string, error) - Rows(bean interface{}) (*Rows, error) - SetExpr(string, interface{}) Interface - SQL(interface{}, ...interface{}) Interface - Sum(bean interface{}, colName string) (float64, error) - SumInt(bean interface{}, colName string) (int64, error) - Sums(bean interface{}, colNames ...string) ([]float64, error) - SumsInt(bean interface{}, colNames ...string) ([]int64, error) - Table(tableNameOrBean interface{}) Interface - Unscoped() Interface - Update(bean interface{}, condiBeans ...interface{}) (int64, error) - UseBool(...string) Interface - Where(interface{}, ...interface{}) Interface -} - -// EngineInterface defines the interface which Engine will implementate. -type EngineInterface interface { - Interface - - Before(func(interface{})) Interface - Charset(charset string) Interface - CreateTables(...interface{}) error - DBMetas() ([]*core.Table, error) - Dialect() core.Dialect - DropTables(...interface{}) error - GetColumnMapper() core.IMapper - GetTableMapper() core.IMapper - GetTZDatabase() *time.Location - GetTZLocation() *time.Location - NewSession() Interface - NoAutoTime() Interface - Quote(string) string - SetConnMaxLifetime(time.Duration) - SetColumnMapper(core.IMapper) - SetLogger(logger core.ILogger) - SetMapper(core.IMapper) - SetMaxOpenConns(int) - SetMaxIdleConns(int) - SetSchema(string) - SetTableMapper(core.IMapper) - SetTZDatabase(tz *time.Location) - SetTZLocation(tz *time.Location) - ShowExecTime(...bool) - ShowSQL(show ...bool) - Sync(...interface{}) error - Sync2(...interface{}) error - StoreEngine(storeEngine string) Interface - TableName(interface{}, ...bool) string - UnMapType(reflect.Type) -} diff --git a/pkg/util/xorm/logger.go b/pkg/util/xorm/logger.go index 7b26e77f3bc..22f208c1d65 100644 --- a/pkg/util/xorm/logger.go +++ b/pkg/util/xorm/logger.go @@ -78,22 +78,12 @@ var _ core.ILogger = &SimpleLogger{} // NewSimpleLogger use a special io.Writer as logger output func NewSimpleLogger(out io.Writer) *SimpleLogger { - return NewSimpleLogger2(out, DEFAULT_LOG_PREFIX, DEFAULT_LOG_FLAG) -} - -// NewSimpleLogger2 let you customrize your logger prefix and flag -func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger { - return NewSimpleLogger3(out, prefix, flag, DEFAULT_LOG_LEVEL) -} - -// NewSimpleLogger3 let you customrize your logger prefix and flag and logLevel -func NewSimpleLogger3(out io.Writer, prefix string, flag int, l core.LogLevel) *SimpleLogger { return &SimpleLogger{ - DEBUG: log.New(out, fmt.Sprintf("%s [debug] ", prefix), flag), - ERR: log.New(out, fmt.Sprintf("%s [error] ", prefix), flag), - INFO: log.New(out, fmt.Sprintf("%s [info] ", prefix), flag), - WARN: log.New(out, fmt.Sprintf("%s [warn] ", prefix), flag), - level: l, + DEBUG: log.New(out, fmt.Sprintf("%s [debug] ", DEFAULT_LOG_PREFIX), DEFAULT_LOG_FLAG), + ERR: log.New(out, fmt.Sprintf("%s [error] ", DEFAULT_LOG_PREFIX), DEFAULT_LOG_FLAG), + INFO: log.New(out, fmt.Sprintf("%s [info] ", DEFAULT_LOG_PREFIX), DEFAULT_LOG_FLAG), + WARN: log.New(out, fmt.Sprintf("%s [warn] ", DEFAULT_LOG_PREFIX), DEFAULT_LOG_FLAG), + level: DEFAULT_LOG_LEVEL, } } @@ -102,7 +92,6 @@ func (s *SimpleLogger) Error(v ...interface{}) { if s.level <= core.LOG_ERR { s.ERR.Output(2, fmt.Sprint(v...)) } - return } // Errorf implement core.ILogger @@ -110,7 +99,6 @@ func (s *SimpleLogger) Errorf(format string, v ...interface{}) { if s.level <= core.LOG_ERR { s.ERR.Output(2, fmt.Sprintf(format, v...)) } - return } // Debug implement core.ILogger @@ -118,7 +106,6 @@ func (s *SimpleLogger) Debug(v ...interface{}) { if s.level <= core.LOG_DEBUG { s.DEBUG.Output(2, fmt.Sprint(v...)) } - return } // Debugf implement core.ILogger @@ -126,7 +113,6 @@ func (s *SimpleLogger) Debugf(format string, v ...interface{}) { if s.level <= core.LOG_DEBUG { s.DEBUG.Output(2, fmt.Sprintf(format, v...)) } - return } // Info implement core.ILogger @@ -134,7 +120,6 @@ func (s *SimpleLogger) Info(v ...interface{}) { if s.level <= core.LOG_INFO { s.INFO.Output(2, fmt.Sprint(v...)) } - return } // Infof implement core.ILogger @@ -142,7 +127,6 @@ func (s *SimpleLogger) Infof(format string, v ...interface{}) { if s.level <= core.LOG_INFO { s.INFO.Output(2, fmt.Sprintf(format, v...)) } - return } // Warn implement core.ILogger @@ -150,7 +134,6 @@ func (s *SimpleLogger) Warn(v ...interface{}) { if s.level <= core.LOG_WARNING { s.WARN.Output(2, fmt.Sprint(v...)) } - return } // Warnf implement core.ILogger @@ -158,7 +141,6 @@ func (s *SimpleLogger) Warnf(format string, v ...interface{}) { if s.level <= core.LOG_WARNING { s.WARN.Output(2, fmt.Sprintf(format, v...)) } - return } // Level implement core.ILogger @@ -169,7 +151,6 @@ func (s *SimpleLogger) Level() core.LogLevel { // SetLevel implement core.ILogger func (s *SimpleLogger) SetLevel(l core.LogLevel) { s.level = l - return } // ShowSQL implement core.ILogger diff --git a/pkg/util/xorm/session_cols.go b/pkg/util/xorm/session_cols.go index 1558074f3de..7d93323e47f 100644 --- a/pkg/util/xorm/session_cols.go +++ b/pkg/util/xorm/session_cols.go @@ -76,24 +76,6 @@ func col2NewCols(columns ...string) []string { return newColumns } -// Incr provides a query string like "count = count + 1" -func (session *Session) Incr(column string, arg ...interface{}) *Session { - session.statement.Incr(column, arg...) - return session -} - -// Decr provides a query string like "count = count - 1" -func (session *Session) Decr(column string, arg ...interface{}) *Session { - session.statement.Decr(column, arg...) - return session -} - -// SetExpr provides a query string like "column = {expression}" -func (session *Session) SetExpr(column string, expression interface{}) *Session { - session.statement.SetExpr(column, expression) - return session -} - // Select provides some columns to special func (session *Session) Select(str string) *Session { session.statement.Select(str) @@ -136,21 +118,8 @@ func (session *Session) Distinct(columns ...string) *Session { return session } -// Omit Only not use the parameters as select or update columns -func (session *Session) Omit(columns ...string) *Session { - session.statement.Omit(columns...) - return session -} - // Nullable Set null when column is zero-value and nullable for update func (session *Session) Nullable(columns ...string) *Session { session.statement.Nullable(columns...) return session } - -// NoAutoTime means do not automatically give created field and updated field -// the current time on the current session temporarily -func (session *Session) NoAutoTime() *Session { - session.statement.UseAutoTime = false - return session -} diff --git a/pkg/util/xorm/session_find.go b/pkg/util/xorm/session_find.go index 6ae41006de2..d0f0840fd33 100644 --- a/pkg/util/xorm/session_find.go +++ b/pkg/util/xorm/session_find.go @@ -180,19 +180,6 @@ func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{}) args = session.statement.RawParams } - // if session.canCache() { - // if cacher := session.engine.getCacher(session.statement.TableName()); cacher != nil && - // !session.statement.IsDistinct && - // !session.statement.unscoped { - // err = session.cacheFind(sliceElementType, sqlStr, rowsSlicePtr, args...) - // if err != ErrCacheFailed { - // return err - // } - // err = nil // !nashtsai! reset err to nil for ErrCacheFailed - // session.engine.logger.Warn("Cache Find Failed") - // } - // } - return session.noCacheFind(table, sliceValue, sqlStr, args...) } @@ -318,206 +305,3 @@ func convertPKToValue(table *core.Table, dst interface{}, pk core.PK) error { dst = pk return nil } - -// func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr interface{}, args ...interface{}) (err error) { -// if !session.canCache() || -// indexNoCase(sqlStr, "having") != -1 || -// indexNoCase(sqlStr, "group by") != -1 { -// return ErrCacheFailed -// } - -// tableName := session.statement.TableName() -// return nil -// // cacher := session.engine.getCacher(tableName) -// // if cacher == nil { -// // return nil -// // } - -// for _, filter := range session.engine.dialect.Filters() { -// sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable) -// } - -// newsql := session.statement.convertIDSQL(sqlStr) -// if newsql == "" { -// return ErrCacheFailed -// } - -// table := session.statement.RefTable -// var cacher core.Cacher -// ids, err := core.GetCacheSql(cacher, tableName, newsql, args) -// if err != nil { -// rows, err := session.queryRows(newsql, args...) -// if err != nil { -// return err -// } -// defer rows.Close() - -// var i int -// ids = make([]core.PK, 0) -// for rows.Next() { -// i++ -// if i > 500 { -// session.engine.logger.Debug("[cacheFind] ids length > 500, no cache") -// return ErrCacheFailed -// } -// var res = make([]string, len(table.PrimaryKeys)) -// err = rows.ScanSlice(&res) -// if err != nil { -// return err -// } -// var pk core.PK = make([]interface{}, len(table.PrimaryKeys)) -// for i, col := range table.PKColumns() { -// pk[i], err = session.engine.idTypeAssertion(col, res[i]) -// if err != nil { -// return err -// } -// } - -// ids = append(ids, pk) -// } -// if rows.Err() != nil { -// return rows.Err() -// } - -// session.engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, sqlStr, newsql, args) -// err = core.PutCacheSql(cacher, ids, tableName, newsql, args) -// if err != nil { -// return err -// } -// } else { -// session.engine.logger.Debug("[cacheFind] cache hit sql:", tableName, sqlStr, newsql, args) -// } - -// sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr)) - -// ididxes := make(map[string]int) -// var ides []core.PK -// var temps = make([]interface{}, len(ids)) - -// for idx, id := range ids { -// sid, err := id.ToString() -// if err != nil { -// return err -// } -// bean := cacher.GetBean(tableName, sid) - -// // fix issue #894 -// isHit := func() (ht bool) { -// if bean == nil { -// ht = false -// return -// } -// ckb := reflect.ValueOf(bean).Elem().Type() -// ht = ckb == t -// if !ht && t.Kind() == reflect.Ptr { -// ht = t.Elem() == ckb -// } -// return -// } -// if !isHit() { -// ides = append(ides, id) -// ididxes[sid] = idx -// } else { -// session.engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean) - -// pk := session.engine.IdOf(bean) -// xid, err := pk.ToString() -// if err != nil { -// return err -// } - -// if sid != xid { -// session.engine.logger.Error("[cacheFind] error cache", xid, sid, bean) -// return ErrCacheFailed -// } -// temps[idx] = bean -// } -// } - -// if len(ides) > 0 { -// slices := reflect.New(reflect.SliceOf(t)) -// beans := slices.Interface() - -// if len(table.PrimaryKeys) == 1 { -// ff := make([]interface{}, 0, len(ides)) -// for _, ie := range ides { -// ff = append(ff, ie[0]) -// } - -// session.In("`"+table.PrimaryKeys[0]+"`", ff...) -// } else { -// for _, ie := range ides { -// cond := builder.NewCond() -// for i, name := range table.PrimaryKeys { -// cond = cond.And(builder.Eq{"`" + name + "`": ie[i]}) -// } -// session.Or(cond) -// } -// } - -// err = session.NoCache().Table(tableName).find(beans) -// if err != nil { -// return err -// } - -// vs := reflect.Indirect(reflect.ValueOf(beans)) -// for i := 0; i < vs.Len(); i++ { -// rv := vs.Index(i) -// if rv.Kind() != reflect.Ptr { -// rv = rv.Addr() -// } -// id, err := session.engine.idOfV(rv) -// if err != nil { -// return err -// } -// sid, err := id.ToString() -// if err != nil { -// return err -// } - -// bean := rv.Interface() -// temps[ididxes[sid]] = bean -// session.engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps) -// cacher.PutBean(tableName, sid, bean) -// } -// } - -// for j := 0; j < len(temps); j++ { -// bean := temps[j] -// if bean == nil { -// session.engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps) -// // return errors.New("cache error") // !nashtsai! no need to return error, but continue instead -// continue -// } -// if sliceValue.Kind() == reflect.Slice { -// if t.Kind() == reflect.Ptr { -// sliceValue.Set(reflect.Append(sliceValue, reflect.ValueOf(bean))) -// } else { -// sliceValue.Set(reflect.Append(sliceValue, reflect.Indirect(reflect.ValueOf(bean)))) -// } -// } else if sliceValue.Kind() == reflect.Map { -// var key = ids[j] -// keyType := sliceValue.Type().Key() -// var ikey interface{} -// if len(key) == 1 { -// ikey, err = str2PK(fmt.Sprintf("%v", key[0]), keyType) -// if err != nil { -// return err -// } -// } else { -// if keyType.Kind() != reflect.Slice { -// return errors.New("table have multiple primary keys, key is not core.PK or slice") -// } -// ikey = key -// } - -// if t.Kind() == reflect.Ptr { -// sliceValue.SetMapIndex(reflect.ValueOf(ikey), reflect.ValueOf(bean)) -// } else { -// sliceValue.SetMapIndex(reflect.ValueOf(ikey), reflect.Indirect(reflect.ValueOf(bean))) -// } -// } -// } - -// return nil -// } diff --git a/pkg/util/xorm/statement.go b/pkg/util/xorm/statement.go index e952f25ced7..832b412c213 100644 --- a/pkg/util/xorm/statement.go +++ b/pkg/util/xorm/statement.go @@ -99,6 +99,11 @@ func (statement *Statement) Init() { statement.lastError = nil } +var ( + ptrPkType = reflect.TypeOf(&core.PK{}) + pkType = reflect.TypeOf(core.PK{}) +) + // NoAutoCondition if you do not want convert bean's field as query condition, then use this function func (statement *Statement) NoAutoCondition(no ...bool) *Statement { statement.noAutoCondition = true diff --git a/pkg/util/xorm/transaction.go b/pkg/util/xorm/transaction.go deleted file mode 100644 index 4104103fd53..00000000000 --- a/pkg/util/xorm/transaction.go +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2018 The Xorm Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package xorm - -// Transaction Execute sql wrapped in a transaction(abbr as tx), tx will automatic commit if no errors occurred -func (engine *Engine) Transaction(f func(*Session) (interface{}, error)) (interface{}, error) { - session := engine.NewSession() - defer session.Close() - - if err := session.Begin(); err != nil { - return nil, err - } - - result, err := f(session) - if err != nil { - return nil, err - } - - if err := session.Commit(); err != nil { - return nil, err - } - - return result, nil -} diff --git a/pkg/util/xorm/types.go b/pkg/util/xorm/types.go deleted file mode 100644 index c76a5460651..00000000000 --- a/pkg/util/xorm/types.go +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright 2017 The Xorm Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package xorm - -import ( - "reflect" - - "xorm.io/core" -) - -var ( - ptrPkType = reflect.TypeOf(&core.PK{}) - pkType = reflect.TypeOf(core.PK{}) -)