repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
go-xorm/xorm | tag.go | LocalTagHandler | func LocalTagHandler(ctx *tagContext) error {
if len(ctx.params) == 0 {
ctx.col.TimeZone = time.Local
} else {
var err error
ctx.col.TimeZone, err = time.LoadLocation(ctx.params[0])
if err != nil {
return err
}
}
return nil
} | go | func LocalTagHandler(ctx *tagContext) error {
if len(ctx.params) == 0 {
ctx.col.TimeZone = time.Local
} else {
var err error
ctx.col.TimeZone, err = time.LoadLocation(ctx.params[0])
if err != nil {
return err
}
}
return nil
} | [
"func",
"LocalTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
"==",
"0",
"{",
"ctx",
".",
"col",
".",
"TimeZone",
"=",
"time",
".",
"Local",
"\n",
"}",
"else",
"{",
"var",
"err",
"error",
"\n",
"ctx",
".",
"col",
".",
"TimeZone",
",",
"err",
"=",
"time",
".",
"LoadLocation",
"(",
"ctx",
".",
"params",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // LocalTagHandler describes local tag handler | [
"LocalTagHandler",
"describes",
"local",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L151-L162 | train |
go-xorm/xorm | tag.go | IndexTagHandler | func IndexTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.indexNames[ctx.params[0]] = core.IndexType
} else {
ctx.isIndex = true
}
return nil
} | go | func IndexTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.indexNames[ctx.params[0]] = core.IndexType
} else {
ctx.isIndex = true
}
return nil
} | [
"func",
"IndexTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
">",
"0",
"{",
"ctx",
".",
"indexNames",
"[",
"ctx",
".",
"params",
"[",
"0",
"]",
"]",
"=",
"core",
".",
"IndexType",
"\n",
"}",
"else",
"{",
"ctx",
".",
"isIndex",
"=",
"true",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // IndexTagHandler describes index tag handler | [
"IndexTagHandler",
"describes",
"index",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L177-L184 | train |
go-xorm/xorm | tag.go | UniqueTagHandler | func UniqueTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.indexNames[ctx.params[0]] = core.UniqueType
} else {
ctx.isUnique = true
}
return nil
} | go | func UniqueTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.indexNames[ctx.params[0]] = core.UniqueType
} else {
ctx.isUnique = true
}
return nil
} | [
"func",
"UniqueTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
">",
"0",
"{",
"ctx",
".",
"indexNames",
"[",
"ctx",
".",
"params",
"[",
"0",
"]",
"]",
"=",
"core",
".",
"UniqueType",
"\n",
"}",
"else",
"{",
"ctx",
".",
"isUnique",
"=",
"true",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UniqueTagHandler describes unique tag handler | [
"UniqueTagHandler",
"describes",
"unique",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L187-L194 | train |
go-xorm/xorm | tag.go | CommentTagHandler | func CommentTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.col.Comment = strings.Trim(ctx.params[0], "' ")
}
return nil
} | go | func CommentTagHandler(ctx *tagContext) error {
if len(ctx.params) > 0 {
ctx.col.Comment = strings.Trim(ctx.params[0], "' ")
}
return nil
} | [
"func",
"CommentTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
">",
"0",
"{",
"ctx",
".",
"col",
".",
"Comment",
"=",
"strings",
".",
"Trim",
"(",
"ctx",
".",
"params",
"[",
"0",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CommentTagHandler add comment to column | [
"CommentTagHandler",
"add",
"comment",
"to",
"column"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L197-L202 | train |
go-xorm/xorm | tag.go | SQLTypeTagHandler | func SQLTypeTagHandler(ctx *tagContext) error {
ctx.col.SQLType = core.SQLType{Name: ctx.tagName}
if len(ctx.params) > 0 {
if ctx.tagName == core.Enum {
ctx.col.EnumOptions = make(map[string]int)
for k, v := range ctx.params {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
ctx.col.EnumOptions[v] = k
}
} else if ctx.tagName == core.Set {
ctx.col.SetOptions = make(map[string]int)
for k, v := range ctx.params {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
ctx.col.SetOptions[v] = k
}
} else {
var err error
if len(ctx.params) == 2 {
ctx.col.Length, err = strconv.Atoi(ctx.params[0])
if err != nil {
return err
}
ctx.col.Length2, err = strconv.Atoi(ctx.params[1])
if err != nil {
return err
}
} else if len(ctx.params) == 1 {
ctx.col.Length, err = strconv.Atoi(ctx.params[0])
if err != nil {
return err
}
}
}
}
return nil
} | go | func SQLTypeTagHandler(ctx *tagContext) error {
ctx.col.SQLType = core.SQLType{Name: ctx.tagName}
if len(ctx.params) > 0 {
if ctx.tagName == core.Enum {
ctx.col.EnumOptions = make(map[string]int)
for k, v := range ctx.params {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
ctx.col.EnumOptions[v] = k
}
} else if ctx.tagName == core.Set {
ctx.col.SetOptions = make(map[string]int)
for k, v := range ctx.params {
v = strings.TrimSpace(v)
v = strings.Trim(v, "'")
ctx.col.SetOptions[v] = k
}
} else {
var err error
if len(ctx.params) == 2 {
ctx.col.Length, err = strconv.Atoi(ctx.params[0])
if err != nil {
return err
}
ctx.col.Length2, err = strconv.Atoi(ctx.params[1])
if err != nil {
return err
}
} else if len(ctx.params) == 1 {
ctx.col.Length, err = strconv.Atoi(ctx.params[0])
if err != nil {
return err
}
}
}
}
return nil
} | [
"func",
"SQLTypeTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"ctx",
".",
"col",
".",
"SQLType",
"=",
"core",
".",
"SQLType",
"{",
"Name",
":",
"ctx",
".",
"tagName",
"}",
"\n",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
">",
"0",
"{",
"if",
"ctx",
".",
"tagName",
"==",
"core",
".",
"Enum",
"{",
"ctx",
".",
"col",
".",
"EnumOptions",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"ctx",
".",
"params",
"{",
"v",
"=",
"strings",
".",
"TrimSpace",
"(",
"v",
")",
"\n",
"v",
"=",
"strings",
".",
"Trim",
"(",
"v",
",",
"\"",
"\"",
")",
"\n",
"ctx",
".",
"col",
".",
"EnumOptions",
"[",
"v",
"]",
"=",
"k",
"\n",
"}",
"\n",
"}",
"else",
"if",
"ctx",
".",
"tagName",
"==",
"core",
".",
"Set",
"{",
"ctx",
".",
"col",
".",
"SetOptions",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"ctx",
".",
"params",
"{",
"v",
"=",
"strings",
".",
"TrimSpace",
"(",
"v",
")",
"\n",
"v",
"=",
"strings",
".",
"Trim",
"(",
"v",
",",
"\"",
"\"",
")",
"\n",
"ctx",
".",
"col",
".",
"SetOptions",
"[",
"v",
"]",
"=",
"k",
"\n",
"}",
"\n",
"}",
"else",
"{",
"var",
"err",
"error",
"\n",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
"==",
"2",
"{",
"ctx",
".",
"col",
".",
"Length",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"ctx",
".",
"params",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ctx",
".",
"col",
".",
"Length2",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"ctx",
".",
"params",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"if",
"len",
"(",
"ctx",
".",
"params",
")",
"==",
"1",
"{",
"ctx",
".",
"col",
".",
"Length",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"ctx",
".",
"params",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SQLTypeTagHandler describes SQL Type tag handler | [
"SQLTypeTagHandler",
"describes",
"SQL",
"Type",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L205-L242 | train |
go-xorm/xorm | tag.go | ExtendsTagHandler | func ExtendsTagHandler(ctx *tagContext) error {
var fieldValue = ctx.fieldValue
switch fieldValue.Kind() {
case reflect.Ptr:
f := fieldValue.Type().Elem()
if f.Kind() == reflect.Struct {
fieldPtr := fieldValue
fieldValue = fieldValue.Elem()
if !fieldValue.IsValid() || fieldPtr.IsNil() {
fieldValue = reflect.New(f).Elem()
}
}
fallthrough
case reflect.Struct:
parentTable, err := ctx.engine.mapType(fieldValue)
if err != nil {
return err
}
for _, col := range parentTable.Columns() {
col.FieldName = fmt.Sprintf("%v.%v", ctx.col.FieldName, col.FieldName)
ctx.table.AddColumn(col)
for indexName, indexType := range col.Indexes {
addIndex(indexName, ctx.table, col, indexType)
}
}
default:
//TODO: warning
}
return nil
} | go | func ExtendsTagHandler(ctx *tagContext) error {
var fieldValue = ctx.fieldValue
switch fieldValue.Kind() {
case reflect.Ptr:
f := fieldValue.Type().Elem()
if f.Kind() == reflect.Struct {
fieldPtr := fieldValue
fieldValue = fieldValue.Elem()
if !fieldValue.IsValid() || fieldPtr.IsNil() {
fieldValue = reflect.New(f).Elem()
}
}
fallthrough
case reflect.Struct:
parentTable, err := ctx.engine.mapType(fieldValue)
if err != nil {
return err
}
for _, col := range parentTable.Columns() {
col.FieldName = fmt.Sprintf("%v.%v", ctx.col.FieldName, col.FieldName)
ctx.table.AddColumn(col)
for indexName, indexType := range col.Indexes {
addIndex(indexName, ctx.table, col, indexType)
}
}
default:
//TODO: warning
}
return nil
} | [
"func",
"ExtendsTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"var",
"fieldValue",
"=",
"ctx",
".",
"fieldValue",
"\n",
"switch",
"fieldValue",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Ptr",
":",
"f",
":=",
"fieldValue",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"f",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"{",
"fieldPtr",
":=",
"fieldValue",
"\n",
"fieldValue",
"=",
"fieldValue",
".",
"Elem",
"(",
")",
"\n",
"if",
"!",
"fieldValue",
".",
"IsValid",
"(",
")",
"||",
"fieldPtr",
".",
"IsNil",
"(",
")",
"{",
"fieldValue",
"=",
"reflect",
".",
"New",
"(",
"f",
")",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"fallthrough",
"\n",
"case",
"reflect",
".",
"Struct",
":",
"parentTable",
",",
"err",
":=",
"ctx",
".",
"engine",
".",
"mapType",
"(",
"fieldValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"col",
":=",
"range",
"parentTable",
".",
"Columns",
"(",
")",
"{",
"col",
".",
"FieldName",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ctx",
".",
"col",
".",
"FieldName",
",",
"col",
".",
"FieldName",
")",
"\n",
"ctx",
".",
"table",
".",
"AddColumn",
"(",
"col",
")",
"\n",
"for",
"indexName",
",",
"indexType",
":=",
"range",
"col",
".",
"Indexes",
"{",
"addIndex",
"(",
"indexName",
",",
"ctx",
".",
"table",
",",
"col",
",",
"indexType",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"//TODO: warning",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ExtendsTagHandler describes extends tag handler | [
"ExtendsTagHandler",
"describes",
"extends",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L245-L274 | train |
go-xorm/xorm | tag.go | CacheTagHandler | func CacheTagHandler(ctx *tagContext) error {
if !ctx.hasCacheTag {
ctx.hasCacheTag = true
}
return nil
} | go | func CacheTagHandler(ctx *tagContext) error {
if !ctx.hasCacheTag {
ctx.hasCacheTag = true
}
return nil
} | [
"func",
"CacheTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"!",
"ctx",
".",
"hasCacheTag",
"{",
"ctx",
".",
"hasCacheTag",
"=",
"true",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CacheTagHandler describes cache tag handler | [
"CacheTagHandler",
"describes",
"cache",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L277-L282 | train |
go-xorm/xorm | tag.go | NoCacheTagHandler | func NoCacheTagHandler(ctx *tagContext) error {
if !ctx.hasNoCacheTag {
ctx.hasNoCacheTag = true
}
return nil
} | go | func NoCacheTagHandler(ctx *tagContext) error {
if !ctx.hasNoCacheTag {
ctx.hasNoCacheTag = true
}
return nil
} | [
"func",
"NoCacheTagHandler",
"(",
"ctx",
"*",
"tagContext",
")",
"error",
"{",
"if",
"!",
"ctx",
".",
"hasNoCacheTag",
"{",
"ctx",
".",
"hasNoCacheTag",
"=",
"true",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // NoCacheTagHandler describes nocache tag handler | [
"NoCacheTagHandler",
"describes",
"nocache",
"tag",
"handler"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/tag.go#L285-L290 | train |
go-xorm/xorm | syslogger.go | Debug | func (s *SyslogLogger) Debug(v ...interface{}) {
s.w.Debug(fmt.Sprint(v...))
} | go | func (s *SyslogLogger) Debug(v ...interface{}) {
s.w.Debug(fmt.Sprint(v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Debug",
"(",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Debug",
"(",
"fmt",
".",
"Sprint",
"(",
"v",
"...",
")",
")",
"\n",
"}"
] | // Debug log content as Debug | [
"Debug",
"log",
"content",
"as",
"Debug"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L30-L32 | train |
go-xorm/xorm | syslogger.go | Debugf | func (s *SyslogLogger) Debugf(format string, v ...interface{}) {
s.w.Debug(fmt.Sprintf(format, v...))
} | go | func (s *SyslogLogger) Debugf(format string, v ...interface{}) {
s.w.Debug(fmt.Sprintf(format, v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Debugf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Debug",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Debugf log content as Debug and format | [
"Debugf",
"log",
"content",
"as",
"Debug",
"and",
"format"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L35-L37 | train |
go-xorm/xorm | syslogger.go | Error | func (s *SyslogLogger) Error(v ...interface{}) {
s.w.Err(fmt.Sprint(v...))
} | go | func (s *SyslogLogger) Error(v ...interface{}) {
s.w.Err(fmt.Sprint(v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Error",
"(",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Err",
"(",
"fmt",
".",
"Sprint",
"(",
"v",
"...",
")",
")",
"\n",
"}"
] | // Error log content as Error | [
"Error",
"log",
"content",
"as",
"Error"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L40-L42 | train |
go-xorm/xorm | syslogger.go | Errorf | func (s *SyslogLogger) Errorf(format string, v ...interface{}) {
s.w.Err(fmt.Sprintf(format, v...))
} | go | func (s *SyslogLogger) Errorf(format string, v ...interface{}) {
s.w.Err(fmt.Sprintf(format, v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Errorf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Err",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Errorf log content as Errorf and format | [
"Errorf",
"log",
"content",
"as",
"Errorf",
"and",
"format"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L45-L47 | train |
go-xorm/xorm | syslogger.go | Info | func (s *SyslogLogger) Info(v ...interface{}) {
s.w.Info(fmt.Sprint(v...))
} | go | func (s *SyslogLogger) Info(v ...interface{}) {
s.w.Info(fmt.Sprint(v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Info",
"(",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Info",
"(",
"fmt",
".",
"Sprint",
"(",
"v",
"...",
")",
")",
"\n",
"}"
] | // Info log content as Info | [
"Info",
"log",
"content",
"as",
"Info"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L50-L52 | train |
go-xorm/xorm | syslogger.go | Infof | func (s *SyslogLogger) Infof(format string, v ...interface{}) {
s.w.Info(fmt.Sprintf(format, v...))
} | go | func (s *SyslogLogger) Infof(format string, v ...interface{}) {
s.w.Info(fmt.Sprintf(format, v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Infof",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Info",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Infof log content as Infof and format | [
"Infof",
"log",
"content",
"as",
"Infof",
"and",
"format"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L55-L57 | train |
go-xorm/xorm | syslogger.go | Warn | func (s *SyslogLogger) Warn(v ...interface{}) {
s.w.Warning(fmt.Sprint(v...))
} | go | func (s *SyslogLogger) Warn(v ...interface{}) {
s.w.Warning(fmt.Sprint(v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Warn",
"(",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Warning",
"(",
"fmt",
".",
"Sprint",
"(",
"v",
"...",
")",
")",
"\n",
"}"
] | // Warn log content as Warn | [
"Warn",
"log",
"content",
"as",
"Warn"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L60-L62 | train |
go-xorm/xorm | syslogger.go | Warnf | func (s *SyslogLogger) Warnf(format string, v ...interface{}) {
s.w.Warning(fmt.Sprintf(format, v...))
} | go | func (s *SyslogLogger) Warnf(format string, v ...interface{}) {
s.w.Warning(fmt.Sprintf(format, v...))
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"Warnf",
"(",
"format",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"w",
".",
"Warning",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // Warnf log content as Warnf and format | [
"Warnf",
"log",
"content",
"as",
"Warnf",
"and",
"format"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L65-L67 | train |
go-xorm/xorm | syslogger.go | ShowSQL | func (s *SyslogLogger) ShowSQL(show ...bool) {
if len(show) == 0 {
s.showSQL = true
return
}
s.showSQL = show[0]
} | go | func (s *SyslogLogger) ShowSQL(show ...bool) {
if len(show) == 0 {
s.showSQL = true
return
}
s.showSQL = show[0]
} | [
"func",
"(",
"s",
"*",
"SyslogLogger",
")",
"ShowSQL",
"(",
"show",
"...",
"bool",
")",
"{",
"if",
"len",
"(",
"show",
")",
"==",
"0",
"{",
"s",
".",
"showSQL",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n",
"s",
".",
"showSQL",
"=",
"show",
"[",
"0",
"]",
"\n",
"}"
] | // ShowSQL set if logging SQL | [
"ShowSQL",
"set",
"if",
"logging",
"SQL"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/syslogger.go#L78-L84 | train |
go-xorm/xorm | engine_group_policy.go | RandomPolicy | func RandomPolicy() GroupPolicyHandler {
var r = rand.New(rand.NewSource(time.Now().UnixNano()))
return func(g *EngineGroup) *Engine {
return g.Slaves()[r.Intn(len(g.Slaves()))]
}
} | go | func RandomPolicy() GroupPolicyHandler {
var r = rand.New(rand.NewSource(time.Now().UnixNano()))
return func(g *EngineGroup) *Engine {
return g.Slaves()[r.Intn(len(g.Slaves()))]
}
} | [
"func",
"RandomPolicy",
"(",
")",
"GroupPolicyHandler",
"{",
"var",
"r",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n",
"return",
"func",
"(",
"g",
"*",
"EngineGroup",
")",
"*",
"Engine",
"{",
"return",
"g",
".",
"Slaves",
"(",
")",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"g",
".",
"Slaves",
"(",
")",
")",
")",
"]",
"\n",
"}",
"\n",
"}"
] | // RandomPolicy implmentes randomly chose the slave of slaves | [
"RandomPolicy",
"implmentes",
"randomly",
"chose",
"the",
"slave",
"of",
"slaves"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group_policy.go#L27-L32 | train |
go-xorm/xorm | engine_group_policy.go | WeightRandomPolicy | func WeightRandomPolicy(weights []int) GroupPolicyHandler {
var rands = make([]int, 0, len(weights))
for i := 0; i < len(weights); i++ {
for n := 0; n < weights[i]; n++ {
rands = append(rands, i)
}
}
var r = rand.New(rand.NewSource(time.Now().UnixNano()))
return func(g *EngineGroup) *Engine {
var slaves = g.Slaves()
idx := rands[r.Intn(len(rands))]
if idx >= len(slaves) {
idx = len(slaves) - 1
}
return slaves[idx]
}
} | go | func WeightRandomPolicy(weights []int) GroupPolicyHandler {
var rands = make([]int, 0, len(weights))
for i := 0; i < len(weights); i++ {
for n := 0; n < weights[i]; n++ {
rands = append(rands, i)
}
}
var r = rand.New(rand.NewSource(time.Now().UnixNano()))
return func(g *EngineGroup) *Engine {
var slaves = g.Slaves()
idx := rands[r.Intn(len(rands))]
if idx >= len(slaves) {
idx = len(slaves) - 1
}
return slaves[idx]
}
} | [
"func",
"WeightRandomPolicy",
"(",
"weights",
"[",
"]",
"int",
")",
"GroupPolicyHandler",
"{",
"var",
"rands",
"=",
"make",
"(",
"[",
"]",
"int",
",",
"0",
",",
"len",
"(",
"weights",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"weights",
")",
";",
"i",
"++",
"{",
"for",
"n",
":=",
"0",
";",
"n",
"<",
"weights",
"[",
"i",
"]",
";",
"n",
"++",
"{",
"rands",
"=",
"append",
"(",
"rands",
",",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"r",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
"\n\n",
"return",
"func",
"(",
"g",
"*",
"EngineGroup",
")",
"*",
"Engine",
"{",
"var",
"slaves",
"=",
"g",
".",
"Slaves",
"(",
")",
"\n",
"idx",
":=",
"rands",
"[",
"r",
".",
"Intn",
"(",
"len",
"(",
"rands",
")",
")",
"]",
"\n",
"if",
"idx",
">=",
"len",
"(",
"slaves",
")",
"{",
"idx",
"=",
"len",
"(",
"slaves",
")",
"-",
"1",
"\n",
"}",
"\n",
"return",
"slaves",
"[",
"idx",
"]",
"\n",
"}",
"\n",
"}"
] | // WeightRandomPolicy implmentes randomly chose the slave of slaves | [
"WeightRandomPolicy",
"implmentes",
"randomly",
"chose",
"the",
"slave",
"of",
"slaves"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group_policy.go#L35-L52 | train |
go-xorm/xorm | engine_group_policy.go | LeastConnPolicy | func LeastConnPolicy() GroupPolicyHandler {
return func(g *EngineGroup) *Engine {
var slaves = g.Slaves()
connections := 0
idx := 0
for i := 0; i < len(slaves); i++ {
openConnections := slaves[i].DB().Stats().OpenConnections
if i == 0 {
connections = openConnections
idx = i
} else if openConnections <= connections {
connections = openConnections
idx = i
}
}
return slaves[idx]
}
} | go | func LeastConnPolicy() GroupPolicyHandler {
return func(g *EngineGroup) *Engine {
var slaves = g.Slaves()
connections := 0
idx := 0
for i := 0; i < len(slaves); i++ {
openConnections := slaves[i].DB().Stats().OpenConnections
if i == 0 {
connections = openConnections
idx = i
} else if openConnections <= connections {
connections = openConnections
idx = i
}
}
return slaves[idx]
}
} | [
"func",
"LeastConnPolicy",
"(",
")",
"GroupPolicyHandler",
"{",
"return",
"func",
"(",
"g",
"*",
"EngineGroup",
")",
"*",
"Engine",
"{",
"var",
"slaves",
"=",
"g",
".",
"Slaves",
"(",
")",
"\n",
"connections",
":=",
"0",
"\n",
"idx",
":=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"slaves",
")",
";",
"i",
"++",
"{",
"openConnections",
":=",
"slaves",
"[",
"i",
"]",
".",
"DB",
"(",
")",
".",
"Stats",
"(",
")",
".",
"OpenConnections",
"\n",
"if",
"i",
"==",
"0",
"{",
"connections",
"=",
"openConnections",
"\n",
"idx",
"=",
"i",
"\n",
"}",
"else",
"if",
"openConnections",
"<=",
"connections",
"{",
"connections",
"=",
"openConnections",
"\n",
"idx",
"=",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"slaves",
"[",
"idx",
"]",
"\n",
"}",
"\n",
"}"
] | // LeastConnPolicy implements GroupPolicy, every time will get the least connections slave | [
"LeastConnPolicy",
"implements",
"GroupPolicy",
"every",
"time",
"will",
"get",
"the",
"least",
"connections",
"slave"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_group_policy.go#L99-L116 | train |
go-xorm/xorm | engine_table.go | tbNameWithSchema | func (engine *Engine) tbNameWithSchema(v string) string {
// Add schema name as prefix of table name.
// Only for postgres database.
if engine.dialect.DBType() == core.POSTGRES &&
engine.dialect.URI().Schema != "" &&
engine.dialect.URI().Schema != postgresPublicSchema &&
strings.Index(v, ".") == -1 {
return engine.dialect.URI().Schema + "." + v
}
return v
} | go | func (engine *Engine) tbNameWithSchema(v string) string {
// Add schema name as prefix of table name.
// Only for postgres database.
if engine.dialect.DBType() == core.POSTGRES &&
engine.dialect.URI().Schema != "" &&
engine.dialect.URI().Schema != postgresPublicSchema &&
strings.Index(v, ".") == -1 {
return engine.dialect.URI().Schema + "." + v
}
return v
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"tbNameWithSchema",
"(",
"v",
"string",
")",
"string",
"{",
"// Add schema name as prefix of table name.",
"// Only for postgres database.",
"if",
"engine",
".",
"dialect",
".",
"DBType",
"(",
")",
"==",
"core",
".",
"POSTGRES",
"&&",
"engine",
".",
"dialect",
".",
"URI",
"(",
")",
".",
"Schema",
"!=",
"\"",
"\"",
"&&",
"engine",
".",
"dialect",
".",
"URI",
"(",
")",
".",
"Schema",
"!=",
"postgresPublicSchema",
"&&",
"strings",
".",
"Index",
"(",
"v",
",",
"\"",
"\"",
")",
"==",
"-",
"1",
"{",
"return",
"engine",
".",
"dialect",
".",
"URI",
"(",
")",
".",
"Schema",
"+",
"\"",
"\"",
"+",
"v",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] | // tbNameWithSchema will automatically add schema prefix on table name | [
"tbNameWithSchema",
"will",
"automatically",
"add",
"schema",
"prefix",
"on",
"table",
"name"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_table.go#L16-L26 | train |
go-xorm/xorm | engine_table.go | TableName | func (engine *Engine) TableName(bean interface{}, includeSchema ...bool) string {
tbName := engine.tbNameNoSchema(bean)
if len(includeSchema) > 0 && includeSchema[0] {
tbName = engine.tbNameWithSchema(tbName)
}
return tbName
} | go | func (engine *Engine) TableName(bean interface{}, includeSchema ...bool) string {
tbName := engine.tbNameNoSchema(bean)
if len(includeSchema) > 0 && includeSchema[0] {
tbName = engine.tbNameWithSchema(tbName)
}
return tbName
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"TableName",
"(",
"bean",
"interface",
"{",
"}",
",",
"includeSchema",
"...",
"bool",
")",
"string",
"{",
"tbName",
":=",
"engine",
".",
"tbNameNoSchema",
"(",
"bean",
")",
"\n",
"if",
"len",
"(",
"includeSchema",
")",
">",
"0",
"&&",
"includeSchema",
"[",
"0",
"]",
"{",
"tbName",
"=",
"engine",
".",
"tbNameWithSchema",
"(",
"tbName",
")",
"\n",
"}",
"\n\n",
"return",
"tbName",
"\n",
"}"
] | // TableName returns table name with schema prefix if has | [
"TableName",
"returns",
"table",
"name",
"with",
"schema",
"prefix",
"if",
"has"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_table.go#L29-L36 | train |
go-xorm/xorm | json.go | Unmarshal | func (StdJSON) Unmarshal(data []byte, v interface{}) error {
return json.Unmarshal(data, v)
} | go | func (StdJSON) Unmarshal(data []byte, v interface{}) error {
return json.Unmarshal(data, v)
} | [
"func",
"(",
"StdJSON",
")",
"Unmarshal",
"(",
"data",
"[",
"]",
"byte",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"v",
")",
"\n",
"}"
] | // Unmarshal implements JSONInterface | [
"Unmarshal",
"implements",
"JSONInterface"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/json.go#L29-L31 | train |
go-xorm/xorm | engine.go | BufferSize | func (engine *Engine) BufferSize(size int) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.BufferSize(size)
} | go | func (engine *Engine) BufferSize(size int) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.BufferSize(size)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"BufferSize",
"(",
"size",
"int",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"BufferSize",
"(",
"size",
")",
"\n",
"}"
] | // BufferSize sets buffer size for iterate | [
"BufferSize",
"sets",
"buffer",
"size",
"for",
"iterate"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L87-L91 | train |
go-xorm/xorm | engine.go | CondDeleted | func (engine *Engine) CondDeleted(colName string) builder.Cond {
if engine.dialect.DBType() == core.MSSQL {
return builder.IsNull{colName}
}
return builder.IsNull{colName}.Or(builder.Eq{colName: zeroTime1})
} | go | func (engine *Engine) CondDeleted(colName string) builder.Cond {
if engine.dialect.DBType() == core.MSSQL {
return builder.IsNull{colName}
}
return builder.IsNull{colName}.Or(builder.Eq{colName: zeroTime1})
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"CondDeleted",
"(",
"colName",
"string",
")",
"builder",
".",
"Cond",
"{",
"if",
"engine",
".",
"dialect",
".",
"DBType",
"(",
")",
"==",
"core",
".",
"MSSQL",
"{",
"return",
"builder",
".",
"IsNull",
"{",
"colName",
"}",
"\n",
"}",
"\n",
"return",
"builder",
".",
"IsNull",
"{",
"colName",
"}",
".",
"Or",
"(",
"builder",
".",
"Eq",
"{",
"colName",
":",
"zeroTime1",
"}",
")",
"\n",
"}"
] | // CondDeleted returns the conditions whether a record is soft deleted. | [
"CondDeleted",
"returns",
"the",
"conditions",
"whether",
"a",
"record",
"is",
"soft",
"deleted",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L94-L99 | train |
go-xorm/xorm | engine.go | ShowSQL | func (engine *Engine) ShowSQL(show ...bool) {
engine.logger.ShowSQL(show...)
if len(show) == 0 {
engine.showSQL = true
} else {
engine.showSQL = show[0]
}
} | go | func (engine *Engine) ShowSQL(show ...bool) {
engine.logger.ShowSQL(show...)
if len(show) == 0 {
engine.showSQL = true
} else {
engine.showSQL = show[0]
}
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"ShowSQL",
"(",
"show",
"...",
"bool",
")",
"{",
"engine",
".",
"logger",
".",
"ShowSQL",
"(",
"show",
"...",
")",
"\n",
"if",
"len",
"(",
"show",
")",
"==",
"0",
"{",
"engine",
".",
"showSQL",
"=",
"true",
"\n",
"}",
"else",
"{",
"engine",
".",
"showSQL",
"=",
"show",
"[",
"0",
"]",
"\n",
"}",
"\n",
"}"
] | // ShowSQL show SQL statement or not on logger if log level is great than INFO | [
"ShowSQL",
"show",
"SQL",
"statement",
"or",
"not",
"on",
"logger",
"if",
"log",
"level",
"is",
"great",
"than",
"INFO"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L102-L109 | train |
go-xorm/xorm | engine.go | SetDisableGlobalCache | func (engine *Engine) SetDisableGlobalCache(disable bool) {
if engine.disableGlobalCache != disable {
engine.disableGlobalCache = disable
}
} | go | func (engine *Engine) SetDisableGlobalCache(disable bool) {
if engine.disableGlobalCache != disable {
engine.disableGlobalCache = disable
}
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"SetDisableGlobalCache",
"(",
"disable",
"bool",
")",
"{",
"if",
"engine",
".",
"disableGlobalCache",
"!=",
"disable",
"{",
"engine",
".",
"disableGlobalCache",
"=",
"disable",
"\n",
"}",
"\n",
"}"
] | // SetDisableGlobalCache disable global cache or not | [
"SetDisableGlobalCache",
"disable",
"global",
"cache",
"or",
"not"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L137-L141 | train |
go-xorm/xorm | engine.go | Quote | func (engine *Engine) Quote(value string) string {
value = strings.TrimSpace(value)
if len(value) == 0 {
return value
}
if string(value[0]) == engine.dialect.QuoteStr() || value[0] == '`' {
return value
}
value = strings.Replace(value, ".", engine.dialect.QuoteStr()+"."+engine.dialect.QuoteStr(), -1)
return engine.dialect.QuoteStr() + value + engine.dialect.QuoteStr()
} | go | func (engine *Engine) Quote(value string) string {
value = strings.TrimSpace(value)
if len(value) == 0 {
return value
}
if string(value[0]) == engine.dialect.QuoteStr() || value[0] == '`' {
return value
}
value = strings.Replace(value, ".", engine.dialect.QuoteStr()+"."+engine.dialect.QuoteStr(), -1)
return engine.dialect.QuoteStr() + value + engine.dialect.QuoteStr()
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Quote",
"(",
"value",
"string",
")",
"string",
"{",
"value",
"=",
"strings",
".",
"TrimSpace",
"(",
"value",
")",
"\n",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"value",
"\n",
"}",
"\n\n",
"if",
"string",
"(",
"value",
"[",
"0",
"]",
")",
"==",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"||",
"value",
"[",
"0",
"]",
"==",
"'`'",
"{",
"return",
"value",
"\n",
"}",
"\n\n",
"value",
"=",
"strings",
".",
"Replace",
"(",
"value",
",",
"\"",
"\"",
",",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"+",
"\"",
"\"",
"+",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
",",
"-",
"1",
")",
"\n\n",
"return",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"+",
"value",
"+",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"\n",
"}"
] | // Quote Use QuoteStr quote the string sql | [
"Quote",
"Use",
"QuoteStr",
"quote",
"the",
"string",
"sql"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L192-L205 | train |
go-xorm/xorm | engine.go | QuoteTo | func (engine *Engine) QuoteTo(buf *builder.StringBuilder, value string) {
if buf == nil {
return
}
value = strings.TrimSpace(value)
if value == "" {
return
}
if string(value[0]) == engine.dialect.QuoteStr() || value[0] == '`' {
buf.WriteString(value)
return
}
value = strings.Replace(value, ".", engine.dialect.QuoteStr()+"."+engine.dialect.QuoteStr(), -1)
buf.WriteString(engine.dialect.QuoteStr())
buf.WriteString(value)
buf.WriteString(engine.dialect.QuoteStr())
} | go | func (engine *Engine) QuoteTo(buf *builder.StringBuilder, value string) {
if buf == nil {
return
}
value = strings.TrimSpace(value)
if value == "" {
return
}
if string(value[0]) == engine.dialect.QuoteStr() || value[0] == '`' {
buf.WriteString(value)
return
}
value = strings.Replace(value, ".", engine.dialect.QuoteStr()+"."+engine.dialect.QuoteStr(), -1)
buf.WriteString(engine.dialect.QuoteStr())
buf.WriteString(value)
buf.WriteString(engine.dialect.QuoteStr())
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"QuoteTo",
"(",
"buf",
"*",
"builder",
".",
"StringBuilder",
",",
"value",
"string",
")",
"{",
"if",
"buf",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"value",
"=",
"strings",
".",
"TrimSpace",
"(",
"value",
")",
"\n",
"if",
"value",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"string",
"(",
"value",
"[",
"0",
"]",
")",
"==",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"||",
"value",
"[",
"0",
"]",
"==",
"'`'",
"{",
"buf",
".",
"WriteString",
"(",
"value",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"value",
"=",
"strings",
".",
"Replace",
"(",
"value",
",",
"\"",
"\"",
",",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
"+",
"\"",
"\"",
"+",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
",",
"-",
"1",
")",
"\n\n",
"buf",
".",
"WriteString",
"(",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"value",
")",
"\n",
"buf",
".",
"WriteString",
"(",
"engine",
".",
"dialect",
".",
"QuoteStr",
"(",
")",
")",
"\n",
"}"
] | // QuoteTo quotes string and writes into the buffer | [
"QuoteTo",
"quotes",
"string",
"and",
"writes",
"into",
"the",
"buffer"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L208-L228 | train |
go-xorm/xorm | engine.go | NewDB | func (engine *Engine) NewDB() (*core.DB, error) {
return core.OpenDialect(engine.dialect)
} | go | func (engine *Engine) NewDB() (*core.DB, error) {
return core.OpenDialect(engine.dialect)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"NewDB",
"(",
")",
"(",
"*",
"core",
".",
"DB",
",",
"error",
")",
"{",
"return",
"core",
".",
"OpenDialect",
"(",
"engine",
".",
"dialect",
")",
"\n",
"}"
] | // NewDB provides an interface to operate database directly | [
"NewDB",
"provides",
"an",
"interface",
"to",
"operate",
"database",
"directly"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L298-L300 | train |
go-xorm/xorm | engine.go | NewSession | func (engine *Engine) NewSession() *Session {
session := &Session{engine: engine}
session.Init()
return session
} | go | func (engine *Engine) NewSession() *Session {
session := &Session{engine: engine}
session.Init()
return session
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"NewSession",
"(",
")",
"*",
"Session",
"{",
"session",
":=",
"&",
"Session",
"{",
"engine",
":",
"engine",
"}",
"\n",
"session",
".",
"Init",
"(",
")",
"\n",
"return",
"session",
"\n",
"}"
] | // NewSession New a session | [
"NewSession",
"New",
"a",
"session"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L313-L317 | train |
go-xorm/xorm | engine.go | NoAutoCondition | func (engine *Engine) NoAutoCondition(no ...bool) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.NoAutoCondition(no...)
} | go | func (engine *Engine) NoAutoCondition(no ...bool) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.NoAutoCondition(no...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"NoAutoCondition",
"(",
"no",
"...",
"bool",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"NoAutoCondition",
"(",
"no",
"...",
")",
"\n",
"}"
] | // NoAutoCondition disable auto generate Where condition from bean or not | [
"NoAutoCondition",
"disable",
"auto",
"generate",
"Where",
"condition",
"from",
"bean",
"or",
"not"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L372-L376 | train |
go-xorm/xorm | engine.go | DBMetas | func (engine *Engine) DBMetas() ([]*core.Table, error) {
tables, err := engine.dialect.GetTables()
if err != nil {
return nil, err
}
for _, table := range tables {
colSeq, cols, err := engine.dialect.GetColumns(table.Name)
if err != nil {
return nil, err
}
for _, name := range colSeq {
table.AddColumn(cols[name])
}
indexes, err := engine.dialect.GetIndexes(table.Name)
if err != nil {
return nil, err
}
table.Indexes = indexes
for _, index := range indexes {
for _, name := range index.Cols {
if col := table.GetColumn(name); col != nil {
col.Indexes[index.Name] = index.Type
} else {
return nil, fmt.Errorf("Unknown col %s in index %v of table %v, columns %v", name, index.Name, table.Name, table.ColumnsSeq())
}
}
}
}
return tables, nil
} | go | func (engine *Engine) DBMetas() ([]*core.Table, error) {
tables, err := engine.dialect.GetTables()
if err != nil {
return nil, err
}
for _, table := range tables {
colSeq, cols, err := engine.dialect.GetColumns(table.Name)
if err != nil {
return nil, err
}
for _, name := range colSeq {
table.AddColumn(cols[name])
}
indexes, err := engine.dialect.GetIndexes(table.Name)
if err != nil {
return nil, err
}
table.Indexes = indexes
for _, index := range indexes {
for _, name := range index.Cols {
if col := table.GetColumn(name); col != nil {
col.Indexes[index.Name] = index.Type
} else {
return nil, fmt.Errorf("Unknown col %s in index %v of table %v, columns %v", name, index.Name, table.Name, table.ColumnsSeq())
}
}
}
}
return tables, nil
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DBMetas",
"(",
")",
"(",
"[",
"]",
"*",
"core",
".",
"Table",
",",
"error",
")",
"{",
"tables",
",",
"err",
":=",
"engine",
".",
"dialect",
".",
"GetTables",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"table",
":=",
"range",
"tables",
"{",
"colSeq",
",",
"cols",
",",
"err",
":=",
"engine",
".",
"dialect",
".",
"GetColumns",
"(",
"table",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"colSeq",
"{",
"table",
".",
"AddColumn",
"(",
"cols",
"[",
"name",
"]",
")",
"\n",
"}",
"\n",
"indexes",
",",
"err",
":=",
"engine",
".",
"dialect",
".",
"GetIndexes",
"(",
"table",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"table",
".",
"Indexes",
"=",
"indexes",
"\n\n",
"for",
"_",
",",
"index",
":=",
"range",
"indexes",
"{",
"for",
"_",
",",
"name",
":=",
"range",
"index",
".",
"Cols",
"{",
"if",
"col",
":=",
"table",
".",
"GetColumn",
"(",
"name",
")",
";",
"col",
"!=",
"nil",
"{",
"col",
".",
"Indexes",
"[",
"index",
".",
"Name",
"]",
"=",
"index",
".",
"Type",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"name",
",",
"index",
".",
"Name",
",",
"table",
".",
"Name",
",",
"table",
".",
"ColumnsSeq",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] | // DBMetas Retrieve all tables, columns, indexes' informations from database. | [
"DBMetas",
"Retrieve",
"all",
"tables",
"columns",
"indexes",
"informations",
"from",
"database",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L379-L410 | train |
go-xorm/xorm | engine.go | DumpAllToFile | func (engine *Engine) DumpAllToFile(fp string, tp ...core.DbType) error {
f, err := os.Create(fp)
if err != nil {
return err
}
defer f.Close()
return engine.DumpAll(f, tp...)
} | go | func (engine *Engine) DumpAllToFile(fp string, tp ...core.DbType) error {
f, err := os.Create(fp)
if err != nil {
return err
}
defer f.Close()
return engine.DumpAll(f, tp...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DumpAllToFile",
"(",
"fp",
"string",
",",
"tp",
"...",
"core",
".",
"DbType",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"fp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"engine",
".",
"DumpAll",
"(",
"f",
",",
"tp",
"...",
")",
"\n",
"}"
] | // DumpAllToFile dump database all table structs and data to a file | [
"DumpAllToFile",
"dump",
"database",
"all",
"table",
"structs",
"and",
"data",
"to",
"a",
"file"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L413-L420 | train |
go-xorm/xorm | engine.go | DumpTablesToFile | func (engine *Engine) DumpTablesToFile(tables []*core.Table, fp string, tp ...core.DbType) error {
f, err := os.Create(fp)
if err != nil {
return err
}
defer f.Close()
return engine.DumpTables(tables, f, tp...)
} | go | func (engine *Engine) DumpTablesToFile(tables []*core.Table, fp string, tp ...core.DbType) error {
f, err := os.Create(fp)
if err != nil {
return err
}
defer f.Close()
return engine.DumpTables(tables, f, tp...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DumpTablesToFile",
"(",
"tables",
"[",
"]",
"*",
"core",
".",
"Table",
",",
"fp",
"string",
",",
"tp",
"...",
"core",
".",
"DbType",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"fp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"engine",
".",
"DumpTables",
"(",
"tables",
",",
"f",
",",
"tp",
"...",
")",
"\n",
"}"
] | // DumpTablesToFile dump specified tables to SQL file. | [
"DumpTablesToFile",
"dump",
"specified",
"tables",
"to",
"SQL",
"file",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L432-L439 | train |
go-xorm/xorm | engine.go | DumpTables | func (engine *Engine) DumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error {
return engine.dumpTables(tables, w, tp...)
} | go | func (engine *Engine) DumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error {
return engine.dumpTables(tables, w, tp...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DumpTables",
"(",
"tables",
"[",
"]",
"*",
"core",
".",
"Table",
",",
"w",
"io",
".",
"Writer",
",",
"tp",
"...",
"core",
".",
"DbType",
")",
"error",
"{",
"return",
"engine",
".",
"dumpTables",
"(",
"tables",
",",
"w",
",",
"tp",
"...",
")",
"\n",
"}"
] | // DumpTables dump specify tables to io.Writer | [
"DumpTables",
"dump",
"specify",
"tables",
"to",
"io",
".",
"Writer"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L442-L444 | train |
go-xorm/xorm | engine.go | dumpTables | func (engine *Engine) dumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error {
var dialect core.Dialect
var distDBName string
if len(tp) == 0 {
dialect = engine.dialect
distDBName = string(engine.dialect.DBType())
} else {
dialect = core.QueryDialect(tp[0])
if dialect == nil {
return errors.New("Unsupported database type")
}
dialect.Init(nil, engine.dialect.URI(), "", "")
distDBName = string(tp[0])
}
_, err := io.WriteString(w, fmt.Sprintf("/*Generated by xorm v%s %s, from %s to %s*/\n\n",
Version, time.Now().In(engine.TZLocation).Format("2006-01-02 15:04:05"), engine.dialect.DBType(), strings.ToUpper(distDBName)))
if err != nil {
return err
}
for i, table := range tables {
if i > 0 {
_, err = io.WriteString(w, "\n")
if err != nil {
return err
}
}
_, err = io.WriteString(w, dialect.CreateTableSql(table, "", table.StoreEngine, "")+";\n")
if err != nil {
return err
}
for _, index := range table.Indexes {
_, err = io.WriteString(w, dialect.CreateIndexSql(table.Name, index)+";\n")
if err != nil {
return err
}
}
cols := table.ColumnsSeq()
colNames := engine.dialect.Quote(strings.Join(cols, engine.dialect.Quote(", ")))
destColNames := dialect.Quote(strings.Join(cols, dialect.Quote(", ")))
rows, err := engine.DB().Query("SELECT " + colNames + " FROM " + engine.Quote(table.Name))
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
dest := make([]interface{}, len(cols))
err = rows.ScanSlice(&dest)
if err != nil {
return err
}
_, err = io.WriteString(w, "INSERT INTO "+dialect.Quote(table.Name)+" ("+destColNames+") VALUES (")
if err != nil {
return err
}
var temp string
for i, d := range dest {
col := table.GetColumn(cols[i])
if col == nil {
return errors.New("unknow column error")
}
if d == nil {
temp += ", NULL"
} else if col.SQLType.IsText() || col.SQLType.IsTime() {
var v = fmt.Sprintf("%s", d)
if strings.HasSuffix(v, " +0000 UTC") {
temp += fmt.Sprintf(", '%s'", v[0:len(v)-len(" +0000 UTC")])
} else {
temp += ", '" + strings.Replace(v, "'", "''", -1) + "'"
}
} else if col.SQLType.IsBlob() {
if reflect.TypeOf(d).Kind() == reflect.Slice {
temp += fmt.Sprintf(", %s", dialect.FormatBytes(d.([]byte)))
} else if reflect.TypeOf(d).Kind() == reflect.String {
temp += fmt.Sprintf(", '%s'", d.(string))
}
} else if col.SQLType.IsNumeric() {
switch reflect.TypeOf(d).Kind() {
case reflect.Slice:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(d.([]byte)[0] != byte('0')))
} else {
temp += fmt.Sprintf(", %s", string(d.([]byte)))
}
case reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64, reflect.Int:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(reflect.ValueOf(d).Int() > 0))
} else {
temp += fmt.Sprintf(", %v", d)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(reflect.ValueOf(d).Uint() > 0))
} else {
temp += fmt.Sprintf(", %v", d)
}
default:
temp += fmt.Sprintf(", %v", d)
}
} else {
s := fmt.Sprintf("%v", d)
if strings.Contains(s, ":") || strings.Contains(s, "-") {
if strings.HasSuffix(s, " +0000 UTC") {
temp += fmt.Sprintf(", '%s'", s[0:len(s)-len(" +0000 UTC")])
} else {
temp += fmt.Sprintf(", '%s'", s)
}
} else {
temp += fmt.Sprintf(", %s", s)
}
}
}
_, err = io.WriteString(w, temp[2:]+");\n")
if err != nil {
return err
}
}
// FIXME: Hack for postgres
if string(dialect.DBType()) == core.POSTGRES && table.AutoIncrColumn() != nil {
_, err = io.WriteString(w, "SELECT setval('"+table.Name+"_id_seq', COALESCE((SELECT MAX("+table.AutoIncrColumn().Name+") + 1 FROM "+dialect.Quote(table.Name)+"), 1), false);\n")
if err != nil {
return err
}
}
}
return nil
} | go | func (engine *Engine) dumpTables(tables []*core.Table, w io.Writer, tp ...core.DbType) error {
var dialect core.Dialect
var distDBName string
if len(tp) == 0 {
dialect = engine.dialect
distDBName = string(engine.dialect.DBType())
} else {
dialect = core.QueryDialect(tp[0])
if dialect == nil {
return errors.New("Unsupported database type")
}
dialect.Init(nil, engine.dialect.URI(), "", "")
distDBName = string(tp[0])
}
_, err := io.WriteString(w, fmt.Sprintf("/*Generated by xorm v%s %s, from %s to %s*/\n\n",
Version, time.Now().In(engine.TZLocation).Format("2006-01-02 15:04:05"), engine.dialect.DBType(), strings.ToUpper(distDBName)))
if err != nil {
return err
}
for i, table := range tables {
if i > 0 {
_, err = io.WriteString(w, "\n")
if err != nil {
return err
}
}
_, err = io.WriteString(w, dialect.CreateTableSql(table, "", table.StoreEngine, "")+";\n")
if err != nil {
return err
}
for _, index := range table.Indexes {
_, err = io.WriteString(w, dialect.CreateIndexSql(table.Name, index)+";\n")
if err != nil {
return err
}
}
cols := table.ColumnsSeq()
colNames := engine.dialect.Quote(strings.Join(cols, engine.dialect.Quote(", ")))
destColNames := dialect.Quote(strings.Join(cols, dialect.Quote(", ")))
rows, err := engine.DB().Query("SELECT " + colNames + " FROM " + engine.Quote(table.Name))
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
dest := make([]interface{}, len(cols))
err = rows.ScanSlice(&dest)
if err != nil {
return err
}
_, err = io.WriteString(w, "INSERT INTO "+dialect.Quote(table.Name)+" ("+destColNames+") VALUES (")
if err != nil {
return err
}
var temp string
for i, d := range dest {
col := table.GetColumn(cols[i])
if col == nil {
return errors.New("unknow column error")
}
if d == nil {
temp += ", NULL"
} else if col.SQLType.IsText() || col.SQLType.IsTime() {
var v = fmt.Sprintf("%s", d)
if strings.HasSuffix(v, " +0000 UTC") {
temp += fmt.Sprintf(", '%s'", v[0:len(v)-len(" +0000 UTC")])
} else {
temp += ", '" + strings.Replace(v, "'", "''", -1) + "'"
}
} else if col.SQLType.IsBlob() {
if reflect.TypeOf(d).Kind() == reflect.Slice {
temp += fmt.Sprintf(", %s", dialect.FormatBytes(d.([]byte)))
} else if reflect.TypeOf(d).Kind() == reflect.String {
temp += fmt.Sprintf(", '%s'", d.(string))
}
} else if col.SQLType.IsNumeric() {
switch reflect.TypeOf(d).Kind() {
case reflect.Slice:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(d.([]byte)[0] != byte('0')))
} else {
temp += fmt.Sprintf(", %s", string(d.([]byte)))
}
case reflect.Int16, reflect.Int8, reflect.Int32, reflect.Int64, reflect.Int:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(reflect.ValueOf(d).Int() > 0))
} else {
temp += fmt.Sprintf(", %v", d)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if col.SQLType.Name == core.Bool {
temp += fmt.Sprintf(", %v", strconv.FormatBool(reflect.ValueOf(d).Uint() > 0))
} else {
temp += fmt.Sprintf(", %v", d)
}
default:
temp += fmt.Sprintf(", %v", d)
}
} else {
s := fmt.Sprintf("%v", d)
if strings.Contains(s, ":") || strings.Contains(s, "-") {
if strings.HasSuffix(s, " +0000 UTC") {
temp += fmt.Sprintf(", '%s'", s[0:len(s)-len(" +0000 UTC")])
} else {
temp += fmt.Sprintf(", '%s'", s)
}
} else {
temp += fmt.Sprintf(", %s", s)
}
}
}
_, err = io.WriteString(w, temp[2:]+");\n")
if err != nil {
return err
}
}
// FIXME: Hack for postgres
if string(dialect.DBType()) == core.POSTGRES && table.AutoIncrColumn() != nil {
_, err = io.WriteString(w, "SELECT setval('"+table.Name+"_id_seq', COALESCE((SELECT MAX("+table.AutoIncrColumn().Name+") + 1 FROM "+dialect.Quote(table.Name)+"), 1), false);\n")
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"dumpTables",
"(",
"tables",
"[",
"]",
"*",
"core",
".",
"Table",
",",
"w",
"io",
".",
"Writer",
",",
"tp",
"...",
"core",
".",
"DbType",
")",
"error",
"{",
"var",
"dialect",
"core",
".",
"Dialect",
"\n",
"var",
"distDBName",
"string",
"\n",
"if",
"len",
"(",
"tp",
")",
"==",
"0",
"{",
"dialect",
"=",
"engine",
".",
"dialect",
"\n",
"distDBName",
"=",
"string",
"(",
"engine",
".",
"dialect",
".",
"DBType",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"dialect",
"=",
"core",
".",
"QueryDialect",
"(",
"tp",
"[",
"0",
"]",
")",
"\n",
"if",
"dialect",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"dialect",
".",
"Init",
"(",
"nil",
",",
"engine",
".",
"dialect",
".",
"URI",
"(",
")",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"distDBName",
"=",
"string",
"(",
"tp",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"w",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"Version",
",",
"time",
".",
"Now",
"(",
")",
".",
"In",
"(",
"engine",
".",
"TZLocation",
")",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"engine",
".",
"dialect",
".",
"DBType",
"(",
")",
",",
"strings",
".",
"ToUpper",
"(",
"distDBName",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"table",
":=",
"range",
"tables",
"{",
"if",
"i",
">",
"0",
"{",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"dialect",
".",
"CreateTableSql",
"(",
"table",
",",
"\"",
"\"",
",",
"table",
".",
"StoreEngine",
",",
"\"",
"\"",
")",
"+",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"index",
":=",
"range",
"table",
".",
"Indexes",
"{",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"dialect",
".",
"CreateIndexSql",
"(",
"table",
".",
"Name",
",",
"index",
")",
"+",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"cols",
":=",
"table",
".",
"ColumnsSeq",
"(",
")",
"\n",
"colNames",
":=",
"engine",
".",
"dialect",
".",
"Quote",
"(",
"strings",
".",
"Join",
"(",
"cols",
",",
"engine",
".",
"dialect",
".",
"Quote",
"(",
"\"",
"\"",
")",
")",
")",
"\n",
"destColNames",
":=",
"dialect",
".",
"Quote",
"(",
"strings",
".",
"Join",
"(",
"cols",
",",
"dialect",
".",
"Quote",
"(",
"\"",
"\"",
")",
")",
")",
"\n\n",
"rows",
",",
"err",
":=",
"engine",
".",
"DB",
"(",
")",
".",
"Query",
"(",
"\"",
"\"",
"+",
"colNames",
"+",
"\"",
"\"",
"+",
"engine",
".",
"Quote",
"(",
"table",
".",
"Name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"rows",
".",
"Close",
"(",
")",
"\n\n",
"for",
"rows",
".",
"Next",
"(",
")",
"{",
"dest",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"cols",
")",
")",
"\n",
"err",
"=",
"rows",
".",
"ScanSlice",
"(",
"&",
"dest",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\"",
"+",
"dialect",
".",
"Quote",
"(",
"table",
".",
"Name",
")",
"+",
"\"",
"\"",
"+",
"destColNames",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"var",
"temp",
"string",
"\n",
"for",
"i",
",",
"d",
":=",
"range",
"dest",
"{",
"col",
":=",
"table",
".",
"GetColumn",
"(",
"cols",
"[",
"i",
"]",
")",
"\n",
"if",
"col",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"d",
"==",
"nil",
"{",
"temp",
"+=",
"\"",
"\"",
"\n",
"}",
"else",
"if",
"col",
".",
"SQLType",
".",
"IsText",
"(",
")",
"||",
"col",
".",
"SQLType",
".",
"IsTime",
"(",
")",
"{",
"var",
"v",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"v",
",",
"\"",
"\"",
")",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
"[",
"0",
":",
"len",
"(",
"v",
")",
"-",
"len",
"(",
"\"",
"\"",
")",
"]",
")",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"\"",
"\"",
"+",
"strings",
".",
"Replace",
"(",
"v",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"else",
"if",
"col",
".",
"SQLType",
".",
"IsBlob",
"(",
")",
"{",
"if",
"reflect",
".",
"TypeOf",
"(",
"d",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Slice",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"dialect",
".",
"FormatBytes",
"(",
"d",
".",
"(",
"[",
"]",
"byte",
")",
")",
")",
"\n",
"}",
"else",
"if",
"reflect",
".",
"TypeOf",
"(",
"d",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"String",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
".",
"(",
"string",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"col",
".",
"SQLType",
".",
"IsNumeric",
"(",
")",
"{",
"switch",
"reflect",
".",
"TypeOf",
"(",
"d",
")",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Slice",
":",
"if",
"col",
".",
"SQLType",
".",
"Name",
"==",
"core",
".",
"Bool",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strconv",
".",
"FormatBool",
"(",
"d",
".",
"(",
"[",
"]",
"byte",
")",
"[",
"0",
"]",
"!=",
"byte",
"(",
"'0'",
")",
")",
")",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"string",
"(",
"d",
".",
"(",
"[",
"]",
"byte",
")",
")",
")",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Int",
":",
"if",
"col",
".",
"SQLType",
".",
"Name",
"==",
"core",
".",
"Bool",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strconv",
".",
"FormatBool",
"(",
"reflect",
".",
"ValueOf",
"(",
"d",
")",
".",
"Int",
"(",
")",
">",
"0",
")",
")",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
":",
"if",
"col",
".",
"SQLType",
".",
"Name",
"==",
"core",
".",
"Bool",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"strconv",
".",
"FormatBool",
"(",
"reflect",
".",
"ValueOf",
"(",
"d",
")",
".",
"Uint",
"(",
")",
">",
"0",
")",
")",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
"\n",
"}",
"\n",
"default",
":",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"s",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"s",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"s",
",",
"\"",
"\"",
")",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"\"",
"\"",
")",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
"[",
"0",
":",
"len",
"(",
"s",
")",
"-",
"len",
"(",
"\"",
"\"",
")",
"]",
")",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"temp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"temp",
"[",
"2",
":",
"]",
"+",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// FIXME: Hack for postgres",
"if",
"string",
"(",
"dialect",
".",
"DBType",
"(",
")",
")",
"==",
"core",
".",
"POSTGRES",
"&&",
"table",
".",
"AutoIncrColumn",
"(",
")",
"!=",
"nil",
"{",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"w",
",",
"\"",
"\"",
"+",
"table",
".",
"Name",
"+",
"\"",
"\"",
"+",
"table",
".",
"AutoIncrColumn",
"(",
")",
".",
"Name",
"+",
"\"",
"\"",
"+",
"dialect",
".",
"Quote",
"(",
"table",
".",
"Name",
")",
"+",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // dumpTables dump database all table structs and data to w with specify db type | [
"dumpTables",
"dump",
"database",
"all",
"table",
"structs",
"and",
"data",
"to",
"w",
"with",
"specify",
"db",
"type"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L447-L581 | train |
go-xorm/xorm | engine.go | Where | func (engine *Engine) Where(query interface{}, args ...interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Where(query, args...)
} | go | func (engine *Engine) Where(query interface{}, args ...interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Where(query, args...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Where",
"(",
"query",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Where",
"(",
"query",
",",
"args",
"...",
")",
"\n",
"}"
] | // Where method provide a condition query | [
"Where",
"method",
"provide",
"a",
"condition",
"query"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L591-L595 | train |
go-xorm/xorm | engine.go | Id | func (engine *Engine) Id(id interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Id(id)
} | go | func (engine *Engine) Id(id interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Id(id)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Id",
"(",
"id",
"interface",
"{",
"}",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Id",
"(",
"id",
")",
"\n",
"}"
] | // Id will be deprecated, please use ID instead | [
"Id",
"will",
"be",
"deprecated",
"please",
"use",
"ID",
"instead"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L598-L602 | train |
go-xorm/xorm | engine.go | Select | func (engine *Engine) Select(str string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Select(str)
} | go | func (engine *Engine) Select(str string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Select(str)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Select",
"(",
"str",
"string",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Select",
"(",
"str",
")",
"\n",
"}"
] | // Select customerize your select columns or contents | [
"Select",
"customerize",
"your",
"select",
"columns",
"or",
"contents"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L649-L653 | train |
go-xorm/xorm | engine.go | Incr | func (engine *Engine) Incr(column string, arg ...interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Incr(column, arg...)
} | go | func (engine *Engine) Incr(column string, arg ...interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Incr(column, arg...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Incr",
"(",
"column",
"string",
",",
"arg",
"...",
"interface",
"{",
"}",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Incr",
"(",
"column",
",",
"arg",
"...",
")",
"\n",
"}"
] | // Incr provides a update string like "column = column + ?" | [
"Incr",
"provides",
"a",
"update",
"string",
"like",
"column",
"=",
"column",
"+",
"?"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L716-L720 | train |
go-xorm/xorm | engine.go | Table | func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Table(tableNameOrBean)
} | go | func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Table(tableNameOrBean)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Table",
"(",
"tableNameOrBean",
"interface",
"{",
"}",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Table",
"(",
"tableNameOrBean",
")",
"\n",
"}"
] | // Table temporarily change the Get, Find, Update's table | [
"Table",
"temporarily",
"change",
"the",
"Get",
"Find",
"Update",
"s",
"table"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L737-L741 | train |
go-xorm/xorm | engine.go | OrderBy | func (engine *Engine) OrderBy(order string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.OrderBy(order)
} | go | func (engine *Engine) OrderBy(order string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.OrderBy(order)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"OrderBy",
"(",
"order",
"string",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"OrderBy",
"(",
"order",
")",
"\n",
"}"
] | // OrderBy will generate "ORDER BY order" | [
"OrderBy",
"will",
"generate",
"ORDER",
"BY",
"order"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L777-L781 | train |
go-xorm/xorm | engine.go | Prepare | func (engine *Engine) Prepare() *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Prepare()
} | go | func (engine *Engine) Prepare() *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Prepare()
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Prepare",
"(",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Prepare",
"(",
")",
"\n",
"}"
] | // Prepare enables prepare statement | [
"Prepare",
"enables",
"prepare",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L784-L788 | train |
go-xorm/xorm | engine.go | 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...)
} | go | 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...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Join",
"(",
"joinOperator",
"string",
",",
"tablename",
"interface",
"{",
"}",
",",
"condition",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Join",
"(",
"joinOperator",
",",
"tablename",
",",
"condition",
",",
"args",
"...",
")",
"\n",
"}"
] | // Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN | [
"Join",
"the",
"join_operator",
"should",
"be",
"one",
"of",
"INNER",
"LEFT",
"OUTER",
"CROSS",
"etc",
"-",
"this",
"will",
"be",
"prepended",
"to",
"JOIN"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L791-L795 | train |
go-xorm/xorm | engine.go | GroupBy | func (engine *Engine) GroupBy(keys string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.GroupBy(keys)
} | go | func (engine *Engine) GroupBy(keys string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.GroupBy(keys)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"GroupBy",
"(",
"keys",
"string",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"GroupBy",
"(",
"keys",
")",
"\n",
"}"
] | // GroupBy generate group by statement | [
"GroupBy",
"generate",
"group",
"by",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L798-L802 | train |
go-xorm/xorm | engine.go | Having | func (engine *Engine) Having(conditions string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Having(conditions)
} | go | func (engine *Engine) Having(conditions string) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Having(conditions)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Having",
"(",
"conditions",
"string",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Having",
"(",
"conditions",
")",
"\n",
"}"
] | // Having generate having statement | [
"Having",
"generate",
"having",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L805-L809 | train |
go-xorm/xorm | engine.go | UnMapType | func (engine *Engine) UnMapType(t reflect.Type) {
engine.mutex.Lock()
defer engine.mutex.Unlock()
delete(engine.Tables, t)
} | go | func (engine *Engine) UnMapType(t reflect.Type) {
engine.mutex.Lock()
defer engine.mutex.Unlock()
delete(engine.Tables, t)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"UnMapType",
"(",
"t",
"reflect",
".",
"Type",
")",
"{",
"engine",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"engine",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"engine",
".",
"Tables",
",",
"t",
")",
"\n",
"}"
] | // UnMapType removes the datbase mapper of a type | [
"UnMapType",
"removes",
"the",
"datbase",
"mapper",
"of",
"a",
"type"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L812-L816 | train |
go-xorm/xorm | engine.go | IsValid | func (t *Table) IsValid() bool {
return t.Table != nil && len(t.Name) > 0
} | go | func (t *Table) IsValid() bool {
return t.Table != nil && len(t.Name) > 0
} | [
"func",
"(",
"t",
"*",
"Table",
")",
"IsValid",
"(",
")",
"bool",
"{",
"return",
"t",
".",
"Table",
"!=",
"nil",
"&&",
"len",
"(",
"t",
".",
"Name",
")",
">",
"0",
"\n",
"}"
] | // IsValid if table is valid | [
"IsValid",
"if",
"table",
"is",
"valid"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L855-L857 | train |
go-xorm/xorm | engine.go | IsTableEmpty | func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error) {
session := engine.NewSession()
defer session.Close()
return session.IsTableEmpty(bean)
} | go | func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error) {
session := engine.NewSession()
defer session.Close()
return session.IsTableEmpty(bean)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"IsTableEmpty",
"(",
"bean",
"interface",
"{",
"}",
")",
"(",
"bool",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"IsTableEmpty",
"(",
"bean",
")",
"\n",
"}"
] | // IsTableEmpty if a table has any reocrd | [
"IsTableEmpty",
"if",
"a",
"table",
"has",
"any",
"reocrd"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1063-L1067 | train |
go-xorm/xorm | engine.go | IDOf | func (engine *Engine) IDOf(bean interface{}) core.PK {
return engine.IdOfV(reflect.ValueOf(bean))
} | go | func (engine *Engine) IDOf(bean interface{}) core.PK {
return engine.IdOfV(reflect.ValueOf(bean))
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"IDOf",
"(",
"bean",
"interface",
"{",
"}",
")",
"core",
".",
"PK",
"{",
"return",
"engine",
".",
"IdOfV",
"(",
"reflect",
".",
"ValueOf",
"(",
"bean",
")",
")",
"\n",
"}"
] | // IDOf get id from one struct | [
"IDOf",
"get",
"id",
"from",
"one",
"struct"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1084-L1086 | train |
go-xorm/xorm | engine.go | IDOfV | 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
} | go | 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",
"{",
"pk",
",",
"err",
":=",
"engine",
".",
"idOfV",
"(",
"rv",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"engine",
".",
"logger",
".",
"Error",
"(",
"err",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"pk",
"\n",
"}"
] | // IDOfV get id from one value of struct | [
"IDOfV",
"get",
"id",
"from",
"one",
"value",
"of",
"struct"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1096-L1103 | train |
go-xorm/xorm | engine.go | CreateTables | 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()
} | go | 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()
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"CreateTables",
"(",
"beans",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"err",
":=",
"session",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"bean",
":=",
"range",
"beans",
"{",
"err",
"=",
"session",
".",
"createTable",
"(",
"bean",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"session",
".",
"Rollback",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"session",
".",
"Commit",
"(",
")",
"\n",
"}"
] | // CreateTables create tabls according bean | [
"CreateTables",
"create",
"tabls",
"according",
"bean"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1310-L1327 | train |
go-xorm/xorm | engine.go | DropTables | 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()
} | go | 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()
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DropTables",
"(",
"beans",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n\n",
"err",
":=",
"session",
".",
"Begin",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"bean",
":=",
"range",
"beans",
"{",
"err",
"=",
"session",
".",
"dropTable",
"(",
"bean",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"session",
".",
"Rollback",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"session",
".",
"Commit",
"(",
")",
"\n",
"}"
] | // DropTables drop specify tables | [
"DropTables",
"drop",
"specify",
"tables"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1330-L1347 | train |
go-xorm/xorm | engine.go | DropIndexes | func (engine *Engine) DropIndexes(bean interface{}) error {
session := engine.NewSession()
defer session.Close()
return session.DropIndexes(bean)
} | go | func (engine *Engine) DropIndexes(bean interface{}) error {
session := engine.NewSession()
defer session.Close()
return session.DropIndexes(bean)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"DropIndexes",
"(",
"bean",
"interface",
"{",
"}",
")",
"error",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"DropIndexes",
"(",
"bean",
")",
"\n",
"}"
] | // DropIndexes drop indexes of a table | [
"DropIndexes",
"drop",
"indexes",
"of",
"a",
"table"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1350-L1354 | train |
go-xorm/xorm | engine.go | Insert | func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
session := engine.NewSession()
defer session.Close()
return session.Insert(beans...)
} | go | func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
session := engine.NewSession()
defer session.Close()
return session.Insert(beans...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Insert",
"(",
"beans",
"...",
"interface",
"{",
"}",
")",
"(",
"int64",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"Insert",
"(",
"beans",
"...",
")",
"\n",
"}"
] | // Insert one or more records | [
"Insert",
"one",
"or",
"more",
"records"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1385-L1389 | train |
go-xorm/xorm | engine.go | Iterate | func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error {
session := engine.NewSession()
defer session.Close()
return session.Iterate(bean, fun)
} | go | func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error {
session := engine.NewSession()
defer session.Close()
return session.Iterate(bean, fun)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Iterate",
"(",
"bean",
"interface",
"{",
"}",
",",
"fun",
"IterFunc",
")",
"error",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"Iterate",
"(",
"bean",
",",
"fun",
")",
"\n",
"}"
] | // Iterate record by record handle records from table, bean's non-empty fields
// are conditions. | [
"Iterate",
"record",
"by",
"record",
"handle",
"records",
"from",
"table",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1450-L1454 | train |
go-xorm/xorm | engine.go | Rows | func (engine *Engine) Rows(bean interface{}) (*Rows, error) {
session := engine.NewSession()
return session.Rows(bean)
} | go | func (engine *Engine) Rows(bean interface{}) (*Rows, error) {
session := engine.NewSession()
return session.Rows(bean)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Rows",
"(",
"bean",
"interface",
"{",
"}",
")",
"(",
"*",
"Rows",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"return",
"session",
".",
"Rows",
"(",
"bean",
")",
"\n",
"}"
] | // Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields
// are conditions. | [
"Rows",
"return",
"sql",
".",
"Rows",
"compatible",
"Rows",
"obj",
"as",
"a",
"forward",
"Iterator",
"object",
"for",
"iterating",
"record",
"by",
"record",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1458-L1461 | train |
go-xorm/xorm | engine.go | Sum | func (engine *Engine) Sum(bean interface{}, colName string) (float64, error) {
session := engine.NewSession()
defer session.Close()
return session.Sum(bean, colName)
} | go | func (engine *Engine) Sum(bean interface{}, colName string) (float64, error) {
session := engine.NewSession()
defer session.Close()
return session.Sum(bean, colName)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Sum",
"(",
"bean",
"interface",
"{",
"}",
",",
"colName",
"string",
")",
"(",
"float64",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"Sum",
"(",
"bean",
",",
"colName",
")",
"\n",
"}"
] | // Sum sum the records by some column. bean's non-empty fields are conditions. | [
"Sum",
"sum",
"the",
"records",
"by",
"some",
"column",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1471-L1475 | train |
go-xorm/xorm | engine.go | SumInt | func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error) {
session := engine.NewSession()
defer session.Close()
return session.SumInt(bean, colName)
} | go | func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error) {
session := engine.NewSession()
defer session.Close()
return session.SumInt(bean, colName)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"SumInt",
"(",
"bean",
"interface",
"{",
"}",
",",
"colName",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"SumInt",
"(",
"bean",
",",
"colName",
")",
"\n",
"}"
] | // SumInt sum the records by some column. bean's non-empty fields are conditions. | [
"SumInt",
"sum",
"the",
"records",
"by",
"some",
"column",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1478-L1482 | train |
go-xorm/xorm | engine.go | Sums | func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error) {
session := engine.NewSession()
defer session.Close()
return session.Sums(bean, colNames...)
} | go | func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error) {
session := engine.NewSession()
defer session.Close()
return session.Sums(bean, colNames...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Sums",
"(",
"bean",
"interface",
"{",
"}",
",",
"colNames",
"...",
"string",
")",
"(",
"[",
"]",
"float64",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"Sums",
"(",
"bean",
",",
"colNames",
"...",
")",
"\n",
"}"
] | // Sums sum the records by some columns. bean's non-empty fields are conditions. | [
"Sums",
"sum",
"the",
"records",
"by",
"some",
"columns",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1485-L1489 | train |
go-xorm/xorm | engine.go | SumsInt | func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, error) {
session := engine.NewSession()
defer session.Close()
return session.SumsInt(bean, colNames...)
} | go | func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, error) {
session := engine.NewSession()
defer session.Close()
return session.SumsInt(bean, colNames...)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"SumsInt",
"(",
"bean",
"interface",
"{",
"}",
",",
"colNames",
"...",
"string",
")",
"(",
"[",
"]",
"int64",
",",
"error",
")",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"SumsInt",
"(",
"bean",
",",
"colNames",
"...",
")",
"\n",
"}"
] | // SumsInt like Sums but return slice of int64 instead of float64. | [
"SumsInt",
"like",
"Sums",
"but",
"return",
"slice",
"of",
"int64",
"instead",
"of",
"float64",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1492-L1496 | train |
go-xorm/xorm | engine.go | ImportFile | func (engine *Engine) ImportFile(ddlPath string) ([]sql.Result, error) {
file, err := os.Open(ddlPath)
if err != nil {
return nil, err
}
defer file.Close()
return engine.Import(file)
} | go | func (engine *Engine) ImportFile(ddlPath string) ([]sql.Result, error) {
file, err := os.Open(ddlPath)
if err != nil {
return nil, err
}
defer file.Close()
return engine.Import(file)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"ImportFile",
"(",
"ddlPath",
"string",
")",
"(",
"[",
"]",
"sql",
".",
"Result",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"ddlPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n",
"return",
"engine",
".",
"Import",
"(",
"file",
")",
"\n",
"}"
] | // ImportFile SQL DDL file | [
"ImportFile",
"SQL",
"DDL",
"file"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1499-L1506 | train |
go-xorm/xorm | engine.go | Import | func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
var results []sql.Result
var lastError error
scanner := bufio.NewScanner(r)
semiColSpliter := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
if atEOF && len(data) == 0 {
return 0, nil, nil
}
if i := bytes.IndexByte(data, ';'); i >= 0 {
return i + 1, data[0:i], nil
}
// If we're at EOF, we have a final, non-terminated line. Return it.
if atEOF {
return len(data), data, nil
}
// Request more data.
return 0, nil, nil
}
scanner.Split(semiColSpliter)
for scanner.Scan() {
query := strings.Trim(scanner.Text(), " \t\n\r")
if len(query) > 0 {
engine.logSQL(query)
result, err := engine.DB().Exec(query)
results = append(results, result)
if err != nil {
return nil, err
}
}
}
return results, lastError
} | go | func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
var results []sql.Result
var lastError error
scanner := bufio.NewScanner(r)
semiColSpliter := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
if atEOF && len(data) == 0 {
return 0, nil, nil
}
if i := bytes.IndexByte(data, ';'); i >= 0 {
return i + 1, data[0:i], nil
}
// If we're at EOF, we have a final, non-terminated line. Return it.
if atEOF {
return len(data), data, nil
}
// Request more data.
return 0, nil, nil
}
scanner.Split(semiColSpliter)
for scanner.Scan() {
query := strings.Trim(scanner.Text(), " \t\n\r")
if len(query) > 0 {
engine.logSQL(query)
result, err := engine.DB().Exec(query)
results = append(results, result)
if err != nil {
return nil, err
}
}
}
return results, lastError
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Import",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"[",
"]",
"sql",
".",
"Result",
",",
"error",
")",
"{",
"var",
"results",
"[",
"]",
"sql",
".",
"Result",
"\n",
"var",
"lastError",
"error",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"r",
")",
"\n\n",
"semiColSpliter",
":=",
"func",
"(",
"data",
"[",
"]",
"byte",
",",
"atEOF",
"bool",
")",
"(",
"advance",
"int",
",",
"token",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"if",
"atEOF",
"&&",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"if",
"i",
":=",
"bytes",
".",
"IndexByte",
"(",
"data",
",",
"';'",
")",
";",
"i",
">=",
"0",
"{",
"return",
"i",
"+",
"1",
",",
"data",
"[",
"0",
":",
"i",
"]",
",",
"nil",
"\n",
"}",
"\n",
"// If we're at EOF, we have a final, non-terminated line. Return it.",
"if",
"atEOF",
"{",
"return",
"len",
"(",
"data",
")",
",",
"data",
",",
"nil",
"\n",
"}",
"\n",
"// Request more data.",
"return",
"0",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"scanner",
".",
"Split",
"(",
"semiColSpliter",
")",
"\n\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"query",
":=",
"strings",
".",
"Trim",
"(",
"scanner",
".",
"Text",
"(",
")",
",",
"\"",
"\\t",
"\\n",
"\\r",
"\"",
")",
"\n",
"if",
"len",
"(",
"query",
")",
">",
"0",
"{",
"engine",
".",
"logSQL",
"(",
"query",
")",
"\n",
"result",
",",
"err",
":=",
"engine",
".",
"DB",
"(",
")",
".",
"Exec",
"(",
"query",
")",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"results",
",",
"lastError",
"\n",
"}"
] | // Import SQL DDL from io.Reader | [
"Import",
"SQL",
"DDL",
"from",
"io",
".",
"Reader"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1509-L1544 | train |
go-xorm/xorm | engine.go | nowTime | func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) {
t := time.Now()
var tz = engine.DatabaseTZ
if !col.DisableTimeZone && col.TimeZone != nil {
tz = col.TimeZone
}
return engine.formatTime(col.SQLType.Name, t.In(tz)), t.In(engine.TZLocation)
} | go | func (engine *Engine) nowTime(col *core.Column) (interface{}, time.Time) {
t := time.Now()
var tz = engine.DatabaseTZ
if !col.DisableTimeZone && col.TimeZone != nil {
tz = col.TimeZone
}
return engine.formatTime(col.SQLType.Name, t.In(tz)), t.In(engine.TZLocation)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"nowTime",
"(",
"col",
"*",
"core",
".",
"Column",
")",
"(",
"interface",
"{",
"}",
",",
"time",
".",
"Time",
")",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"var",
"tz",
"=",
"engine",
".",
"DatabaseTZ",
"\n",
"if",
"!",
"col",
".",
"DisableTimeZone",
"&&",
"col",
".",
"TimeZone",
"!=",
"nil",
"{",
"tz",
"=",
"col",
".",
"TimeZone",
"\n",
"}",
"\n",
"return",
"engine",
".",
"formatTime",
"(",
"col",
".",
"SQLType",
".",
"Name",
",",
"t",
".",
"In",
"(",
"tz",
")",
")",
",",
"t",
".",
"In",
"(",
"engine",
".",
"TZLocation",
")",
"\n",
"}"
] | // nowTime return current time | [
"nowTime",
"return",
"current",
"time"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1547-L1554 | train |
go-xorm/xorm | engine.go | formatTime | func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}) {
switch sqlTypeName {
case core.Time:
s := t.Format("2006-01-02 15:04:05") //time.RFC3339
v = s[11:19]
case core.Date:
v = t.Format("2006-01-02")
case core.DateTime, core.TimeStamp:
v = t.Format("2006-01-02 15:04:05")
case core.TimeStampz:
if engine.dialect.DBType() == core.MSSQL {
v = t.Format("2006-01-02T15:04:05.9999999Z07:00")
} else {
v = t.Format(time.RFC3339Nano)
}
case core.BigInt, core.Int:
v = t.Unix()
default:
v = t
}
return
} | go | func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}) {
switch sqlTypeName {
case core.Time:
s := t.Format("2006-01-02 15:04:05") //time.RFC3339
v = s[11:19]
case core.Date:
v = t.Format("2006-01-02")
case core.DateTime, core.TimeStamp:
v = t.Format("2006-01-02 15:04:05")
case core.TimeStampz:
if engine.dialect.DBType() == core.MSSQL {
v = t.Format("2006-01-02T15:04:05.9999999Z07:00")
} else {
v = t.Format(time.RFC3339Nano)
}
case core.BigInt, core.Int:
v = t.Unix()
default:
v = t
}
return
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"formatTime",
"(",
"sqlTypeName",
"string",
",",
"t",
"time",
".",
"Time",
")",
"(",
"v",
"interface",
"{",
"}",
")",
"{",
"switch",
"sqlTypeName",
"{",
"case",
"core",
".",
"Time",
":",
"s",
":=",
"t",
".",
"Format",
"(",
"\"",
"\"",
")",
"//time.RFC3339",
"\n",
"v",
"=",
"s",
"[",
"11",
":",
"19",
"]",
"\n",
"case",
"core",
".",
"Date",
":",
"v",
"=",
"t",
".",
"Format",
"(",
"\"",
"\"",
")",
"\n",
"case",
"core",
".",
"DateTime",
",",
"core",
".",
"TimeStamp",
":",
"v",
"=",
"t",
".",
"Format",
"(",
"\"",
"\"",
")",
"\n",
"case",
"core",
".",
"TimeStampz",
":",
"if",
"engine",
".",
"dialect",
".",
"DBType",
"(",
")",
"==",
"core",
".",
"MSSQL",
"{",
"v",
"=",
"t",
".",
"Format",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"v",
"=",
"t",
".",
"Format",
"(",
"time",
".",
"RFC3339Nano",
")",
"\n",
"}",
"\n",
"case",
"core",
".",
"BigInt",
",",
"core",
".",
"Int",
":",
"v",
"=",
"t",
".",
"Unix",
"(",
")",
"\n",
"default",
":",
"v",
"=",
"t",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // formatTime format time as column type | [
"formatTime",
"format",
"time",
"as",
"column",
"type"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1571-L1592 | train |
go-xorm/xorm | engine.go | SetSchema | func (engine *Engine) SetSchema(schema string) {
engine.dialect.URI().Schema = schema
} | go | func (engine *Engine) SetSchema(schema string) {
engine.dialect.URI().Schema = schema
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"SetSchema",
"(",
"schema",
"string",
")",
"{",
"engine",
".",
"dialect",
".",
"URI",
"(",
")",
".",
"Schema",
"=",
"schema",
"\n",
"}"
] | // SetSchema sets the schema of database | [
"SetSchema",
"sets",
"the",
"schema",
"of",
"database"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine.go#L1625-L1627 | train |
go-xorm/xorm | logger.go | NewSimpleLogger2 | func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger {
return NewSimpleLogger3(out, prefix, flag, DEFAULT_LOG_LEVEL)
} | go | func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger {
return NewSimpleLogger3(out, prefix, flag, DEFAULT_LOG_LEVEL)
} | [
"func",
"NewSimpleLogger2",
"(",
"out",
"io",
".",
"Writer",
",",
"prefix",
"string",
",",
"flag",
"int",
")",
"*",
"SimpleLogger",
"{",
"return",
"NewSimpleLogger3",
"(",
"out",
",",
"prefix",
",",
"flag",
",",
"DEFAULT_LOG_LEVEL",
")",
"\n",
"}"
] | // NewSimpleLogger2 let you customrize your logger prefix and flag | [
"NewSimpleLogger2",
"let",
"you",
"customrize",
"your",
"logger",
"prefix",
"and",
"flag"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/logger.go#L85-L87 | train |
go-xorm/xorm | logger.go | NewSimpleLogger3 | 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,
}
} | go | 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,
}
} | [
"func",
"NewSimpleLogger3",
"(",
"out",
"io",
".",
"Writer",
",",
"prefix",
"string",
",",
"flag",
"int",
",",
"l",
"core",
".",
"LogLevel",
")",
"*",
"SimpleLogger",
"{",
"return",
"&",
"SimpleLogger",
"{",
"DEBUG",
":",
"log",
".",
"New",
"(",
"out",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
")",
",",
"flag",
")",
",",
"ERR",
":",
"log",
".",
"New",
"(",
"out",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
")",
",",
"flag",
")",
",",
"INFO",
":",
"log",
".",
"New",
"(",
"out",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
")",
",",
"flag",
")",
",",
"WARN",
":",
"log",
".",
"New",
"(",
"out",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
")",
",",
"flag",
")",
",",
"level",
":",
"l",
",",
"}",
"\n",
"}"
] | // NewSimpleLogger3 let you customrize your logger prefix and flag and logLevel | [
"NewSimpleLogger3",
"let",
"you",
"customrize",
"your",
"logger",
"prefix",
"and",
"flag",
"and",
"logLevel"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/logger.go#L90-L98 | train |
go-xorm/xorm | examples/conversion.go | FromDB | func (s *Status) FromDB(bytes []byte) error {
if r, ok := Statuses[string(bytes)]; ok {
*s = r
return nil
}
return errors.New("no this data")
} | go | func (s *Status) FromDB(bytes []byte) error {
if r, ok := Statuses[string(bytes)]; ok {
*s = r
return nil
}
return errors.New("no this data")
} | [
"func",
"(",
"s",
"*",
"Status",
")",
"FromDB",
"(",
"bytes",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"r",
",",
"ok",
":=",
"Statuses",
"[",
"string",
"(",
"bytes",
")",
"]",
";",
"ok",
"{",
"*",
"s",
"=",
"r",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // FromDB implemented xorm.Conversion convent database data to self | [
"FromDB",
"implemented",
"xorm",
".",
"Conversion",
"convent",
"database",
"data",
"to",
"self"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/examples/conversion.go#L31-L37 | train |
go-xorm/xorm | engine_context.go | Context | func (engine *Engine) Context(ctx context.Context) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Context(ctx)
} | go | func (engine *Engine) Context(ctx context.Context) *Session {
session := engine.NewSession()
session.isAutoClose = true
return session.Context(ctx)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"Context",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Session",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"session",
".",
"isAutoClose",
"=",
"true",
"\n",
"return",
"session",
".",
"Context",
"(",
"ctx",
")",
"\n",
"}"
] | // Context creates a session with the context | [
"Context",
"creates",
"a",
"session",
"with",
"the",
"context"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_context.go#L12-L16 | train |
go-xorm/xorm | engine_context.go | PingContext | func (engine *Engine) PingContext(ctx context.Context) error {
session := engine.NewSession()
defer session.Close()
return session.PingContext(ctx)
} | go | func (engine *Engine) PingContext(ctx context.Context) error {
session := engine.NewSession()
defer session.Close()
return session.PingContext(ctx)
} | [
"func",
"(",
"engine",
"*",
"Engine",
")",
"PingContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"session",
":=",
"engine",
".",
"NewSession",
"(",
")",
"\n",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"return",
"session",
".",
"PingContext",
"(",
"ctx",
")",
"\n",
"}"
] | // PingContext tests if database is alive | [
"PingContext",
"tests",
"if",
"database",
"is",
"alive"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/engine_context.go#L24-L28 | train |
go-xorm/xorm | rows.go | Next | func (rows *Rows) Next() bool {
if rows.lastError == nil && rows.rows != nil {
hasNext := rows.rows.Next()
if !hasNext {
rows.lastError = sql.ErrNoRows
}
return hasNext
}
return false
} | go | func (rows *Rows) Next() bool {
if rows.lastError == nil && rows.rows != nil {
hasNext := rows.rows.Next()
if !hasNext {
rows.lastError = sql.ErrNoRows
}
return hasNext
}
return false
} | [
"func",
"(",
"rows",
"*",
"Rows",
")",
"Next",
"(",
")",
"bool",
"{",
"if",
"rows",
".",
"lastError",
"==",
"nil",
"&&",
"rows",
".",
"rows",
"!=",
"nil",
"{",
"hasNext",
":=",
"rows",
".",
"rows",
".",
"Next",
"(",
")",
"\n",
"if",
"!",
"hasNext",
"{",
"rows",
".",
"lastError",
"=",
"sql",
".",
"ErrNoRows",
"\n",
"}",
"\n",
"return",
"hasNext",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // Next move cursor to next record, return false if end has reached | [
"Next",
"move",
"cursor",
"to",
"next",
"record",
"return",
"false",
"if",
"end",
"has",
"reached"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/rows.go#L61-L70 | train |
go-xorm/xorm | session_schema.go | DropIndexes | func (session *Session) DropIndexes(bean interface{}) error {
if session.isAutoClose {
defer session.Close()
}
return session.dropIndexes(bean)
} | go | func (session *Session) DropIndexes(bean interface{}) error {
if session.isAutoClose {
defer session.Close()
}
return session.dropIndexes(bean)
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"DropIndexes",
"(",
"bean",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"session",
".",
"isAutoClose",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"session",
".",
"dropIndexes",
"(",
"bean",
")",
"\n",
"}"
] | // DropIndexes drop indexes | [
"DropIndexes",
"drop",
"indexes"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_schema.go#L92-L98 | train |
go-xorm/xorm | session_schema.go | isIndexExist2 | func (session *Session) isIndexExist2(tableName string, cols []string, unique bool) (bool, error) {
indexes, err := session.engine.dialect.GetIndexes(tableName)
if err != nil {
return false, err
}
for _, index := range indexes {
if sliceEq(index.Cols, cols) {
if unique {
return index.Type == core.UniqueType, nil
}
return index.Type == core.IndexType, nil
}
}
return false, nil
} | go | func (session *Session) isIndexExist2(tableName string, cols []string, unique bool) (bool, error) {
indexes, err := session.engine.dialect.GetIndexes(tableName)
if err != nil {
return false, err
}
for _, index := range indexes {
if sliceEq(index.Cols, cols) {
if unique {
return index.Type == core.UniqueType, nil
}
return index.Type == core.IndexType, nil
}
}
return false, nil
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"isIndexExist2",
"(",
"tableName",
"string",
",",
"cols",
"[",
"]",
"string",
",",
"unique",
"bool",
")",
"(",
"bool",
",",
"error",
")",
"{",
"indexes",
",",
"err",
":=",
"session",
".",
"engine",
".",
"dialect",
".",
"GetIndexes",
"(",
"tableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"index",
":=",
"range",
"indexes",
"{",
"if",
"sliceEq",
"(",
"index",
".",
"Cols",
",",
"cols",
")",
"{",
"if",
"unique",
"{",
"return",
"index",
".",
"Type",
"==",
"core",
".",
"UniqueType",
",",
"nil",
"\n",
"}",
"\n",
"return",
"index",
".",
"Type",
"==",
"core",
".",
"IndexType",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // find if index is exist according cols | [
"find",
"if",
"index",
"is",
"exist",
"according",
"cols"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_schema.go#L184-L199 | train |
go-xorm/xorm | session_tx.go | Commit | func (session *Session) Commit() error {
if !session.isAutoCommit && !session.isCommitedOrRollbacked {
session.saveLastSQL("COMMIT")
session.isCommitedOrRollbacked = true
session.isAutoCommit = true
var err error
if err = session.tx.Commit(); err == nil {
// handle processors after tx committed
closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
if closuresPtr != nil {
for _, closure := range *closuresPtr {
closure(bean)
}
}
}
for bean, closuresPtr := range session.afterInsertBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
processor.AfterInsert()
}
}
for bean, closuresPtr := range session.afterUpdateBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
processor.AfterUpdate()
}
}
for bean, closuresPtr := range session.afterDeleteBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
processor.AfterDelete()
}
}
cleanUpFunc := func(slices *map[interface{}]*[]func(interface{})) {
if len(*slices) > 0 {
*slices = make(map[interface{}]*[]func(interface{}), 0)
}
}
cleanUpFunc(&session.afterInsertBeans)
cleanUpFunc(&session.afterUpdateBeans)
cleanUpFunc(&session.afterDeleteBeans)
}
return err
}
return nil
} | go | func (session *Session) Commit() error {
if !session.isAutoCommit && !session.isCommitedOrRollbacked {
session.saveLastSQL("COMMIT")
session.isCommitedOrRollbacked = true
session.isAutoCommit = true
var err error
if err = session.tx.Commit(); err == nil {
// handle processors after tx committed
closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
if closuresPtr != nil {
for _, closure := range *closuresPtr {
closure(bean)
}
}
}
for bean, closuresPtr := range session.afterInsertBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterInsertProcessor); ok {
processor.AfterInsert()
}
}
for bean, closuresPtr := range session.afterUpdateBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
processor.AfterUpdate()
}
}
for bean, closuresPtr := range session.afterDeleteBeans {
closureCallFunc(closuresPtr, bean)
if processor, ok := interface{}(bean).(AfterDeleteProcessor); ok {
processor.AfterDelete()
}
}
cleanUpFunc := func(slices *map[interface{}]*[]func(interface{})) {
if len(*slices) > 0 {
*slices = make(map[interface{}]*[]func(interface{}), 0)
}
}
cleanUpFunc(&session.afterInsertBeans)
cleanUpFunc(&session.afterUpdateBeans)
cleanUpFunc(&session.afterDeleteBeans)
}
return err
}
return nil
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"Commit",
"(",
")",
"error",
"{",
"if",
"!",
"session",
".",
"isAutoCommit",
"&&",
"!",
"session",
".",
"isCommitedOrRollbacked",
"{",
"session",
".",
"saveLastSQL",
"(",
"\"",
"\"",
")",
"\n",
"session",
".",
"isCommitedOrRollbacked",
"=",
"true",
"\n",
"session",
".",
"isAutoCommit",
"=",
"true",
"\n",
"var",
"err",
"error",
"\n",
"if",
"err",
"=",
"session",
".",
"tx",
".",
"Commit",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"// handle processors after tx committed",
"closureCallFunc",
":=",
"func",
"(",
"closuresPtr",
"*",
"[",
"]",
"func",
"(",
"interface",
"{",
"}",
")",
",",
"bean",
"interface",
"{",
"}",
")",
"{",
"if",
"closuresPtr",
"!=",
"nil",
"{",
"for",
"_",
",",
"closure",
":=",
"range",
"*",
"closuresPtr",
"{",
"closure",
"(",
"bean",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"for",
"bean",
",",
"closuresPtr",
":=",
"range",
"session",
".",
"afterInsertBeans",
"{",
"closureCallFunc",
"(",
"closuresPtr",
",",
"bean",
")",
"\n\n",
"if",
"processor",
",",
"ok",
":=",
"interface",
"{",
"}",
"(",
"bean",
")",
".",
"(",
"AfterInsertProcessor",
")",
";",
"ok",
"{",
"processor",
".",
"AfterInsert",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"bean",
",",
"closuresPtr",
":=",
"range",
"session",
".",
"afterUpdateBeans",
"{",
"closureCallFunc",
"(",
"closuresPtr",
",",
"bean",
")",
"\n\n",
"if",
"processor",
",",
"ok",
":=",
"interface",
"{",
"}",
"(",
"bean",
")",
".",
"(",
"AfterUpdateProcessor",
")",
";",
"ok",
"{",
"processor",
".",
"AfterUpdate",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"bean",
",",
"closuresPtr",
":=",
"range",
"session",
".",
"afterDeleteBeans",
"{",
"closureCallFunc",
"(",
"closuresPtr",
",",
"bean",
")",
"\n\n",
"if",
"processor",
",",
"ok",
":=",
"interface",
"{",
"}",
"(",
"bean",
")",
".",
"(",
"AfterDeleteProcessor",
")",
";",
"ok",
"{",
"processor",
".",
"AfterDelete",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"cleanUpFunc",
":=",
"func",
"(",
"slices",
"*",
"map",
"[",
"interface",
"{",
"}",
"]",
"*",
"[",
"]",
"func",
"(",
"interface",
"{",
"}",
")",
")",
"{",
"if",
"len",
"(",
"*",
"slices",
")",
">",
"0",
"{",
"*",
"slices",
"=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"*",
"[",
"]",
"func",
"(",
"interface",
"{",
"}",
")",
",",
"0",
")",
"\n",
"}",
"\n",
"}",
"\n",
"cleanUpFunc",
"(",
"&",
"session",
".",
"afterInsertBeans",
")",
"\n",
"cleanUpFunc",
"(",
"&",
"session",
".",
"afterUpdateBeans",
")",
"\n",
"cleanUpFunc",
"(",
"&",
"session",
".",
"afterDeleteBeans",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Commit When using transaction, Commit will commit all operations. | [
"Commit",
"When",
"using",
"transaction",
"Commit",
"will",
"commit",
"all",
"operations",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_tx.go#L34-L83 | train |
go-xorm/xorm | session_stats.go | sum | func (session *Session) sum(res interface{}, bean interface{}, columnNames ...string) error {
if session.isAutoClose {
defer session.Close()
}
v := reflect.ValueOf(res)
if v.Kind() != reflect.Ptr {
return errors.New("need a pointer to a variable")
}
var isSlice = v.Elem().Kind() == reflect.Slice
var sqlStr string
var args []interface{}
var err error
if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
if err != nil {
return err
}
} else {
sqlStr = session.statement.RawSQL
args = session.statement.RawParams
}
if isSlice {
err = session.queryRow(sqlStr, args...).ScanSlice(res)
} else {
err = session.queryRow(sqlStr, args...).Scan(res)
}
if err == sql.ErrNoRows || err == nil {
return nil
}
return err
} | go | func (session *Session) sum(res interface{}, bean interface{}, columnNames ...string) error {
if session.isAutoClose {
defer session.Close()
}
v := reflect.ValueOf(res)
if v.Kind() != reflect.Ptr {
return errors.New("need a pointer to a variable")
}
var isSlice = v.Elem().Kind() == reflect.Slice
var sqlStr string
var args []interface{}
var err error
if len(session.statement.RawSQL) == 0 {
sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
if err != nil {
return err
}
} else {
sqlStr = session.statement.RawSQL
args = session.statement.RawParams
}
if isSlice {
err = session.queryRow(sqlStr, args...).ScanSlice(res)
} else {
err = session.queryRow(sqlStr, args...).Scan(res)
}
if err == sql.ErrNoRows || err == nil {
return nil
}
return err
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"sum",
"(",
"res",
"interface",
"{",
"}",
",",
"bean",
"interface",
"{",
"}",
",",
"columnNames",
"...",
"string",
")",
"error",
"{",
"if",
"session",
".",
"isAutoClose",
"{",
"defer",
"session",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"v",
":=",
"reflect",
".",
"ValueOf",
"(",
"res",
")",
"\n",
"if",
"v",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"isSlice",
"=",
"v",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Slice",
"\n",
"var",
"sqlStr",
"string",
"\n",
"var",
"args",
"[",
"]",
"interface",
"{",
"}",
"\n",
"var",
"err",
"error",
"\n",
"if",
"len",
"(",
"session",
".",
"statement",
".",
"RawSQL",
")",
"==",
"0",
"{",
"sqlStr",
",",
"args",
",",
"err",
"=",
"session",
".",
"statement",
".",
"genSumSQL",
"(",
"bean",
",",
"columnNames",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"sqlStr",
"=",
"session",
".",
"statement",
".",
"RawSQL",
"\n",
"args",
"=",
"session",
".",
"statement",
".",
"RawParams",
"\n",
"}",
"\n\n",
"if",
"isSlice",
"{",
"err",
"=",
"session",
".",
"queryRow",
"(",
"sqlStr",
",",
"args",
"...",
")",
".",
"ScanSlice",
"(",
"res",
")",
"\n",
"}",
"else",
"{",
"err",
"=",
"session",
".",
"queryRow",
"(",
"sqlStr",
",",
"args",
"...",
")",
".",
"Scan",
"(",
"res",
")",
"\n",
"}",
"\n",
"if",
"err",
"==",
"sql",
".",
"ErrNoRows",
"||",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // sum call sum some column. bean's non-empty fields are conditions. | [
"sum",
"call",
"sum",
"some",
"column",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_stats.go#L43-L76 | train |
go-xorm/xorm | session_stats.go | SumInt | func (session *Session) SumInt(bean interface{}, columnName string) (res int64, err error) {
return res, session.sum(&res, bean, columnName)
} | go | func (session *Session) SumInt(bean interface{}, columnName string) (res int64, err error) {
return res, session.sum(&res, bean, columnName)
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"SumInt",
"(",
"bean",
"interface",
"{",
"}",
",",
"columnName",
"string",
")",
"(",
"res",
"int64",
",",
"err",
"error",
")",
"{",
"return",
"res",
",",
"session",
".",
"sum",
"(",
"&",
"res",
",",
"bean",
",",
"columnName",
")",
"\n",
"}"
] | // SumInt call sum some column. bean's non-empty fields are conditions. | [
"SumInt",
"call",
"sum",
"some",
"column",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_stats.go#L84-L86 | train |
go-xorm/xorm | session_stats.go | Sums | func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
var res = make([]float64, len(columnNames), len(columnNames))
return res, session.sum(&res, bean, columnNames...)
} | go | func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
var res = make([]float64, len(columnNames), len(columnNames))
return res, session.sum(&res, bean, columnNames...)
} | [
"func",
"(",
"session",
"*",
"Session",
")",
"Sums",
"(",
"bean",
"interface",
"{",
"}",
",",
"columnNames",
"...",
"string",
")",
"(",
"[",
"]",
"float64",
",",
"error",
")",
"{",
"var",
"res",
"=",
"make",
"(",
"[",
"]",
"float64",
",",
"len",
"(",
"columnNames",
")",
",",
"len",
"(",
"columnNames",
")",
")",
"\n",
"return",
"res",
",",
"session",
".",
"sum",
"(",
"&",
"res",
",",
"bean",
",",
"columnNames",
"...",
")",
"\n",
"}"
] | // Sums call sum some columns. bean's non-empty fields are conditions. | [
"Sums",
"call",
"sum",
"some",
"columns",
".",
"bean",
"s",
"non",
"-",
"empty",
"fields",
"are",
"conditions",
"."
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/session_stats.go#L89-L92 | train |
go-xorm/xorm | cache_memory_store.go | Put | func (s *MemoryStore) Put(key string, value interface{}) error {
s.mutex.Lock()
defer s.mutex.Unlock()
s.store[key] = value
return nil
} | go | func (s *MemoryStore) Put(key string, value interface{}) error {
s.mutex.Lock()
defer s.mutex.Unlock()
s.store[key] = value
return nil
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Put",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"s",
".",
"store",
"[",
"key",
"]",
"=",
"value",
"\n",
"return",
"nil",
"\n",
"}"
] | // Put puts object into store | [
"Put",
"puts",
"object",
"into",
"store"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_memory_store.go#L27-L32 | train |
go-xorm/xorm | cache_memory_store.go | Get | func (s *MemoryStore) Get(key string) (interface{}, error) {
s.mutex.RLock()
defer s.mutex.RUnlock()
if v, ok := s.store[key]; ok {
return v, nil
}
return nil, ErrNotExist
} | go | func (s *MemoryStore) Get(key string) (interface{}, error) {
s.mutex.RLock()
defer s.mutex.RUnlock()
if v, ok := s.store[key]; ok {
return v, nil
}
return nil, ErrNotExist
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"v",
",",
"ok",
":=",
"s",
".",
"store",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"v",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"ErrNotExist",
"\n",
"}"
] | // Get gets object from store | [
"Get",
"gets",
"object",
"from",
"store"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_memory_store.go#L35-L43 | train |
go-xorm/xorm | cache_memory_store.go | Del | func (s *MemoryStore) Del(key string) error {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.store, key)
return nil
} | go | func (s *MemoryStore) Del(key string) error {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.store, key)
return nil
} | [
"func",
"(",
"s",
"*",
"MemoryStore",
")",
"Del",
"(",
"key",
"string",
")",
"error",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"store",
",",
"key",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Del deletes object | [
"Del",
"deletes",
"object"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/cache_memory_store.go#L46-L51 | train |
go-xorm/xorm | statement.go | Init | func (statement *Statement) Init() {
statement.RefTable = nil
statement.Start = 0
statement.LimitN = 0
statement.OrderStr = ""
statement.UseCascade = true
statement.JoinStr = ""
statement.joinArgs = make([]interface{}, 0)
statement.GroupByStr = ""
statement.HavingStr = ""
statement.ColumnStr = ""
statement.OmitStr = ""
statement.columnMap = columnMap{}
statement.omitColumnMap = columnMap{}
statement.AltTableName = ""
statement.tableName = ""
statement.idParam = nil
statement.RawSQL = ""
statement.RawParams = make([]interface{}, 0)
statement.UseCache = true
statement.UseAutoTime = true
statement.noAutoCondition = false
statement.IsDistinct = false
statement.IsForUpdate = false
statement.TableAlias = ""
statement.selectStr = ""
statement.allUseBool = false
statement.useAllCols = false
statement.mustColumnMap = make(map[string]bool)
statement.nullableMap = make(map[string]bool)
statement.checkVersion = true
statement.unscoped = false
statement.incrColumns = make(map[string]incrParam)
statement.decrColumns = make(map[string]decrParam)
statement.exprColumns = make(map[string]exprParam)
statement.cond = builder.NewCond()
statement.bufferSize = 0
statement.context = nil
statement.lastError = nil
} | go | func (statement *Statement) Init() {
statement.RefTable = nil
statement.Start = 0
statement.LimitN = 0
statement.OrderStr = ""
statement.UseCascade = true
statement.JoinStr = ""
statement.joinArgs = make([]interface{}, 0)
statement.GroupByStr = ""
statement.HavingStr = ""
statement.ColumnStr = ""
statement.OmitStr = ""
statement.columnMap = columnMap{}
statement.omitColumnMap = columnMap{}
statement.AltTableName = ""
statement.tableName = ""
statement.idParam = nil
statement.RawSQL = ""
statement.RawParams = make([]interface{}, 0)
statement.UseCache = true
statement.UseAutoTime = true
statement.noAutoCondition = false
statement.IsDistinct = false
statement.IsForUpdate = false
statement.TableAlias = ""
statement.selectStr = ""
statement.allUseBool = false
statement.useAllCols = false
statement.mustColumnMap = make(map[string]bool)
statement.nullableMap = make(map[string]bool)
statement.checkVersion = true
statement.unscoped = false
statement.incrColumns = make(map[string]incrParam)
statement.decrColumns = make(map[string]decrParam)
statement.exprColumns = make(map[string]exprParam)
statement.cond = builder.NewCond()
statement.bufferSize = 0
statement.context = nil
statement.lastError = nil
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Init",
"(",
")",
"{",
"statement",
".",
"RefTable",
"=",
"nil",
"\n",
"statement",
".",
"Start",
"=",
"0",
"\n",
"statement",
".",
"LimitN",
"=",
"0",
"\n",
"statement",
".",
"OrderStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"UseCascade",
"=",
"true",
"\n",
"statement",
".",
"JoinStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"joinArgs",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"statement",
".",
"GroupByStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"HavingStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"ColumnStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"OmitStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"columnMap",
"=",
"columnMap",
"{",
"}",
"\n",
"statement",
".",
"omitColumnMap",
"=",
"columnMap",
"{",
"}",
"\n",
"statement",
".",
"AltTableName",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"tableName",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"idParam",
"=",
"nil",
"\n",
"statement",
".",
"RawSQL",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"RawParams",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"statement",
".",
"UseCache",
"=",
"true",
"\n",
"statement",
".",
"UseAutoTime",
"=",
"true",
"\n",
"statement",
".",
"noAutoCondition",
"=",
"false",
"\n",
"statement",
".",
"IsDistinct",
"=",
"false",
"\n",
"statement",
".",
"IsForUpdate",
"=",
"false",
"\n",
"statement",
".",
"TableAlias",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"selectStr",
"=",
"\"",
"\"",
"\n",
"statement",
".",
"allUseBool",
"=",
"false",
"\n",
"statement",
".",
"useAllCols",
"=",
"false",
"\n",
"statement",
".",
"mustColumnMap",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"statement",
".",
"nullableMap",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"statement",
".",
"checkVersion",
"=",
"true",
"\n",
"statement",
".",
"unscoped",
"=",
"false",
"\n",
"statement",
".",
"incrColumns",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"incrParam",
")",
"\n",
"statement",
".",
"decrColumns",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"decrParam",
")",
"\n",
"statement",
".",
"exprColumns",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"exprParam",
")",
"\n",
"statement",
".",
"cond",
"=",
"builder",
".",
"NewCond",
"(",
")",
"\n",
"statement",
".",
"bufferSize",
"=",
"0",
"\n",
"statement",
".",
"context",
"=",
"nil",
"\n",
"statement",
".",
"lastError",
"=",
"nil",
"\n",
"}"
] | // Init reset all the statement's fields | [
"Init",
"reset",
"all",
"the",
"statement",
"s",
"fields"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L66-L105 | train |
go-xorm/xorm | statement.go | NoAutoCondition | func (statement *Statement) NoAutoCondition(no ...bool) *Statement {
statement.noAutoCondition = true
if len(no) > 0 {
statement.noAutoCondition = no[0]
}
return statement
} | go | func (statement *Statement) NoAutoCondition(no ...bool) *Statement {
statement.noAutoCondition = true
if len(no) > 0 {
statement.noAutoCondition = no[0]
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"NoAutoCondition",
"(",
"no",
"...",
"bool",
")",
"*",
"Statement",
"{",
"statement",
".",
"noAutoCondition",
"=",
"true",
"\n",
"if",
"len",
"(",
"no",
")",
">",
"0",
"{",
"statement",
".",
"noAutoCondition",
"=",
"no",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // NoAutoCondition if you do not want convert bean's field as query condition, then use this function | [
"NoAutoCondition",
"if",
"you",
"do",
"not",
"want",
"convert",
"bean",
"s",
"field",
"as",
"query",
"condition",
"then",
"use",
"this",
"function"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L108-L114 | train |
go-xorm/xorm | statement.go | SQL | func (statement *Statement) SQL(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case (*builder.Builder):
var err error
statement.RawSQL, statement.RawParams, err = query.(*builder.Builder).ToSQL()
if err != nil {
statement.lastError = err
}
case string:
statement.RawSQL = query.(string)
statement.RawParams = args
default:
statement.lastError = ErrUnSupportedSQLType
}
return statement
} | go | func (statement *Statement) SQL(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case (*builder.Builder):
var err error
statement.RawSQL, statement.RawParams, err = query.(*builder.Builder).ToSQL()
if err != nil {
statement.lastError = err
}
case string:
statement.RawSQL = query.(string)
statement.RawParams = args
default:
statement.lastError = ErrUnSupportedSQLType
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"SQL",
"(",
"query",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"switch",
"query",
".",
"(",
"type",
")",
"{",
"case",
"(",
"*",
"builder",
".",
"Builder",
")",
":",
"var",
"err",
"error",
"\n",
"statement",
".",
"RawSQL",
",",
"statement",
".",
"RawParams",
",",
"err",
"=",
"query",
".",
"(",
"*",
"builder",
".",
"Builder",
")",
".",
"ToSQL",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"statement",
".",
"lastError",
"=",
"err",
"\n",
"}",
"\n",
"case",
"string",
":",
"statement",
".",
"RawSQL",
"=",
"query",
".",
"(",
"string",
")",
"\n",
"statement",
".",
"RawParams",
"=",
"args",
"\n",
"default",
":",
"statement",
".",
"lastError",
"=",
"ErrUnSupportedSQLType",
"\n",
"}",
"\n\n",
"return",
"statement",
"\n",
"}"
] | // SQL adds raw sql statement | [
"SQL",
"adds",
"raw",
"sql",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L123-L139 | train |
go-xorm/xorm | statement.go | Where | func (statement *Statement) Where(query interface{}, args ...interface{}) *Statement {
return statement.And(query, args...)
} | go | func (statement *Statement) Where(query interface{}, args ...interface{}) *Statement {
return statement.And(query, args...)
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Where",
"(",
"query",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"return",
"statement",
".",
"And",
"(",
"query",
",",
"args",
"...",
")",
"\n",
"}"
] | // Where add Where statement | [
"Where",
"add",
"Where",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L142-L144 | train |
go-xorm/xorm | statement.go | And | func (statement *Statement) And(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case string:
cond := builder.Expr(query.(string), args...)
statement.cond = statement.cond.And(cond)
case map[string]interface{}:
cond := builder.Eq(query.(map[string]interface{}))
statement.cond = statement.cond.And(cond)
case builder.Cond:
cond := query.(builder.Cond)
statement.cond = statement.cond.And(cond)
for _, v := range args {
if vv, ok := v.(builder.Cond); ok {
statement.cond = statement.cond.And(vv)
}
}
default:
statement.lastError = ErrConditionType
}
return statement
} | go | func (statement *Statement) And(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case string:
cond := builder.Expr(query.(string), args...)
statement.cond = statement.cond.And(cond)
case map[string]interface{}:
cond := builder.Eq(query.(map[string]interface{}))
statement.cond = statement.cond.And(cond)
case builder.Cond:
cond := query.(builder.Cond)
statement.cond = statement.cond.And(cond)
for _, v := range args {
if vv, ok := v.(builder.Cond); ok {
statement.cond = statement.cond.And(vv)
}
}
default:
statement.lastError = ErrConditionType
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"And",
"(",
"query",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"switch",
"query",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"cond",
":=",
"builder",
".",
"Expr",
"(",
"query",
".",
"(",
"string",
")",
",",
"args",
"...",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"And",
"(",
"cond",
")",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"cond",
":=",
"builder",
".",
"Eq",
"(",
"query",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"And",
"(",
"cond",
")",
"\n",
"case",
"builder",
".",
"Cond",
":",
"cond",
":=",
"query",
".",
"(",
"builder",
".",
"Cond",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"And",
"(",
"cond",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"args",
"{",
"if",
"vv",
",",
"ok",
":=",
"v",
".",
"(",
"builder",
".",
"Cond",
")",
";",
"ok",
"{",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"And",
"(",
"vv",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"statement",
".",
"lastError",
"=",
"ErrConditionType",
"\n",
"}",
"\n\n",
"return",
"statement",
"\n",
"}"
] | // And add Where & and statement | [
"And",
"add",
"Where",
"&",
"and",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L147-L168 | train |
go-xorm/xorm | statement.go | Or | func (statement *Statement) Or(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case string:
cond := builder.Expr(query.(string), args...)
statement.cond = statement.cond.Or(cond)
case map[string]interface{}:
cond := builder.Eq(query.(map[string]interface{}))
statement.cond = statement.cond.Or(cond)
case builder.Cond:
cond := query.(builder.Cond)
statement.cond = statement.cond.Or(cond)
for _, v := range args {
if vv, ok := v.(builder.Cond); ok {
statement.cond = statement.cond.Or(vv)
}
}
default:
// TODO: not support condition type
}
return statement
} | go | func (statement *Statement) Or(query interface{}, args ...interface{}) *Statement {
switch query.(type) {
case string:
cond := builder.Expr(query.(string), args...)
statement.cond = statement.cond.Or(cond)
case map[string]interface{}:
cond := builder.Eq(query.(map[string]interface{}))
statement.cond = statement.cond.Or(cond)
case builder.Cond:
cond := query.(builder.Cond)
statement.cond = statement.cond.Or(cond)
for _, v := range args {
if vv, ok := v.(builder.Cond); ok {
statement.cond = statement.cond.Or(vv)
}
}
default:
// TODO: not support condition type
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Or",
"(",
"query",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"switch",
"query",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"cond",
":=",
"builder",
".",
"Expr",
"(",
"query",
".",
"(",
"string",
")",
",",
"args",
"...",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"Or",
"(",
"cond",
")",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"cond",
":=",
"builder",
".",
"Eq",
"(",
"query",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"Or",
"(",
"cond",
")",
"\n",
"case",
"builder",
".",
"Cond",
":",
"cond",
":=",
"query",
".",
"(",
"builder",
".",
"Cond",
")",
"\n",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"Or",
"(",
"cond",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"args",
"{",
"if",
"vv",
",",
"ok",
":=",
"v",
".",
"(",
"builder",
".",
"Cond",
")",
";",
"ok",
"{",
"statement",
".",
"cond",
"=",
"statement",
".",
"cond",
".",
"Or",
"(",
"vv",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"// TODO: not support condition type",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // Or add Where & Or statement | [
"Or",
"add",
"Where",
"&",
"Or",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L171-L191 | train |
go-xorm/xorm | statement.go | TableName | func (statement *Statement) TableName() string {
if statement.AltTableName != "" {
return statement.AltTableName
}
return statement.tableName
} | go | func (statement *Statement) TableName() string {
if statement.AltTableName != "" {
return statement.AltTableName
}
return statement.tableName
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"TableName",
"(",
")",
"string",
"{",
"if",
"statement",
".",
"AltTableName",
"!=",
"\"",
"\"",
"{",
"return",
"statement",
".",
"AltTableName",
"\n",
"}",
"\n\n",
"return",
"statement",
".",
"tableName",
"\n",
"}"
] | // TableName return current tableName | [
"TableName",
"return",
"current",
"tableName"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L500-L506 | train |
go-xorm/xorm | statement.go | ID | func (statement *Statement) ID(id interface{}) *Statement {
idValue := reflect.ValueOf(id)
idType := reflect.TypeOf(idValue.Interface())
switch idType {
case ptrPkType:
if pkPtr, ok := (id).(*core.PK); ok {
statement.idParam = pkPtr
return statement
}
case pkType:
if pk, ok := (id).(core.PK); ok {
statement.idParam = &pk
return statement
}
}
switch idType.Kind() {
case reflect.String:
statement.idParam = &core.PK{idValue.Convert(reflect.TypeOf("")).Interface()}
return statement
}
statement.idParam = &core.PK{id}
return statement
} | go | func (statement *Statement) ID(id interface{}) *Statement {
idValue := reflect.ValueOf(id)
idType := reflect.TypeOf(idValue.Interface())
switch idType {
case ptrPkType:
if pkPtr, ok := (id).(*core.PK); ok {
statement.idParam = pkPtr
return statement
}
case pkType:
if pk, ok := (id).(core.PK); ok {
statement.idParam = &pk
return statement
}
}
switch idType.Kind() {
case reflect.String:
statement.idParam = &core.PK{idValue.Convert(reflect.TypeOf("")).Interface()}
return statement
}
statement.idParam = &core.PK{id}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"ID",
"(",
"id",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"idValue",
":=",
"reflect",
".",
"ValueOf",
"(",
"id",
")",
"\n",
"idType",
":=",
"reflect",
".",
"TypeOf",
"(",
"idValue",
".",
"Interface",
"(",
")",
")",
"\n\n",
"switch",
"idType",
"{",
"case",
"ptrPkType",
":",
"if",
"pkPtr",
",",
"ok",
":=",
"(",
"id",
")",
".",
"(",
"*",
"core",
".",
"PK",
")",
";",
"ok",
"{",
"statement",
".",
"idParam",
"=",
"pkPtr",
"\n",
"return",
"statement",
"\n",
"}",
"\n",
"case",
"pkType",
":",
"if",
"pk",
",",
"ok",
":=",
"(",
"id",
")",
".",
"(",
"core",
".",
"PK",
")",
";",
"ok",
"{",
"statement",
".",
"idParam",
"=",
"&",
"pk",
"\n",
"return",
"statement",
"\n",
"}",
"\n",
"}",
"\n\n",
"switch",
"idType",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"String",
":",
"statement",
".",
"idParam",
"=",
"&",
"core",
".",
"PK",
"{",
"idValue",
".",
"Convert",
"(",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
")",
".",
"Interface",
"(",
")",
"}",
"\n",
"return",
"statement",
"\n",
"}",
"\n\n",
"statement",
".",
"idParam",
"=",
"&",
"core",
".",
"PK",
"{",
"id",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // ID generate "where id = ? " statement or for composite key "where key1 = ? and key2 = ?" | [
"ID",
"generate",
"where",
"id",
"=",
"?",
"statement",
"or",
"for",
"composite",
"key",
"where",
"key1",
"=",
"?",
"and",
"key2",
"=",
"?"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L509-L534 | train |
go-xorm/xorm | statement.go | Incr | func (statement *Statement) Incr(column string, arg ...interface{}) *Statement {
k := strings.ToLower(column)
if len(arg) > 0 {
statement.incrColumns[k] = incrParam{column, arg[0]}
} else {
statement.incrColumns[k] = incrParam{column, 1}
}
return statement
} | go | func (statement *Statement) Incr(column string, arg ...interface{}) *Statement {
k := strings.ToLower(column)
if len(arg) > 0 {
statement.incrColumns[k] = incrParam{column, arg[0]}
} else {
statement.incrColumns[k] = incrParam{column, 1}
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Incr",
"(",
"column",
"string",
",",
"arg",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"k",
":=",
"strings",
".",
"ToLower",
"(",
"column",
")",
"\n",
"if",
"len",
"(",
"arg",
")",
">",
"0",
"{",
"statement",
".",
"incrColumns",
"[",
"k",
"]",
"=",
"incrParam",
"{",
"column",
",",
"arg",
"[",
"0",
"]",
"}",
"\n",
"}",
"else",
"{",
"statement",
".",
"incrColumns",
"[",
"k",
"]",
"=",
"incrParam",
"{",
"column",
",",
"1",
"}",
"\n",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // Incr Generate "Update ... Set column = column + arg" statement | [
"Incr",
"Generate",
"Update",
"...",
"Set",
"column",
"=",
"column",
"+",
"arg",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L537-L545 | train |
go-xorm/xorm | statement.go | Decr | func (statement *Statement) Decr(column string, arg ...interface{}) *Statement {
k := strings.ToLower(column)
if len(arg) > 0 {
statement.decrColumns[k] = decrParam{column, arg[0]}
} else {
statement.decrColumns[k] = decrParam{column, 1}
}
return statement
} | go | func (statement *Statement) Decr(column string, arg ...interface{}) *Statement {
k := strings.ToLower(column)
if len(arg) > 0 {
statement.decrColumns[k] = decrParam{column, arg[0]}
} else {
statement.decrColumns[k] = decrParam{column, 1}
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Decr",
"(",
"column",
"string",
",",
"arg",
"...",
"interface",
"{",
"}",
")",
"*",
"Statement",
"{",
"k",
":=",
"strings",
".",
"ToLower",
"(",
"column",
")",
"\n",
"if",
"len",
"(",
"arg",
")",
">",
"0",
"{",
"statement",
".",
"decrColumns",
"[",
"k",
"]",
"=",
"decrParam",
"{",
"column",
",",
"arg",
"[",
"0",
"]",
"}",
"\n",
"}",
"else",
"{",
"statement",
".",
"decrColumns",
"[",
"k",
"]",
"=",
"decrParam",
"{",
"column",
",",
"1",
"}",
"\n",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // Decr Generate "Update ... Set column = column - arg" statement | [
"Decr",
"Generate",
"Update",
"...",
"Set",
"column",
"=",
"column",
"-",
"arg",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L548-L556 | train |
go-xorm/xorm | statement.go | Distinct | func (statement *Statement) Distinct(columns ...string) *Statement {
statement.IsDistinct = true
statement.Cols(columns...)
return statement
} | go | func (statement *Statement) Distinct(columns ...string) *Statement {
statement.IsDistinct = true
statement.Cols(columns...)
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Distinct",
"(",
"columns",
"...",
"string",
")",
"*",
"Statement",
"{",
"statement",
".",
"IsDistinct",
"=",
"true",
"\n",
"statement",
".",
"Cols",
"(",
"columns",
"...",
")",
"\n",
"return",
"statement",
"\n",
"}"
] | // Distinct generates "DISTINCT col1, col2 " statement | [
"Distinct",
"generates",
"DISTINCT",
"col1",
"col2",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L611-L615 | train |
go-xorm/xorm | statement.go | Cols | func (statement *Statement) Cols(columns ...string) *Statement {
cols := col2NewCols(columns...)
for _, nc := range cols {
statement.columnMap.add(nc)
}
newColumns := statement.colmap2NewColsWithQuote()
statement.ColumnStr = strings.Join(newColumns, ", ")
statement.ColumnStr = strings.Replace(statement.ColumnStr, statement.Engine.quote("*"), "*", -1)
return statement
} | go | func (statement *Statement) Cols(columns ...string) *Statement {
cols := col2NewCols(columns...)
for _, nc := range cols {
statement.columnMap.add(nc)
}
newColumns := statement.colmap2NewColsWithQuote()
statement.ColumnStr = strings.Join(newColumns, ", ")
statement.ColumnStr = strings.Replace(statement.ColumnStr, statement.Engine.quote("*"), "*", -1)
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Cols",
"(",
"columns",
"...",
"string",
")",
"*",
"Statement",
"{",
"cols",
":=",
"col2NewCols",
"(",
"columns",
"...",
")",
"\n",
"for",
"_",
",",
"nc",
":=",
"range",
"cols",
"{",
"statement",
".",
"columnMap",
".",
"add",
"(",
"nc",
")",
"\n",
"}",
"\n\n",
"newColumns",
":=",
"statement",
".",
"colmap2NewColsWithQuote",
"(",
")",
"\n\n",
"statement",
".",
"ColumnStr",
"=",
"strings",
".",
"Join",
"(",
"newColumns",
",",
"\"",
"\"",
")",
"\n",
"statement",
".",
"ColumnStr",
"=",
"strings",
".",
"Replace",
"(",
"statement",
".",
"ColumnStr",
",",
"statement",
".",
"Engine",
".",
"quote",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"return",
"statement",
"\n",
"}"
] | // Cols generate "col1, col2" statement | [
"Cols",
"generate",
"col1",
"col2",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L630-L641 | train |
go-xorm/xorm | statement.go | UseBool | func (statement *Statement) UseBool(columns ...string) *Statement {
if len(columns) > 0 {
statement.MustCols(columns...)
} else {
statement.allUseBool = true
}
return statement
} | go | func (statement *Statement) UseBool(columns ...string) *Statement {
if len(columns) > 0 {
statement.MustCols(columns...)
} else {
statement.allUseBool = true
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"UseBool",
"(",
"columns",
"...",
"string",
")",
"*",
"Statement",
"{",
"if",
"len",
"(",
"columns",
")",
">",
"0",
"{",
"statement",
".",
"MustCols",
"(",
"columns",
"...",
")",
"\n",
"}",
"else",
"{",
"statement",
".",
"allUseBool",
"=",
"true",
"\n",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // UseBool indicates that use bool fields as update contents and query contiditions | [
"UseBool",
"indicates",
"that",
"use",
"bool",
"fields",
"as",
"update",
"contents",
"and",
"query",
"contiditions"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L659-L666 | train |
go-xorm/xorm | statement.go | Top | func (statement *Statement) Top(limit int) *Statement {
statement.Limit(limit)
return statement
} | go | func (statement *Statement) Top(limit int) *Statement {
statement.Limit(limit)
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Top",
"(",
"limit",
"int",
")",
"*",
"Statement",
"{",
"statement",
".",
"Limit",
"(",
"limit",
")",
"\n",
"return",
"statement",
"\n",
"}"
] | // Top generate LIMIT limit statement | [
"Top",
"generate",
"LIMIT",
"limit",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L686-L689 | train |
go-xorm/xorm | statement.go | Limit | func (statement *Statement) Limit(limit int, start ...int) *Statement {
statement.LimitN = limit
if len(start) > 0 {
statement.Start = start[0]
}
return statement
} | go | func (statement *Statement) Limit(limit int, start ...int) *Statement {
statement.LimitN = limit
if len(start) > 0 {
statement.Start = start[0]
}
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Limit",
"(",
"limit",
"int",
",",
"start",
"...",
"int",
")",
"*",
"Statement",
"{",
"statement",
".",
"LimitN",
"=",
"limit",
"\n",
"if",
"len",
"(",
"start",
")",
">",
"0",
"{",
"statement",
".",
"Start",
"=",
"start",
"[",
"0",
"]",
"\n",
"}",
"\n",
"return",
"statement",
"\n",
"}"
] | // Limit generate LIMIT start, limit statement | [
"Limit",
"generate",
"LIMIT",
"start",
"limit",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L692-L698 | train |
go-xorm/xorm | statement.go | OrderBy | func (statement *Statement) OrderBy(order string) *Statement {
if len(statement.OrderStr) > 0 {
statement.OrderStr += ", "
}
statement.OrderStr += order
return statement
} | go | func (statement *Statement) OrderBy(order string) *Statement {
if len(statement.OrderStr) > 0 {
statement.OrderStr += ", "
}
statement.OrderStr += order
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"OrderBy",
"(",
"order",
"string",
")",
"*",
"Statement",
"{",
"if",
"len",
"(",
"statement",
".",
"OrderStr",
")",
">",
"0",
"{",
"statement",
".",
"OrderStr",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"statement",
".",
"OrderStr",
"+=",
"order",
"\n",
"return",
"statement",
"\n",
"}"
] | // OrderBy generate "Order By order" statement | [
"OrderBy",
"generate",
"Order",
"By",
"order",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L701-L707 | train |
go-xorm/xorm | statement.go | GroupBy | func (statement *Statement) GroupBy(keys string) *Statement {
statement.GroupByStr = keys
return statement
} | go | func (statement *Statement) GroupBy(keys string) *Statement {
statement.GroupByStr = keys
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"GroupBy",
"(",
"keys",
"string",
")",
"*",
"Statement",
"{",
"statement",
".",
"GroupByStr",
"=",
"keys",
"\n",
"return",
"statement",
"\n",
"}"
] | // GroupBy generate "Group By keys" statement | [
"GroupBy",
"generate",
"Group",
"By",
"keys",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L791-L794 | train |
go-xorm/xorm | statement.go | Having | func (statement *Statement) Having(conditions string) *Statement {
statement.HavingStr = fmt.Sprintf("HAVING %v", conditions)
return statement
} | go | func (statement *Statement) Having(conditions string) *Statement {
statement.HavingStr = fmt.Sprintf("HAVING %v", conditions)
return statement
} | [
"func",
"(",
"statement",
"*",
"Statement",
")",
"Having",
"(",
"conditions",
"string",
")",
"*",
"Statement",
"{",
"statement",
".",
"HavingStr",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"conditions",
")",
"\n",
"return",
"statement",
"\n",
"}"
] | // Having generate "Having conditions" statement | [
"Having",
"generate",
"Having",
"conditions",
"statement"
] | ce804aee6c5118ed9a6bc04754aea4ea65232fe5 | https://github.com/go-xorm/xorm/blob/ce804aee6c5118ed9a6bc04754aea4ea65232fe5/statement.go#L797-L800 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.