ipbl/vendor/xorm.io/xorm/internal/statements/query.go

500 lines
12 KiB
Go
Raw Normal View History

2021-11-07 20:44:48 +01:00
// Copyright 2019 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 statements
import (
"errors"
"fmt"
"reflect"
"strings"
"xorm.io/builder"
2022-06-05 23:07:32 +02:00
"xorm.io/xorm/internal/utils"
2021-11-07 20:44:48 +01:00
"xorm.io/xorm/schemas"
)
// GenQuerySQL generate query SQL
func (statement *Statement) GenQuerySQL(sqlOrArgs ...interface{}) (string, []interface{}, error) {
if len(sqlOrArgs) > 0 {
return statement.ConvertSQLOrArgs(sqlOrArgs...)
}
if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil
}
if len(statement.TableName()) <= 0 {
return "", nil, ErrTableNotFound
}
2022-06-05 23:07:32 +02:00
columnStr := statement.ColumnStr()
2021-11-07 20:44:48 +01:00
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {
if statement.JoinStr == "" {
if columnStr == "" {
if statement.GroupByStr != "" {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
} else {
columnStr = statement.genColumnStr()
}
}
} else {
if columnStr == "" {
if statement.GroupByStr != "" {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
} else {
columnStr = "*"
}
}
}
if columnStr == "" {
columnStr = "*"
}
}
if err := statement.ProcessIDParam(); err != nil {
return "", nil, err
}
2022-06-05 23:07:32 +02:00
return statement.genSelectSQL(columnStr, true, true)
2021-11-07 20:44:48 +01:00
}
// GenSumSQL generates sum SQL
func (statement *Statement) GenSumSQL(bean interface{}, columns ...string) (string, []interface{}, error) {
if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil
}
2022-06-05 23:07:32 +02:00
if err := statement.SetRefBean(bean); err != nil {
return "", nil, err
}
2021-11-07 20:44:48 +01:00
2022-06-05 23:07:32 +02:00
sumStrs := make([]string, 0, len(columns))
2021-11-07 20:44:48 +01:00
for _, colName := range columns {
if !strings.Contains(colName, " ") && !strings.Contains(colName, "(") {
colName = statement.quote(colName)
} else {
colName = statement.ReplaceQuote(colName)
}
sumStrs = append(sumStrs, fmt.Sprintf("COALESCE(sum(%s),0)", colName))
}
sumSelect := strings.Join(sumStrs, ", ")
2022-06-05 23:07:32 +02:00
if err := statement.MergeConds(bean); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
2022-06-05 23:07:32 +02:00
return statement.genSelectSQL(sumSelect, true, true)
2021-11-07 20:44:48 +01:00
}
// GenGetSQL generates Get SQL
func (statement *Statement) GenGetSQL(bean interface{}) (string, []interface{}, error) {
var isStruct bool
if bean != nil {
v := rValue(bean)
isStruct = v.Kind() == reflect.Struct
if isStruct {
2022-06-05 23:07:32 +02:00
if err := statement.SetRefBean(bean); err != nil {
return "", nil, err
}
2021-11-07 20:44:48 +01:00
}
}
2022-06-05 23:07:32 +02:00
columnStr := statement.ColumnStr()
2021-11-07 20:44:48 +01:00
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {
// TODO: always generate column names, not use * even if join
if len(statement.JoinStr) == 0 {
if len(columnStr) == 0 {
if len(statement.GroupByStr) > 0 {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
} else {
columnStr = statement.genColumnStr()
}
}
} else {
if len(columnStr) == 0 {
if len(statement.GroupByStr) > 0 {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
}
}
}
}
if len(columnStr) == 0 {
columnStr = "*"
}
if isStruct {
2022-06-05 23:07:32 +02:00
if err := statement.MergeConds(bean); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
} else {
if err := statement.ProcessIDParam(); err != nil {
return "", nil, err
}
}
2022-06-05 23:07:32 +02:00
return statement.genSelectSQL(columnStr, true, true)
2021-11-07 20:44:48 +01:00
}
// GenCountSQL generates the SQL for counting
func (statement *Statement) GenCountSQL(beans ...interface{}) (string, []interface{}, error) {
if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil
}
var condArgs []interface{}
var err error
if len(beans) > 0 {
2022-06-05 23:07:32 +02:00
if err := statement.SetRefBean(beans[0]); err != nil {
return "", nil, err
}
if err := statement.MergeConds(beans[0]); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
}
2022-06-05 23:07:32 +02:00
selectSQL := statement.SelectStr
2021-11-07 20:44:48 +01:00
if len(selectSQL) <= 0 {
if statement.IsDistinct {
selectSQL = fmt.Sprintf("count(DISTINCT %s)", statement.ColumnStr())
} else if statement.ColumnStr() != "" {
selectSQL = fmt.Sprintf("count(%s)", statement.ColumnStr())
} else {
selectSQL = "count(*)"
}
}
var subQuerySelect string
if statement.GroupByStr != "" {
subQuerySelect = statement.GroupByStr
} else {
subQuerySelect = selectSQL
}
sqlStr, condArgs, err := statement.genSelectSQL(subQuerySelect, false, false)
if err != nil {
return "", nil, err
}
if statement.GroupByStr != "" {
sqlStr = fmt.Sprintf("SELECT %s FROM (%s) sub", selectSQL, sqlStr)
}
2022-06-05 23:07:32 +02:00
return sqlStr, condArgs, nil
}
func (statement *Statement) writeFrom(w builder.Writer) error {
if _, err := fmt.Fprint(w, " FROM "); err != nil {
return err
}
if err := statement.writeTableName(w); err != nil {
return err
}
if err := statement.writeAlias(w); err != nil {
return err
}
return statement.writeJoin(w)
}
func (statement *Statement) writeLimitOffset(w builder.Writer) error {
if statement.Start > 0 {
if statement.LimitN != nil {
_, err := fmt.Fprintf(w, " LIMIT %v OFFSET %v", *statement.LimitN, statement.Start)
return err
}
_, err := fmt.Fprintf(w, " LIMIT 0 OFFSET %v", statement.Start)
return err
}
if statement.LimitN != nil {
_, err := fmt.Fprint(w, " LIMIT ", *statement.LimitN)
return err
}
// no limit statement
return nil
2021-11-07 20:44:48 +01:00
}
func (statement *Statement) genSelectSQL(columnStr string, needLimit, needOrderBy bool) (string, []interface{}, error) {
var (
2022-06-05 23:07:32 +02:00
distinct string
dialect = statement.dialect
top, whereStr string
mssqlCondi = builder.NewWriter()
2021-11-07 20:44:48 +01:00
)
2022-06-05 23:07:32 +02:00
2021-11-07 20:44:48 +01:00
if statement.IsDistinct && !strings.HasPrefix(columnStr, "count") {
distinct = "DISTINCT "
}
2022-06-05 23:07:32 +02:00
condWriter := builder.NewWriter()
if err := statement.cond.WriteTo(statement.QuoteReplacer(condWriter)); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
2022-06-05 23:07:32 +02:00
if condWriter.Len() > 0 {
whereStr = " WHERE "
2021-11-07 20:44:48 +01:00
}
pLimitN := statement.LimitN
if dialect.URI().DBType == schemas.MSSQL {
if pLimitN != nil {
LimitNValue := *pLimitN
top = fmt.Sprintf("TOP %d ", LimitNValue)
}
if statement.Start > 0 {
if statement.RefTable == nil {
return "", nil, errors.New("Unsupported query limit without reference table")
}
var column string
if len(statement.RefTable.PKColumns()) == 0 {
for _, index := range statement.RefTable.Indexes {
if len(index.Cols) == 1 {
column = index.Cols[0]
break
}
}
if len(column) == 0 {
column = statement.RefTable.ColumnsSeq()[0]
}
} else {
column = statement.RefTable.PKColumns()[0].Name
}
if statement.needTableName() {
if len(statement.TableAlias) > 0 {
2022-06-05 23:07:32 +02:00
column = fmt.Sprintf("%s.%s", statement.TableAlias, column)
2021-11-07 20:44:48 +01:00
} else {
2022-06-05 23:07:32 +02:00
column = fmt.Sprintf("%s.%s", statement.TableName(), column)
2021-11-07 20:44:48 +01:00
}
}
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprintf(mssqlCondi, "(%s NOT IN (SELECT TOP %d %s",
column, statement.Start, column); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
if err := statement.writeFrom(mssqlCondi); err != nil {
return "", nil, err
}
if whereStr != "" {
if _, err := fmt.Fprint(mssqlCondi, whereStr); err != nil {
return "", nil, err
}
if err := utils.WriteBuilder(mssqlCondi, statement.QuoteReplacer(condWriter)); err != nil {
return "", nil, err
}
}
if needOrderBy {
if err := statement.WriteOrderBy(mssqlCondi); err != nil {
return "", nil, err
}
}
if err := statement.WriteGroupBy(mssqlCondi); err != nil {
return "", nil, err
}
if _, err := fmt.Fprint(mssqlCondi, "))"); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
}
}
2022-06-05 23:07:32 +02:00
buf := builder.NewWriter()
if _, err := fmt.Fprintf(buf, "SELECT %v%v%v", distinct, top, columnStr); err != nil {
return "", nil, err
}
if err := statement.writeFrom(buf); err != nil {
return "", nil, err
}
if whereStr != "" {
if _, err := fmt.Fprint(buf, whereStr); err != nil {
return "", nil, err
}
if err := utils.WriteBuilder(buf, statement.QuoteReplacer(condWriter)); err != nil {
return "", nil, err
}
}
if mssqlCondi.Len() > 0 {
2021-11-07 20:44:48 +01:00
if len(whereStr) > 0 {
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprint(buf, " AND "); err != nil {
return "", nil, err
}
2021-11-07 20:44:48 +01:00
} else {
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprint(buf, " WHERE "); err != nil {
return "", nil, err
}
}
if err := utils.WriteBuilder(buf, mssqlCondi); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
}
2022-06-05 23:07:32 +02:00
if err := statement.WriteGroupBy(buf); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
if err := statement.writeHaving(buf); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
if needOrderBy {
if err := statement.WriteOrderBy(buf); err != nil {
return "", nil, err
}
2021-11-07 20:44:48 +01:00
}
if needLimit {
if dialect.URI().DBType != schemas.MSSQL && dialect.URI().DBType != schemas.ORACLE {
2022-06-05 23:07:32 +02:00
if err := statement.writeLimitOffset(buf); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
} else if dialect.URI().DBType == schemas.ORACLE {
2022-06-05 23:07:32 +02:00
if pLimitN != nil {
2021-11-07 20:44:48 +01:00
oldString := buf.String()
buf.Reset()
rawColStr := columnStr
if rawColStr == "*" {
rawColStr = "at.*"
}
2022-06-05 23:07:32 +02:00
fmt.Fprintf(buf, "SELECT %v FROM (SELECT %v,ROWNUM RN FROM (%v) at WHERE ROWNUM <= %d) aat WHERE RN > %d",
2021-11-07 20:44:48 +01:00
columnStr, rawColStr, oldString, statement.Start+*pLimitN, statement.Start)
}
}
}
if statement.IsForUpdate {
2022-06-05 23:07:32 +02:00
return dialect.ForUpdateSQL(buf.String()), buf.Args(), nil
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
return buf.String(), buf.Args(), nil
2021-11-07 20:44:48 +01:00
}
// GenExistSQL generates Exist SQL
func (statement *Statement) GenExistSQL(bean ...interface{}) (string, []interface{}, error) {
if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil
}
var b interface{}
if len(bean) > 0 {
b = bean[0]
beanValue := reflect.ValueOf(bean[0])
if beanValue.Kind() != reflect.Ptr {
return "", nil, errors.New("needs a pointer")
}
if beanValue.Elem().Kind() == reflect.Struct {
if err := statement.SetRefBean(bean[0]); err != nil {
return "", nil, err
}
}
}
tableName := statement.TableName()
if len(tableName) <= 0 {
return "", nil, ErrTableNotFound
}
2022-06-05 23:07:32 +02:00
if statement.RefTable != nil {
return statement.Limit(1).GenGetSQL(b)
}
2021-11-07 20:44:48 +01:00
2022-06-05 23:07:32 +02:00
tableName = statement.quote(tableName)
buf := builder.NewWriter()
if statement.dialect.URI().DBType == schemas.MSSQL {
if _, err := fmt.Fprintf(buf, "SELECT TOP 1 * FROM %s", tableName); err != nil {
return "", nil, err
}
if err := statement.writeJoin(buf); err != nil {
return "", nil, err
}
2021-11-07 20:44:48 +01:00
if statement.Conds().IsValid() {
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprintf(buf, " WHERE "); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
2022-06-05 23:07:32 +02:00
if err := statement.Conds().WriteTo(statement.QuoteReplacer(buf)); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
}
} else if statement.dialect.URI().DBType == schemas.ORACLE {
if _, err := fmt.Fprintf(buf, "SELECT * FROM %s", tableName); err != nil {
return "", nil, err
}
if err := statement.writeJoin(buf); err != nil {
return "", nil, err
}
if _, err := fmt.Fprintf(buf, " WHERE "); err != nil {
return "", nil, err
}
if statement.Conds().IsValid() {
if err := statement.Conds().WriteTo(statement.QuoteReplacer(buf)); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprintf(buf, " AND "); err != nil {
return "", nil, err
}
}
if _, err := fmt.Fprintf(buf, "ROWNUM=1"); err != nil {
return "", nil, err
2021-11-07 20:44:48 +01:00
}
} else {
2022-06-05 23:07:32 +02:00
if _, err := fmt.Fprintf(buf, "SELECT 1 FROM %s", tableName); err != nil {
return "", nil, err
}
if err := statement.writeJoin(buf); err != nil {
return "", nil, err
}
if statement.Conds().IsValid() {
if _, err := fmt.Fprintf(buf, " WHERE "); err != nil {
return "", nil, err
}
if err := statement.Conds().WriteTo(statement.QuoteReplacer(buf)); err != nil {
return "", nil, err
}
}
if _, err := fmt.Fprintf(buf, " LIMIT 1"); err != nil {
2021-11-07 20:44:48 +01:00
return "", nil, err
}
}
2022-06-05 23:07:32 +02:00
return buf.String(), buf.Args(), nil
2021-11-07 20:44:48 +01:00
}
// GenFindSQL generates Find SQL
func (statement *Statement) GenFindSQL(autoCond builder.Cond) (string, []interface{}, error) {
if statement.RawSQL != "" {
return statement.GenRawSQL(), statement.RawParams, nil
}
if len(statement.TableName()) <= 0 {
return "", nil, ErrTableNotFound
}
2022-06-05 23:07:32 +02:00
columnStr := statement.ColumnStr()
2021-11-07 20:44:48 +01:00
if len(statement.SelectStr) > 0 {
columnStr = statement.SelectStr
} else {
if statement.JoinStr == "" {
if columnStr == "" {
if statement.GroupByStr != "" {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
} else {
columnStr = statement.genColumnStr()
}
}
} else {
if columnStr == "" {
if statement.GroupByStr != "" {
columnStr = statement.quoteColumnStr(statement.GroupByStr)
} else {
columnStr = "*"
}
}
}
if columnStr == "" {
columnStr = "*"
}
}
statement.cond = statement.cond.And(autoCond)
2022-06-05 23:07:32 +02:00
return statement.genSelectSQL(columnStr, true, true)
2021-11-07 20:44:48 +01:00
}