repo
stringlengths 5
67
| path
stringlengths 4
218
| func_name
stringlengths 0
151
| original_string
stringlengths 52
373k
| language
stringclasses 6
values | code
stringlengths 52
373k
| code_tokens
listlengths 10
512
| docstring
stringlengths 3
47.2k
| docstring_tokens
listlengths 3
234
| sha
stringlengths 40
40
| url
stringlengths 85
339
| partition
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
xo/xo
|
loaders/sqlite.go
|
SqQueryColumns
|
func SqQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS ` + strings.Join(inspect, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load column information
return SqTableColumns(args.DB, "", xoid)
}
|
go
|
func SqQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS ` + strings.Join(inspect, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load column information
return SqTableColumns(args.DB, "", xoid)
}
|
[
"func",
"SqQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"xoid",
":=",
"\"_xo_\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE TEMPORARY VIEW `",
"+",
"xoid",
"+",
"` AS `",
"+",
"strings",
".",
"Join",
"(",
"inspect",
",",
"\"\\n\"",
")",
"\n",
"\\n",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// SqQueryColumns parses a sqlite query and generates a type for it.
|
[
"SqQueryColumns",
"parses",
"a",
"sqlite",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/sqlite.go#L199-L213
|
train
|
xo/xo
|
examples/django/postgres/authgrouppermission.xo.go
|
AuthGroupPermissionByID
|
func AuthGroupPermissionByID(db XODB, id int) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM public.auth_group_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
}
|
go
|
func AuthGroupPermissionByID(db XODB, id int) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM public.auth_group_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
}
|
[
"func",
"AuthGroupPermissionByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthGroupPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, group_id, permission_id `",
"+",
"`FROM public.auth_group_permissions `",
"+",
"`WHERE id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"agp",
":=",
"AuthGroupPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"agp",
".",
"ID",
",",
"&",
"agp",
".",
"GroupID",
",",
"&",
"agp",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"agp",
",",
"nil",
"\n",
"}"
] |
// AuthGroupPermissionByID retrieves a row from 'public.auth_group_permissions' as a AuthGroupPermission.
//
// Generated from index 'auth_group_permissions_pkey'.
|
[
"AuthGroupPermissionByID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_group_permissions",
"as",
"a",
"AuthGroupPermission",
".",
"Generated",
"from",
"index",
"auth_group_permissions_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authgrouppermission.xo.go#L281-L302
|
train
|
xo/xo
|
examples/django/postgres/djangosession.xo.go
|
Update
|
func (ds *DjangoSession) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ds._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ds._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_session SET (` +
`session_data, expire_date` +
`) = ( ` +
`$1, $2` +
`) WHERE session_key = $3`
// run query
XOLog(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
return err
}
|
go
|
func (ds *DjangoSession) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ds._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ds._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_session SET (` +
`session_data, expire_date` +
`) = ( ` +
`$1, $2` +
`) WHERE session_key = $3`
// run query
XOLog(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
return err
}
|
[
"func",
"(",
"ds",
"*",
"DjangoSession",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ds",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"ds",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE public.django_session SET (`",
"+",
"`session_data, expire_date`",
"+",
"`) = ( `",
"+",
"`$1, $2`",
"+",
"`) WHERE session_key = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ds",
".",
"SessionData",
",",
"ds",
".",
"ExpireDate",
",",
"ds",
".",
"SessionKey",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ds",
".",
"SessionData",
",",
"ds",
".",
"ExpireDate",
",",
"ds",
".",
"SessionKey",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the DjangoSession in the database.
|
[
"Update",
"updates",
"the",
"DjangoSession",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangosession.xo.go#L61-L85
|
train
|
xo/xo
|
examples/django/postgres/djangosession.xo.go
|
DjangoSessionsBySessionKey
|
func DjangoSessionsBySessionKey(db XODB, sessionKey string) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM public.django_session ` +
`WHERE session_key = $1`
// run query
XOLog(sqlstr, sessionKey)
q, err := db.Query(sqlstr, sessionKey)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
}
|
go
|
func DjangoSessionsBySessionKey(db XODB, sessionKey string) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM public.django_session ` +
`WHERE session_key = $1`
// run query
XOLog(sqlstr, sessionKey)
q, err := db.Query(sqlstr, sessionKey)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
}
|
[
"func",
"DjangoSessionsBySessionKey",
"(",
"db",
"XODB",
",",
"sessionKey",
"string",
")",
"(",
"[",
"]",
"*",
"DjangoSession",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`session_key, session_data, expire_date `",
"+",
"`FROM public.django_session `",
"+",
"`WHERE session_key = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"sessionKey",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"sessionKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"DjangoSession",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ds",
":=",
"DjangoSession",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ds",
".",
"SessionKey",
",",
"&",
"ds",
".",
"SessionData",
",",
"&",
"ds",
".",
"ExpireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ds",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// DjangoSessionsBySessionKey retrieves a row from 'public.django_session' as a DjangoSession.
//
// Generated from index 'django_session_session_key_c0390e0f_like'.
|
[
"DjangoSessionsBySessionKey",
"retrieves",
"a",
"row",
"from",
"public",
".",
"django_session",
"as",
"a",
"DjangoSession",
".",
"Generated",
"from",
"index",
"django_session_session_key_c0390e0f_like",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangosession.xo.go#L229-L263
|
train
|
xo/xo
|
internal/templates.go
|
TemplateLoader
|
func (a *ArgType) TemplateLoader(name string) ([]byte, error) {
// no template path specified
if a.TemplatePath == "" {
return templates.Asset(name)
}
return ioutil.ReadFile(path.Join(a.TemplatePath, name))
}
|
go
|
func (a *ArgType) TemplateLoader(name string) ([]byte, error) {
// no template path specified
if a.TemplatePath == "" {
return templates.Asset(name)
}
return ioutil.ReadFile(path.Join(a.TemplatePath, name))
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"TemplateLoader",
"(",
"name",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"a",
".",
"TemplatePath",
"==",
"\"\"",
"{",
"return",
"templates",
".",
"Asset",
"(",
"name",
")",
"\n",
"}",
"\n",
"return",
"ioutil",
".",
"ReadFile",
"(",
"path",
".",
"Join",
"(",
"a",
".",
"TemplatePath",
",",
"name",
")",
")",
"\n",
"}"
] |
// TemplateLoader loads templates from the specified name.
|
[
"TemplateLoader",
"loads",
"templates",
"from",
"the",
"specified",
"name",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/templates.go#L15-L22
|
train
|
xo/xo
|
internal/templates.go
|
TemplateSet
|
func (a *ArgType) TemplateSet() *TemplateSet {
if a.templateSet == nil {
a.templateSet = &TemplateSet{
funcs: a.NewTemplateFuncs(),
l: a.TemplateLoader,
tpls: map[string]*template.Template{},
}
}
return a.templateSet
}
|
go
|
func (a *ArgType) TemplateSet() *TemplateSet {
if a.templateSet == nil {
a.templateSet = &TemplateSet{
funcs: a.NewTemplateFuncs(),
l: a.TemplateLoader,
tpls: map[string]*template.Template{},
}
}
return a.templateSet
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"TemplateSet",
"(",
")",
"*",
"TemplateSet",
"{",
"if",
"a",
".",
"templateSet",
"==",
"nil",
"{",
"a",
".",
"templateSet",
"=",
"&",
"TemplateSet",
"{",
"funcs",
":",
"a",
".",
"NewTemplateFuncs",
"(",
")",
",",
"l",
":",
"a",
".",
"TemplateLoader",
",",
"tpls",
":",
"map",
"[",
"string",
"]",
"*",
"template",
".",
"Template",
"{",
"}",
",",
"}",
"\n",
"}",
"\n",
"return",
"a",
".",
"templateSet",
"\n",
"}"
] |
// TemplateSet retrieves the created template set.
|
[
"TemplateSet",
"retrieves",
"the",
"created",
"template",
"set",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/templates.go#L25-L35
|
train
|
xo/xo
|
internal/templates.go
|
ExecuteTemplate
|
func (a *ArgType) ExecuteTemplate(tt TemplateType, name string, sub string, obj interface{}) error {
var err error
// setup generated
if a.Generated == nil {
a.Generated = []TBuf{}
}
// create store
v := TBuf{
TemplateType: tt,
Name: name,
Subname: sub,
Buf: new(bytes.Buffer),
}
// build template name
loaderType := ""
if tt != XOTemplate {
if a.LoaderType == "oci8" || a.LoaderType == "ora" {
// force oracle for oci8 since the oracle driver doesn't recognize
// 'oracle' as valid protocol
loaderType = "oracle."
} else {
loaderType = a.LoaderType + "."
}
}
templateName := fmt.Sprintf("%s%s.go.tpl", loaderType, tt)
// execute template
err = a.TemplateSet().Execute(v.Buf, templateName, obj)
if err != nil {
return err
}
a.Generated = append(a.Generated, v)
return nil
}
|
go
|
func (a *ArgType) ExecuteTemplate(tt TemplateType, name string, sub string, obj interface{}) error {
var err error
// setup generated
if a.Generated == nil {
a.Generated = []TBuf{}
}
// create store
v := TBuf{
TemplateType: tt,
Name: name,
Subname: sub,
Buf: new(bytes.Buffer),
}
// build template name
loaderType := ""
if tt != XOTemplate {
if a.LoaderType == "oci8" || a.LoaderType == "ora" {
// force oracle for oci8 since the oracle driver doesn't recognize
// 'oracle' as valid protocol
loaderType = "oracle."
} else {
loaderType = a.LoaderType + "."
}
}
templateName := fmt.Sprintf("%s%s.go.tpl", loaderType, tt)
// execute template
err = a.TemplateSet().Execute(v.Buf, templateName, obj)
if err != nil {
return err
}
a.Generated = append(a.Generated, v)
return nil
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"ExecuteTemplate",
"(",
"tt",
"TemplateType",
",",
"name",
"string",
",",
"sub",
"string",
",",
"obj",
"interface",
"{",
"}",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"a",
".",
"Generated",
"==",
"nil",
"{",
"a",
".",
"Generated",
"=",
"[",
"]",
"TBuf",
"{",
"}",
"\n",
"}",
"\n",
"v",
":=",
"TBuf",
"{",
"TemplateType",
":",
"tt",
",",
"Name",
":",
"name",
",",
"Subname",
":",
"sub",
",",
"Buf",
":",
"new",
"(",
"bytes",
".",
"Buffer",
")",
",",
"}",
"\n",
"loaderType",
":=",
"\"\"",
"\n",
"if",
"tt",
"!=",
"XOTemplate",
"{",
"if",
"a",
".",
"LoaderType",
"==",
"\"oci8\"",
"||",
"a",
".",
"LoaderType",
"==",
"\"ora\"",
"{",
"loaderType",
"=",
"\"oracle.\"",
"\n",
"}",
"else",
"{",
"loaderType",
"=",
"a",
".",
"LoaderType",
"+",
"\".\"",
"\n",
"}",
"\n",
"}",
"\n",
"templateName",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"%s%s.go.tpl\"",
",",
"loaderType",
",",
"tt",
")",
"\n",
"err",
"=",
"a",
".",
"TemplateSet",
"(",
")",
".",
"Execute",
"(",
"v",
".",
"Buf",
",",
"templateName",
",",
"obj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"a",
".",
"Generated",
"=",
"append",
"(",
"a",
".",
"Generated",
",",
"v",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ExecuteTemplate loads and parses the supplied template with name and
// executes it with obj as the context.
|
[
"ExecuteTemplate",
"loads",
"and",
"parses",
"the",
"supplied",
"template",
"with",
"name",
"and",
"executes",
"it",
"with",
"obj",
"as",
"the",
"context",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/templates.go#L39-L76
|
train
|
xo/xo
|
internal/templates.go
|
Execute
|
func (ts *TemplateSet) Execute(w io.Writer, name string, obj interface{}) error {
tpl, ok := ts.tpls[name]
if !ok {
// attempt to load and parse the template
buf, err := ts.l(name)
if err != nil {
return err
}
// parse template
tpl, err = template.New(name).Funcs(ts.funcs).Parse(string(buf))
if err != nil {
return err
}
}
return tpl.Execute(w, obj)
}
|
go
|
func (ts *TemplateSet) Execute(w io.Writer, name string, obj interface{}) error {
tpl, ok := ts.tpls[name]
if !ok {
// attempt to load and parse the template
buf, err := ts.l(name)
if err != nil {
return err
}
// parse template
tpl, err = template.New(name).Funcs(ts.funcs).Parse(string(buf))
if err != nil {
return err
}
}
return tpl.Execute(w, obj)
}
|
[
"func",
"(",
"ts",
"*",
"TemplateSet",
")",
"Execute",
"(",
"w",
"io",
".",
"Writer",
",",
"name",
"string",
",",
"obj",
"interface",
"{",
"}",
")",
"error",
"{",
"tpl",
",",
"ok",
":=",
"ts",
".",
"tpls",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"buf",
",",
"err",
":=",
"ts",
".",
"l",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"tpl",
",",
"err",
"=",
"template",
".",
"New",
"(",
"name",
")",
".",
"Funcs",
"(",
"ts",
".",
"funcs",
")",
".",
"Parse",
"(",
"string",
"(",
"buf",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"tpl",
".",
"Execute",
"(",
"w",
",",
"obj",
")",
"\n",
"}"
] |
// Execute executes a specified template in the template set using the supplied
// obj as its parameters and writing the output to w.
|
[
"Execute",
"executes",
"a",
"specified",
"template",
"in",
"the",
"template",
"set",
"using",
"the",
"supplied",
"obj",
"as",
"its",
"parameters",
"and",
"writing",
"the",
"output",
"to",
"w",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/templates.go#L87-L104
|
train
|
xo/xo
|
examples/django/sqlite3/authusergroup.xo.go
|
Save
|
func (aug *AuthUserGroup) Save(db XODB) error {
if aug.Exists() {
return aug.Update(db)
}
return aug.Insert(db)
}
|
go
|
func (aug *AuthUserGroup) Save(db XODB) error {
if aug.Exists() {
return aug.Update(db)
}
return aug.Insert(db)
}
|
[
"func",
"(",
"aug",
"*",
"AuthUserGroup",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"aug",
".",
"Exists",
"(",
")",
"{",
"return",
"aug",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"aug",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthUserGroup to the database.
|
[
"Save",
"saves",
"the",
"AuthUserGroup",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authusergroup.xo.go#L92-L98
|
train
|
xo/xo
|
examples/django/sqlite3/authusergroup.xo.go
|
AuthUserGroupByUserIDGroupID
|
func AuthUserGroupByUserIDGroupID(db XODB, userID int, groupID int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM auth_user_groups ` +
`WHERE user_id = ? AND group_id = ?`
// run query
XOLog(sqlstr, userID, groupID)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, groupID).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
}
|
go
|
func AuthUserGroupByUserIDGroupID(db XODB, userID int, groupID int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM auth_user_groups ` +
`WHERE user_id = ? AND group_id = ?`
// run query
XOLog(sqlstr, userID, groupID)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, groupID).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
}
|
[
"func",
"AuthUserGroupByUserIDGroupID",
"(",
"db",
"XODB",
",",
"userID",
"int",
",",
"groupID",
"int",
")",
"(",
"*",
"AuthUserGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, group_id `",
"+",
"`FROM auth_user_groups `",
"+",
"`WHERE user_id = ? AND group_id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"userID",
",",
"groupID",
")",
"\n",
"aug",
":=",
"AuthUserGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"userID",
",",
"groupID",
")",
".",
"Scan",
"(",
"&",
"aug",
".",
"ID",
",",
"&",
"aug",
".",
"UserID",
",",
"&",
"aug",
".",
"GroupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"aug",
",",
"nil",
"\n",
"}"
] |
// AuthUserGroupByUserIDGroupID retrieves a row from 'auth_user_groups' as a AuthUserGroup.
//
// Generated from index 'auth_user_groups_user_id_94350c0c_uniq'.
|
[
"AuthUserGroupByUserIDGroupID",
"retrieves",
"a",
"row",
"from",
"auth_user_groups",
"as",
"a",
"AuthUserGroup",
".",
"Generated",
"from",
"index",
"auth_user_groups_user_id_94350c0c_uniq",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authusergroup.xo.go#L251-L272
|
train
|
xo/xo
|
examples/django/sqlite3/authgrouppermission.xo.go
|
Update
|
func (agp *AuthGroupPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if agp._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group_permissions SET ` +
`group_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
_, err = db.Exec(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
return err
}
|
go
|
func (agp *AuthGroupPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if agp._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group_permissions SET ` +
`group_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
_, err = db.Exec(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
return err
}
|
[
"func",
"(",
"agp",
"*",
"AuthGroupPermission",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"agp",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"agp",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE auth_group_permissions SET `",
"+",
"`group_id = ?, permission_id = ?`",
"+",
"` WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"agp",
".",
"GroupID",
",",
"agp",
".",
"PermissionID",
",",
"agp",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"agp",
".",
"GroupID",
",",
"agp",
".",
"PermissionID",
",",
"agp",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the AuthGroupPermission in the database.
|
[
"Update",
"updates",
"the",
"AuthGroupPermission",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authgrouppermission.xo.go#L67-L89
|
train
|
xo/xo
|
examples/django/sqlite3/authgrouppermission.xo.go
|
Delete
|
func (agp *AuthGroupPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return nil
}
// if deleted, bail
if agp._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM auth_group_permissions WHERE id = ?`
// run query
XOLog(sqlstr, agp.ID)
_, err = db.Exec(sqlstr, agp.ID)
if err != nil {
return err
}
// set deleted
agp._deleted = true
return nil
}
|
go
|
func (agp *AuthGroupPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return nil
}
// if deleted, bail
if agp._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM auth_group_permissions WHERE id = ?`
// run query
XOLog(sqlstr, agp.ID)
_, err = db.Exec(sqlstr, agp.ID)
if err != nil {
return err
}
// set deleted
agp._deleted = true
return nil
}
|
[
"func",
"(",
"agp",
"*",
"AuthGroupPermission",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"agp",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"agp",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM auth_group_permissions WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"agp",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"agp",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"agp",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthGroupPermission from the database.
|
[
"Delete",
"deletes",
"the",
"AuthGroupPermission",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authgrouppermission.xo.go#L101-L128
|
train
|
xo/xo
|
examples/django/postgres/authuser.xo.go
|
AuthUsersByUsername
|
func AuthUsersByUsername(db XODB, username string) ([]*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM public.auth_user ` +
`WHERE username = $1`
// run query
XOLog(sqlstr, username)
q, err := db.Query(sqlstr, username)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUser{}
for q.Next() {
au := AuthUser{
_exists: true,
}
// scan
err = q.Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
res = append(res, &au)
}
return res, nil
}
|
go
|
func AuthUsersByUsername(db XODB, username string) ([]*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM public.auth_user ` +
`WHERE username = $1`
// run query
XOLog(sqlstr, username)
q, err := db.Query(sqlstr, username)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUser{}
for q.Next() {
au := AuthUser{
_exists: true,
}
// scan
err = q.Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
res = append(res, &au)
}
return res, nil
}
|
[
"func",
"AuthUsersByUsername",
"(",
"db",
"XODB",
",",
"username",
"string",
")",
"(",
"[",
"]",
"*",
"AuthUser",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined `",
"+",
"`FROM public.auth_user `",
"+",
"`WHERE username = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"username",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"AuthUser",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"au",
":=",
"AuthUser",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"au",
".",
"ID",
",",
"&",
"au",
".",
"Password",
",",
"&",
"au",
".",
"LastLogin",
",",
"&",
"au",
".",
"IsSuperuser",
",",
"&",
"au",
".",
"Username",
",",
"&",
"au",
".",
"FirstName",
",",
"&",
"au",
".",
"LastName",
",",
"&",
"au",
".",
"Email",
",",
"&",
"au",
".",
"IsStaff",
",",
"&",
"au",
".",
"IsActive",
",",
"&",
"au",
".",
"DateJoined",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"au",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthUsersByUsername retrieves a row from 'public.auth_user' as a AuthUser.
//
// Generated from index 'auth_user_username_6821ab7c_like'.
|
[
"AuthUsersByUsername",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_user",
"as",
"a",
"AuthUser",
".",
"Generated",
"from",
"index",
"auth_user_username_6821ab7c_like",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authuser.xo.go#L200-L234
|
train
|
xo/xo
|
internal/loader.go
|
NthParam
|
func (tl TypeLoader) NthParam(i int) string {
if tl.ParamN != nil {
return tl.ParamN(i)
}
return fmt.Sprintf("$%d", i+1)
}
|
go
|
func (tl TypeLoader) NthParam(i int) string {
if tl.ParamN != nil {
return tl.ParamN(i)
}
return fmt.Sprintf("$%d", i+1)
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"NthParam",
"(",
"i",
"int",
")",
"string",
"{",
"if",
"tl",
".",
"ParamN",
"!=",
"nil",
"{",
"return",
"tl",
".",
"ParamN",
"(",
"i",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"$%d\"",
",",
"i",
"+",
"1",
")",
"\n",
"}"
] |
// NthParam satisifies Loader's NthParam.
|
[
"NthParam",
"satisifies",
"Loader",
"s",
"NthParam",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L67-L73
|
train
|
xo/xo
|
internal/loader.go
|
Escape
|
func (tl TypeLoader) Escape(typ EscType, s string) string {
if e, ok := tl.Esc[typ]; ok && e != nil {
return e(s)
}
return `"` + s + `"`
}
|
go
|
func (tl TypeLoader) Escape(typ EscType, s string) string {
if e, ok := tl.Esc[typ]; ok && e != nil {
return e(s)
}
return `"` + s + `"`
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"Escape",
"(",
"typ",
"EscType",
",",
"s",
"string",
")",
"string",
"{",
"if",
"e",
",",
"ok",
":=",
"tl",
".",
"Esc",
"[",
"typ",
"]",
";",
"ok",
"&&",
"e",
"!=",
"nil",
"{",
"return",
"e",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"`\"`",
"+",
"s",
"+",
"`\"`",
"\n",
"}"
] |
// Escape escapes the provided identifier based on the EscType.
|
[
"Escape",
"escapes",
"the",
"provided",
"identifier",
"based",
"on",
"the",
"EscType",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L85-L91
|
train
|
xo/xo
|
internal/loader.go
|
Relkind
|
func (tl TypeLoader) Relkind(rt RelType) string {
if tl.ProcessRelkind != nil {
return tl.ProcessRelkind(rt)
}
return rt.String()
}
|
go
|
func (tl TypeLoader) Relkind(rt RelType) string {
if tl.ProcessRelkind != nil {
return tl.ProcessRelkind(rt)
}
return rt.String()
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"Relkind",
"(",
"rt",
"RelType",
")",
"string",
"{",
"if",
"tl",
".",
"ProcessRelkind",
"!=",
"nil",
"{",
"return",
"tl",
".",
"ProcessRelkind",
"(",
"rt",
")",
"\n",
"}",
"\n",
"return",
"rt",
".",
"String",
"(",
")",
"\n",
"}"
] |
// Relkind satisfies Loader's Relkind.
|
[
"Relkind",
"satisfies",
"Loader",
"s",
"Relkind",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L94-L100
|
train
|
xo/xo
|
internal/loader.go
|
SchemaName
|
func (tl TypeLoader) SchemaName(args *ArgType) (string, error) {
if tl.Schema != nil {
return tl.Schema(args)
}
return "", nil
}
|
go
|
func (tl TypeLoader) SchemaName(args *ArgType) (string, error) {
if tl.Schema != nil {
return tl.Schema(args)
}
return "", nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"SchemaName",
"(",
"args",
"*",
"ArgType",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"tl",
".",
"Schema",
"!=",
"nil",
"{",
"return",
"tl",
".",
"Schema",
"(",
"args",
")",
"\n",
"}",
"\n",
"return",
"\"\"",
",",
"nil",
"\n",
"}"
] |
// SchemaName returns the active schema name.
|
[
"SchemaName",
"returns",
"the",
"active",
"schema",
"name",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L103-L109
|
train
|
xo/xo
|
internal/loader.go
|
LoadSchema
|
func (tl TypeLoader) LoadSchema(args *ArgType) error {
var err error
// load enums
_, err = tl.LoadEnums(args)
if err != nil {
return err
}
// load procs
_, err = tl.LoadProcs(args)
if err != nil {
return err
}
// load tables
tableMap, err := tl.LoadRelkind(args, Table)
if err != nil {
return err
}
// load views
viewMap, err := tl.LoadRelkind(args, View)
if err != nil {
return err
}
// merge views with the tableMap
for k, v := range viewMap {
tableMap[k] = v
}
// load foreign keys
_, err = tl.LoadForeignKeys(args, tableMap)
if err != nil {
return err
}
// load indexes
_, err = tl.LoadIndexes(args, tableMap)
if err != nil {
return err
}
return nil
}
|
go
|
func (tl TypeLoader) LoadSchema(args *ArgType) error {
var err error
// load enums
_, err = tl.LoadEnums(args)
if err != nil {
return err
}
// load procs
_, err = tl.LoadProcs(args)
if err != nil {
return err
}
// load tables
tableMap, err := tl.LoadRelkind(args, Table)
if err != nil {
return err
}
// load views
viewMap, err := tl.LoadRelkind(args, View)
if err != nil {
return err
}
// merge views with the tableMap
for k, v := range viewMap {
tableMap[k] = v
}
// load foreign keys
_, err = tl.LoadForeignKeys(args, tableMap)
if err != nil {
return err
}
// load indexes
_, err = tl.LoadIndexes(args, tableMap)
if err != nil {
return err
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadSchema",
"(",
"args",
"*",
"ArgType",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"_",
",",
"err",
"=",
"tl",
".",
"LoadEnums",
"(",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"tl",
".",
"LoadProcs",
"(",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"tableMap",
",",
"err",
":=",
"tl",
".",
"LoadRelkind",
"(",
"args",
",",
"Table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"viewMap",
",",
"err",
":=",
"tl",
".",
"LoadRelkind",
"(",
"args",
",",
"View",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"viewMap",
"{",
"tableMap",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"tl",
".",
"LoadForeignKeys",
"(",
"args",
",",
"tableMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"tl",
".",
"LoadIndexes",
"(",
"args",
",",
"tableMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadSchema loads schema definitions.
|
[
"LoadSchema",
"loads",
"schema",
"definitions",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L247-L292
|
train
|
xo/xo
|
internal/loader.go
|
LoadEnums
|
func (tl TypeLoader) LoadEnums(args *ArgType) (map[string]*Enum, error) {
var err error
// not supplied, so bail
if tl.EnumList == nil {
return nil, nil
}
// load enums
enumList, err := tl.EnumList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process enums
enumMap := map[string]*Enum{}
for _, e := range enumList {
enumTpl := &Enum{
Name: SingularizeIdentifier(e.EnumName),
Schema: args.Schema,
Values: []*EnumValue{},
Enum: e,
ReverseConstNames: args.UseReversedEnumConstNames,
}
err = tl.LoadEnumValues(args, enumTpl)
if err != nil {
return nil, err
}
enumMap[enumTpl.Name] = enumTpl
args.KnownTypeMap[enumTpl.Name] = true
}
// generate enum templates
for _, e := range enumMap {
err = args.ExecuteTemplate(EnumTemplate, e.Name, "", e)
if err != nil {
return nil, err
}
}
return enumMap, nil
}
|
go
|
func (tl TypeLoader) LoadEnums(args *ArgType) (map[string]*Enum, error) {
var err error
// not supplied, so bail
if tl.EnumList == nil {
return nil, nil
}
// load enums
enumList, err := tl.EnumList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process enums
enumMap := map[string]*Enum{}
for _, e := range enumList {
enumTpl := &Enum{
Name: SingularizeIdentifier(e.EnumName),
Schema: args.Schema,
Values: []*EnumValue{},
Enum: e,
ReverseConstNames: args.UseReversedEnumConstNames,
}
err = tl.LoadEnumValues(args, enumTpl)
if err != nil {
return nil, err
}
enumMap[enumTpl.Name] = enumTpl
args.KnownTypeMap[enumTpl.Name] = true
}
// generate enum templates
for _, e := range enumMap {
err = args.ExecuteTemplate(EnumTemplate, e.Name, "", e)
if err != nil {
return nil, err
}
}
return enumMap, nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadEnums",
"(",
"args",
"*",
"ArgType",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"Enum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"tl",
".",
"EnumList",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"enumList",
",",
"err",
":=",
"tl",
".",
"EnumList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"enumMap",
":=",
"map",
"[",
"string",
"]",
"*",
"Enum",
"{",
"}",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"enumList",
"{",
"enumTpl",
":=",
"&",
"Enum",
"{",
"Name",
":",
"SingularizeIdentifier",
"(",
"e",
".",
"EnumName",
")",
",",
"Schema",
":",
"args",
".",
"Schema",
",",
"Values",
":",
"[",
"]",
"*",
"EnumValue",
"{",
"}",
",",
"Enum",
":",
"e",
",",
"ReverseConstNames",
":",
"args",
".",
"UseReversedEnumConstNames",
",",
"}",
"\n",
"err",
"=",
"tl",
".",
"LoadEnumValues",
"(",
"args",
",",
"enumTpl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"enumMap",
"[",
"enumTpl",
".",
"Name",
"]",
"=",
"enumTpl",
"\n",
"args",
".",
"KnownTypeMap",
"[",
"enumTpl",
".",
"Name",
"]",
"=",
"true",
"\n",
"}",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"enumMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"EnumTemplate",
",",
"e",
".",
"Name",
",",
"\"\"",
",",
"e",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"enumMap",
",",
"nil",
"\n",
"}"
] |
// LoadEnums loads schema enums.
|
[
"LoadEnums",
"loads",
"schema",
"enums",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L295-L338
|
train
|
xo/xo
|
internal/loader.go
|
LoadEnumValues
|
func (tl TypeLoader) LoadEnumValues(args *ArgType, enumTpl *Enum) error {
var err error
// load enum values
enumValues, err := tl.EnumValueList(args.DB, args.Schema, enumTpl.Enum.EnumName)
if err != nil {
return err
}
// process enum values
for _, ev := range enumValues {
// chop off redundant enum name if applicable
name := snaker.SnakeToCamelIdentifier(ev.EnumValue)
if strings.HasSuffix(strings.ToLower(name), strings.ToLower(enumTpl.Name)) {
n := name[:len(name)-len(enumTpl.Name)]
if len(n) > 0 {
name = n
}
}
enumTpl.Values = append(enumTpl.Values, &EnumValue{
Name: name,
Val: ev,
})
}
return nil
}
|
go
|
func (tl TypeLoader) LoadEnumValues(args *ArgType, enumTpl *Enum) error {
var err error
// load enum values
enumValues, err := tl.EnumValueList(args.DB, args.Schema, enumTpl.Enum.EnumName)
if err != nil {
return err
}
// process enum values
for _, ev := range enumValues {
// chop off redundant enum name if applicable
name := snaker.SnakeToCamelIdentifier(ev.EnumValue)
if strings.HasSuffix(strings.ToLower(name), strings.ToLower(enumTpl.Name)) {
n := name[:len(name)-len(enumTpl.Name)]
if len(n) > 0 {
name = n
}
}
enumTpl.Values = append(enumTpl.Values, &EnumValue{
Name: name,
Val: ev,
})
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadEnumValues",
"(",
"args",
"*",
"ArgType",
",",
"enumTpl",
"*",
"Enum",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"enumValues",
",",
"err",
":=",
"tl",
".",
"EnumValueList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"enumTpl",
".",
"Enum",
".",
"EnumName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"ev",
":=",
"range",
"enumValues",
"{",
"name",
":=",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"ev",
".",
"EnumValue",
")",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"strings",
".",
"ToLower",
"(",
"name",
")",
",",
"strings",
".",
"ToLower",
"(",
"enumTpl",
".",
"Name",
")",
")",
"{",
"n",
":=",
"name",
"[",
":",
"len",
"(",
"name",
")",
"-",
"len",
"(",
"enumTpl",
".",
"Name",
")",
"]",
"\n",
"if",
"len",
"(",
"n",
")",
">",
"0",
"{",
"name",
"=",
"n",
"\n",
"}",
"\n",
"}",
"\n",
"enumTpl",
".",
"Values",
"=",
"append",
"(",
"enumTpl",
".",
"Values",
",",
"&",
"EnumValue",
"{",
"Name",
":",
"name",
",",
"Val",
":",
"ev",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadEnumValues loads schema enum values.
|
[
"LoadEnumValues",
"loads",
"schema",
"enum",
"values",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L341-L368
|
train
|
xo/xo
|
internal/loader.go
|
LoadProcs
|
func (tl TypeLoader) LoadProcs(args *ArgType) (map[string]*Proc, error) {
var err error
// not supplied, so bail
if tl.ProcList == nil {
return nil, nil
}
// load procs
procList, err := tl.ProcList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process procs
procMap := map[string]*Proc{}
for _, p := range procList {
// fix the name if it starts with one or more underscores
name := p.ProcName
for strings.HasPrefix(name, "_") {
name = name[1:]
}
// create template
procTpl := &Proc{
Name: snaker.SnakeToCamelIdentifier(name),
Schema: args.Schema,
Params: []*Field{},
Return: &Field{},
Proc: p,
}
// parse return type into template
// TODO: fix this so that nullable types can be returned
_, procTpl.Return.NilType, procTpl.Return.Type = tl.ParseType(args, p.ReturnType, false)
// load proc parameters
err = tl.LoadProcParams(args, procTpl)
if err != nil {
return nil, err
}
procMap[p.ProcName] = procTpl
}
// generate proc templates
for _, p := range procMap {
err = args.ExecuteTemplate(ProcTemplate, "sp_"+p.Name, "", p)
if err != nil {
return nil, err
}
}
return procMap, nil
}
|
go
|
func (tl TypeLoader) LoadProcs(args *ArgType) (map[string]*Proc, error) {
var err error
// not supplied, so bail
if tl.ProcList == nil {
return nil, nil
}
// load procs
procList, err := tl.ProcList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process procs
procMap := map[string]*Proc{}
for _, p := range procList {
// fix the name if it starts with one or more underscores
name := p.ProcName
for strings.HasPrefix(name, "_") {
name = name[1:]
}
// create template
procTpl := &Proc{
Name: snaker.SnakeToCamelIdentifier(name),
Schema: args.Schema,
Params: []*Field{},
Return: &Field{},
Proc: p,
}
// parse return type into template
// TODO: fix this so that nullable types can be returned
_, procTpl.Return.NilType, procTpl.Return.Type = tl.ParseType(args, p.ReturnType, false)
// load proc parameters
err = tl.LoadProcParams(args, procTpl)
if err != nil {
return nil, err
}
procMap[p.ProcName] = procTpl
}
// generate proc templates
for _, p := range procMap {
err = args.ExecuteTemplate(ProcTemplate, "sp_"+p.Name, "", p)
if err != nil {
return nil, err
}
}
return procMap, nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadProcs",
"(",
"args",
"*",
"ArgType",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"Proc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"tl",
".",
"ProcList",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"procList",
",",
"err",
":=",
"tl",
".",
"ProcList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"procMap",
":=",
"map",
"[",
"string",
"]",
"*",
"Proc",
"{",
"}",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"procList",
"{",
"name",
":=",
"p",
".",
"ProcName",
"\n",
"for",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"\"_\"",
")",
"{",
"name",
"=",
"name",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"procTpl",
":=",
"&",
"Proc",
"{",
"Name",
":",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"name",
")",
",",
"Schema",
":",
"args",
".",
"Schema",
",",
"Params",
":",
"[",
"]",
"*",
"Field",
"{",
"}",
",",
"Return",
":",
"&",
"Field",
"{",
"}",
",",
"Proc",
":",
"p",
",",
"}",
"\n",
"_",
",",
"procTpl",
".",
"Return",
".",
"NilType",
",",
"procTpl",
".",
"Return",
".",
"Type",
"=",
"tl",
".",
"ParseType",
"(",
"args",
",",
"p",
".",
"ReturnType",
",",
"false",
")",
"\n",
"err",
"=",
"tl",
".",
"LoadProcParams",
"(",
"args",
",",
"procTpl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"procMap",
"[",
"p",
".",
"ProcName",
"]",
"=",
"procTpl",
"\n",
"}",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"procMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"ProcTemplate",
",",
"\"sp_\"",
"+",
"p",
".",
"Name",
",",
"\"\"",
",",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"procMap",
",",
"nil",
"\n",
"}"
] |
// LoadProcs loads schema stored procedures definitions.
|
[
"LoadProcs",
"loads",
"schema",
"stored",
"procedures",
"definitions",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L371-L425
|
train
|
xo/xo
|
internal/loader.go
|
LoadProcParams
|
func (tl TypeLoader) LoadProcParams(args *ArgType, procTpl *Proc) error {
var err error
// load proc params
paramList, err := tl.ProcParamList(args.DB, args.Schema, procTpl.Proc.ProcName)
if err != nil {
return err
}
// process params
for i, p := range paramList {
// TODO: some databases support named parameters in procs (MySQL)
paramTpl := &Field{
Name: fmt.Sprintf("v%d", i),
}
// TODO: fix this so that nullable types can be used as parameters
_, _, paramTpl.Type = tl.ParseType(args, strings.TrimSpace(p.ParamType), false)
// add to proc params
if procTpl.ProcParams != "" {
procTpl.ProcParams = procTpl.ProcParams + ", "
}
procTpl.ProcParams = procTpl.ProcParams + p.ParamType
procTpl.Params = append(procTpl.Params, paramTpl)
}
return nil
}
|
go
|
func (tl TypeLoader) LoadProcParams(args *ArgType, procTpl *Proc) error {
var err error
// load proc params
paramList, err := tl.ProcParamList(args.DB, args.Schema, procTpl.Proc.ProcName)
if err != nil {
return err
}
// process params
for i, p := range paramList {
// TODO: some databases support named parameters in procs (MySQL)
paramTpl := &Field{
Name: fmt.Sprintf("v%d", i),
}
// TODO: fix this so that nullable types can be used as parameters
_, _, paramTpl.Type = tl.ParseType(args, strings.TrimSpace(p.ParamType), false)
// add to proc params
if procTpl.ProcParams != "" {
procTpl.ProcParams = procTpl.ProcParams + ", "
}
procTpl.ProcParams = procTpl.ProcParams + p.ParamType
procTpl.Params = append(procTpl.Params, paramTpl)
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadProcParams",
"(",
"args",
"*",
"ArgType",
",",
"procTpl",
"*",
"Proc",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"paramList",
",",
"err",
":=",
"tl",
".",
"ProcParamList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"procTpl",
".",
"Proc",
".",
"ProcName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"p",
":=",
"range",
"paramList",
"{",
"paramTpl",
":=",
"&",
"Field",
"{",
"Name",
":",
"fmt",
".",
"Sprintf",
"(",
"\"v%d\"",
",",
"i",
")",
",",
"}",
"\n",
"_",
",",
"_",
",",
"paramTpl",
".",
"Type",
"=",
"tl",
".",
"ParseType",
"(",
"args",
",",
"strings",
".",
"TrimSpace",
"(",
"p",
".",
"ParamType",
")",
",",
"false",
")",
"\n",
"if",
"procTpl",
".",
"ProcParams",
"!=",
"\"\"",
"{",
"procTpl",
".",
"ProcParams",
"=",
"procTpl",
".",
"ProcParams",
"+",
"\", \"",
"\n",
"}",
"\n",
"procTpl",
".",
"ProcParams",
"=",
"procTpl",
".",
"ProcParams",
"+",
"p",
".",
"ParamType",
"\n",
"procTpl",
".",
"Params",
"=",
"append",
"(",
"procTpl",
".",
"Params",
",",
"paramTpl",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadProcParams loads schema stored procedure parameters.
|
[
"LoadProcParams",
"loads",
"schema",
"stored",
"procedure",
"parameters",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L428-L457
|
train
|
xo/xo
|
internal/loader.go
|
LoadForeignKeys
|
func (tl TypeLoader) LoadForeignKeys(args *ArgType, tableMap map[string]*Type) (map[string]*ForeignKey, error) {
var err error
fkMap := map[string]*ForeignKey{}
for _, t := range tableMap {
// load keys per table
err = tl.LoadTableForeignKeys(args, tableMap, t, fkMap)
if err != nil {
return nil, err
}
}
// determine foreign key names
for _, fk := range fkMap {
fk.Name = args.ForeignKeyName(fkMap, fk)
}
// generate templates
for _, fk := range fkMap {
err = args.ExecuteTemplate(ForeignKeyTemplate, fk.Type.Name, fk.ForeignKey.ForeignKeyName, fk)
if err != nil {
return nil, err
}
}
return fkMap, nil
}
|
go
|
func (tl TypeLoader) LoadForeignKeys(args *ArgType, tableMap map[string]*Type) (map[string]*ForeignKey, error) {
var err error
fkMap := map[string]*ForeignKey{}
for _, t := range tableMap {
// load keys per table
err = tl.LoadTableForeignKeys(args, tableMap, t, fkMap)
if err != nil {
return nil, err
}
}
// determine foreign key names
for _, fk := range fkMap {
fk.Name = args.ForeignKeyName(fkMap, fk)
}
// generate templates
for _, fk := range fkMap {
err = args.ExecuteTemplate(ForeignKeyTemplate, fk.Type.Name, fk.ForeignKey.ForeignKeyName, fk)
if err != nil {
return nil, err
}
}
return fkMap, nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadForeignKeys",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"fkMap",
":=",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
"{",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"err",
"=",
"tl",
".",
"LoadTableForeignKeys",
"(",
"args",
",",
"tableMap",
",",
"t",
",",
"fkMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"fk",
":=",
"range",
"fkMap",
"{",
"fk",
".",
"Name",
"=",
"args",
".",
"ForeignKeyName",
"(",
"fkMap",
",",
"fk",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"fk",
":=",
"range",
"fkMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"ForeignKeyTemplate",
",",
"fk",
".",
"Type",
".",
"Name",
",",
"fk",
".",
"ForeignKey",
".",
"ForeignKeyName",
",",
"fk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fkMap",
",",
"nil",
"\n",
"}"
] |
// LoadForeignKeys loads foreign keys.
|
[
"LoadForeignKeys",
"loads",
"foreign",
"keys",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L553-L579
|
train
|
xo/xo
|
internal/loader.go
|
LoadTableForeignKeys
|
func (tl TypeLoader) LoadTableForeignKeys(args *ArgType, tableMap map[string]*Type, typeTpl *Type, fkMap map[string]*ForeignKey) error {
var err error
// load foreign keys
foreignKeyList, err := tl.ForeignKeyList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// loop over foreign keys for table
for _, fk := range foreignKeyList {
var refTpl *Type
var col, refCol *Field
colLoop:
// find column
for _, f := range typeTpl.Fields {
if f.Col.ColumnName == fk.ColumnName {
col = f
break colLoop
}
}
refTplLoop:
// find ref table
for _, t := range tableMap {
if t.Table.TableName == fk.RefTableName {
refTpl = t
break refTplLoop
}
}
refColLoop:
// find ref column
for _, f := range refTpl.Fields {
if f.Col.ColumnName == fk.RefColumnName {
refCol = f
break refColLoop
}
}
// no ref col, but have ref tpl, so use primary key
if refTpl != nil && refCol == nil {
refCol = refTpl.PrimaryKey
}
// check everything was found
if col == nil || refTpl == nil || refCol == nil {
return errors.New("could not find col, refTpl, or refCol")
}
// foreign key name
if fk.ForeignKeyName == "" {
fk.ForeignKeyName = typeTpl.Table.TableName + "_" + col.Col.ColumnName + "_fkey"
}
// create foreign key template
fkMap[fk.ForeignKeyName] = &ForeignKey{
Schema: args.Schema,
Type: typeTpl,
Field: col,
RefType: refTpl,
RefField: refCol,
ForeignKey: fk,
}
}
return nil
}
|
go
|
func (tl TypeLoader) LoadTableForeignKeys(args *ArgType, tableMap map[string]*Type, typeTpl *Type, fkMap map[string]*ForeignKey) error {
var err error
// load foreign keys
foreignKeyList, err := tl.ForeignKeyList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// loop over foreign keys for table
for _, fk := range foreignKeyList {
var refTpl *Type
var col, refCol *Field
colLoop:
// find column
for _, f := range typeTpl.Fields {
if f.Col.ColumnName == fk.ColumnName {
col = f
break colLoop
}
}
refTplLoop:
// find ref table
for _, t := range tableMap {
if t.Table.TableName == fk.RefTableName {
refTpl = t
break refTplLoop
}
}
refColLoop:
// find ref column
for _, f := range refTpl.Fields {
if f.Col.ColumnName == fk.RefColumnName {
refCol = f
break refColLoop
}
}
// no ref col, but have ref tpl, so use primary key
if refTpl != nil && refCol == nil {
refCol = refTpl.PrimaryKey
}
// check everything was found
if col == nil || refTpl == nil || refCol == nil {
return errors.New("could not find col, refTpl, or refCol")
}
// foreign key name
if fk.ForeignKeyName == "" {
fk.ForeignKeyName = typeTpl.Table.TableName + "_" + col.Col.ColumnName + "_fkey"
}
// create foreign key template
fkMap[fk.ForeignKeyName] = &ForeignKey{
Schema: args.Schema,
Type: typeTpl,
Field: col,
RefType: refTpl,
RefField: refCol,
ForeignKey: fk,
}
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadTableForeignKeys",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
",",
"typeTpl",
"*",
"Type",
",",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"foreignKeyList",
",",
"err",
":=",
"tl",
".",
"ForeignKeyList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"typeTpl",
".",
"Table",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"fk",
":=",
"range",
"foreignKeyList",
"{",
"var",
"refTpl",
"*",
"Type",
"\n",
"var",
"col",
",",
"refCol",
"*",
"Field",
"\n",
"colLoop",
":",
"for",
"_",
",",
"f",
":=",
"range",
"typeTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"fk",
".",
"ColumnName",
"{",
"col",
"=",
"f",
"\n",
"break",
"colLoop",
"\n",
"}",
"\n",
"}",
"\n",
"refTplLoop",
":",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"if",
"t",
".",
"Table",
".",
"TableName",
"==",
"fk",
".",
"RefTableName",
"{",
"refTpl",
"=",
"t",
"\n",
"break",
"refTplLoop",
"\n",
"}",
"\n",
"}",
"\n",
"refColLoop",
":",
"for",
"_",
",",
"f",
":=",
"range",
"refTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"fk",
".",
"RefColumnName",
"{",
"refCol",
"=",
"f",
"\n",
"break",
"refColLoop",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"refTpl",
"!=",
"nil",
"&&",
"refCol",
"==",
"nil",
"{",
"refCol",
"=",
"refTpl",
".",
"PrimaryKey",
"\n",
"}",
"\n",
"if",
"col",
"==",
"nil",
"||",
"refTpl",
"==",
"nil",
"||",
"refCol",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"could not find col, refTpl, or refCol\"",
")",
"\n",
"}",
"\n",
"if",
"fk",
".",
"ForeignKeyName",
"==",
"\"\"",
"{",
"fk",
".",
"ForeignKeyName",
"=",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"_\"",
"+",
"col",
".",
"Col",
".",
"ColumnName",
"+",
"\"_fkey\"",
"\n",
"}",
"\n",
"fkMap",
"[",
"fk",
".",
"ForeignKeyName",
"]",
"=",
"&",
"ForeignKey",
"{",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Field",
":",
"col",
",",
"RefType",
":",
"refTpl",
",",
"RefField",
":",
"refCol",
",",
"ForeignKey",
":",
"fk",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadTableForeignKeys loads schema foreign key definitions per table.
|
[
"LoadTableForeignKeys",
"loads",
"schema",
"foreign",
"key",
"definitions",
"per",
"table",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L582-L650
|
train
|
xo/xo
|
internal/loader.go
|
LoadIndexes
|
func (tl TypeLoader) LoadIndexes(args *ArgType, tableMap map[string]*Type) (map[string]*Index, error) {
var err error
ixMap := map[string]*Index{}
for _, t := range tableMap {
// load table indexes
err = tl.LoadTableIndexes(args, t, ixMap)
if err != nil {
return nil, err
}
}
// generate templates
for _, ix := range ixMap {
err = args.ExecuteTemplate(IndexTemplate, ix.Type.Name, ix.Index.IndexName, ix)
if err != nil {
return nil, err
}
}
return ixMap, nil
}
|
go
|
func (tl TypeLoader) LoadIndexes(args *ArgType, tableMap map[string]*Type) (map[string]*Index, error) {
var err error
ixMap := map[string]*Index{}
for _, t := range tableMap {
// load table indexes
err = tl.LoadTableIndexes(args, t, ixMap)
if err != nil {
return nil, err
}
}
// generate templates
for _, ix := range ixMap {
err = args.ExecuteTemplate(IndexTemplate, ix.Type.Name, ix.Index.IndexName, ix)
if err != nil {
return nil, err
}
}
return ixMap, nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadIndexes",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"ixMap",
":=",
"map",
"[",
"string",
"]",
"*",
"Index",
"{",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"err",
"=",
"tl",
".",
"LoadTableIndexes",
"(",
"args",
",",
"t",
",",
"ixMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"ix",
":=",
"range",
"ixMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"IndexTemplate",
",",
"ix",
".",
"Type",
".",
"Name",
",",
"ix",
".",
"Index",
".",
"IndexName",
",",
"ix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ixMap",
",",
"nil",
"\n",
"}"
] |
// LoadIndexes loads schema index definitions.
|
[
"LoadIndexes",
"loads",
"schema",
"index",
"definitions",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L653-L674
|
train
|
xo/xo
|
internal/loader.go
|
LoadTableIndexes
|
func (tl TypeLoader) LoadTableIndexes(args *ArgType, typeTpl *Type, ixMap map[string]*Index) error {
var err error
var priIxLoaded bool
// load indexes
indexList, err := tl.IndexList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// process indexes
for _, ix := range indexList {
// save whether or not the primary key index was processed
priIxLoaded = priIxLoaded || ix.IsPrimary || (ix.Origin == "pk")
// create index template
ixTpl := &Index{
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{},
Index: ix,
}
// load index columns
err = tl.LoadIndexColumns(args, ixTpl)
if err != nil {
return err
}
// build func name
args.BuildIndexFuncName(ixTpl)
ixMap[typeTpl.Table.TableName+"_"+ix.IndexName] = ixTpl
}
// search for primary key if it was skipped being set in the type
pk := typeTpl.PrimaryKey
if pk == nil {
for _, f := range typeTpl.Fields {
if f.Col.IsPrimaryKey {
pk = f
break
}
}
}
// if no primary key index loaded, but a primary key column was defined in
// the type, then create the definition here. this is needed for sqlite, as
// sqlite doesn't define primary keys in its index list
if args.LoaderType != "ora" && !priIxLoaded && pk != nil {
ixName := typeTpl.Table.TableName + "_" + pk.Col.ColumnName + "_pkey"
ixMap[ixName] = &Index{
FuncName: typeTpl.Name + "By" + pk.Name,
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{pk},
Index: &models.Index{
IndexName: ixName,
IsUnique: true,
IsPrimary: true,
},
}
}
return nil
}
|
go
|
func (tl TypeLoader) LoadTableIndexes(args *ArgType, typeTpl *Type, ixMap map[string]*Index) error {
var err error
var priIxLoaded bool
// load indexes
indexList, err := tl.IndexList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// process indexes
for _, ix := range indexList {
// save whether or not the primary key index was processed
priIxLoaded = priIxLoaded || ix.IsPrimary || (ix.Origin == "pk")
// create index template
ixTpl := &Index{
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{},
Index: ix,
}
// load index columns
err = tl.LoadIndexColumns(args, ixTpl)
if err != nil {
return err
}
// build func name
args.BuildIndexFuncName(ixTpl)
ixMap[typeTpl.Table.TableName+"_"+ix.IndexName] = ixTpl
}
// search for primary key if it was skipped being set in the type
pk := typeTpl.PrimaryKey
if pk == nil {
for _, f := range typeTpl.Fields {
if f.Col.IsPrimaryKey {
pk = f
break
}
}
}
// if no primary key index loaded, but a primary key column was defined in
// the type, then create the definition here. this is needed for sqlite, as
// sqlite doesn't define primary keys in its index list
if args.LoaderType != "ora" && !priIxLoaded && pk != nil {
ixName := typeTpl.Table.TableName + "_" + pk.Col.ColumnName + "_pkey"
ixMap[ixName] = &Index{
FuncName: typeTpl.Name + "By" + pk.Name,
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{pk},
Index: &models.Index{
IndexName: ixName,
IsUnique: true,
IsPrimary: true,
},
}
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadTableIndexes",
"(",
"args",
"*",
"ArgType",
",",
"typeTpl",
"*",
"Type",
",",
"ixMap",
"map",
"[",
"string",
"]",
"*",
"Index",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"priIxLoaded",
"bool",
"\n",
"indexList",
",",
"err",
":=",
"tl",
".",
"IndexList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"typeTpl",
".",
"Table",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"ix",
":=",
"range",
"indexList",
"{",
"priIxLoaded",
"=",
"priIxLoaded",
"||",
"ix",
".",
"IsPrimary",
"||",
"(",
"ix",
".",
"Origin",
"==",
"\"pk\"",
")",
"\n",
"ixTpl",
":=",
"&",
"Index",
"{",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Fields",
":",
"[",
"]",
"*",
"Field",
"{",
"}",
",",
"Index",
":",
"ix",
",",
"}",
"\n",
"err",
"=",
"tl",
".",
"LoadIndexColumns",
"(",
"args",
",",
"ixTpl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"args",
".",
"BuildIndexFuncName",
"(",
"ixTpl",
")",
"\n",
"ixMap",
"[",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"_\"",
"+",
"ix",
".",
"IndexName",
"]",
"=",
"ixTpl",
"\n",
"}",
"\n",
"pk",
":=",
"typeTpl",
".",
"PrimaryKey",
"\n",
"if",
"pk",
"==",
"nil",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"typeTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"IsPrimaryKey",
"{",
"pk",
"=",
"f",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"args",
".",
"LoaderType",
"!=",
"\"ora\"",
"&&",
"!",
"priIxLoaded",
"&&",
"pk",
"!=",
"nil",
"{",
"ixName",
":=",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"_\"",
"+",
"pk",
".",
"Col",
".",
"ColumnName",
"+",
"\"_pkey\"",
"\n",
"ixMap",
"[",
"ixName",
"]",
"=",
"&",
"Index",
"{",
"FuncName",
":",
"typeTpl",
".",
"Name",
"+",
"\"By\"",
"+",
"pk",
".",
"Name",
",",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Fields",
":",
"[",
"]",
"*",
"Field",
"{",
"pk",
"}",
",",
"Index",
":",
"&",
"models",
".",
"Index",
"{",
"IndexName",
":",
"ixName",
",",
"IsUnique",
":",
"true",
",",
"IsPrimary",
":",
"true",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadTableIndexes loads schema index definitions per table.
|
[
"LoadTableIndexes",
"loads",
"schema",
"index",
"definitions",
"per",
"table",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L677-L742
|
train
|
xo/xo
|
internal/loader.go
|
LoadIndexColumns
|
func (tl TypeLoader) LoadIndexColumns(args *ArgType, ixTpl *Index) error {
var err error
// load index columns
indexCols, err := tl.IndexColumnList(args.DB, args.Schema, ixTpl.Type.Table.TableName, ixTpl.Index.IndexName)
if err != nil {
return err
}
// process index columns
for _, ic := range indexCols {
var field *Field
fieldLoop:
// find field
for _, f := range ixTpl.Type.Fields {
if f.Col.ColumnName == ic.ColumnName {
field = f
break fieldLoop
}
}
if field == nil {
continue
}
ixTpl.Fields = append(ixTpl.Fields, field)
}
return nil
}
|
go
|
func (tl TypeLoader) LoadIndexColumns(args *ArgType, ixTpl *Index) error {
var err error
// load index columns
indexCols, err := tl.IndexColumnList(args.DB, args.Schema, ixTpl.Type.Table.TableName, ixTpl.Index.IndexName)
if err != nil {
return err
}
// process index columns
for _, ic := range indexCols {
var field *Field
fieldLoop:
// find field
for _, f := range ixTpl.Type.Fields {
if f.Col.ColumnName == ic.ColumnName {
field = f
break fieldLoop
}
}
if field == nil {
continue
}
ixTpl.Fields = append(ixTpl.Fields, field)
}
return nil
}
|
[
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadIndexColumns",
"(",
"args",
"*",
"ArgType",
",",
"ixTpl",
"*",
"Index",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"indexCols",
",",
"err",
":=",
"tl",
".",
"IndexColumnList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"ixTpl",
".",
"Type",
".",
"Table",
".",
"TableName",
",",
"ixTpl",
".",
"Index",
".",
"IndexName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"ic",
":=",
"range",
"indexCols",
"{",
"var",
"field",
"*",
"Field",
"\n",
"fieldLoop",
":",
"for",
"_",
",",
"f",
":=",
"range",
"ixTpl",
".",
"Type",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"ic",
".",
"ColumnName",
"{",
"field",
"=",
"f",
"\n",
"break",
"fieldLoop",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"field",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"ixTpl",
".",
"Fields",
"=",
"append",
"(",
"ixTpl",
".",
"Fields",
",",
"field",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// LoadIndexColumns loads the index column information.
|
[
"LoadIndexColumns",
"loads",
"the",
"index",
"column",
"information",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L745-L775
|
train
|
xo/xo
|
examples/django/postgres/authpermission.xo.go
|
AuthPermissionByContentTypeIDCodename
|
func AuthPermissionByContentTypeIDCodename(db XODB, contentTypeID int, codename string) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE content_type_id = $1 AND codename = $2`
// run query
XOLog(sqlstr, contentTypeID, codename)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, contentTypeID, codename).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
}
|
go
|
func AuthPermissionByContentTypeIDCodename(db XODB, contentTypeID int, codename string) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE content_type_id = $1 AND codename = $2`
// run query
XOLog(sqlstr, contentTypeID, codename)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, contentTypeID, codename).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
}
|
[
"func",
"AuthPermissionByContentTypeIDCodename",
"(",
"db",
"XODB",
",",
"contentTypeID",
"int",
",",
"codename",
"string",
")",
"(",
"*",
"AuthPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name, content_type_id, codename `",
"+",
"`FROM public.auth_permission `",
"+",
"`WHERE content_type_id = $1 AND codename = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"contentTypeID",
",",
"codename",
")",
"\n",
"ap",
":=",
"AuthPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"contentTypeID",
",",
"codename",
")",
".",
"Scan",
"(",
"&",
"ap",
".",
"ID",
",",
"&",
"ap",
".",
"Name",
",",
"&",
"ap",
".",
"ContentTypeID",
",",
"&",
"ap",
".",
"Codename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ap",
",",
"nil",
"\n",
"}"
] |
// AuthPermissionByContentTypeIDCodename retrieves a row from 'public.auth_permission' as a AuthPermission.
//
// Generated from index 'auth_permission_content_type_id_01ab375a_uniq'.
|
[
"AuthPermissionByContentTypeIDCodename",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_permission",
"as",
"a",
"AuthPermission",
".",
"Generated",
"from",
"index",
"auth_permission_content_type_id_01ab375a_uniq",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authpermission.xo.go#L210-L231
|
train
|
xo/xo
|
examples/django/postgres/authpermission.xo.go
|
AuthPermissionByID
|
func AuthPermissionByID(db XODB, id int) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
}
|
go
|
func AuthPermissionByID(db XODB, id int) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
}
|
[
"func",
"AuthPermissionByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name, content_type_id, codename `",
"+",
"`FROM public.auth_permission `",
"+",
"`WHERE id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"ap",
":=",
"AuthPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"ap",
".",
"ID",
",",
"&",
"ap",
".",
"Name",
",",
"&",
"ap",
".",
"ContentTypeID",
",",
"&",
"ap",
".",
"Codename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ap",
",",
"nil",
"\n",
"}"
] |
// AuthPermissionByID retrieves a row from 'public.auth_permission' as a AuthPermission.
//
// Generated from index 'auth_permission_pkey'.
|
[
"AuthPermissionByID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_permission",
"as",
"a",
"AuthPermission",
".",
"Generated",
"from",
"index",
"auth_permission_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authpermission.xo.go#L236-L257
|
train
|
xo/xo
|
models/sequence.xo.go
|
PgSequences
|
func PgSequences(db XODB, schema string) ([]*Sequence, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.relname ` + // ::varchar AS table_name
`FROM pg_class s ` +
`JOIN pg_depend d ON d.objid = s.oid ` +
`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid ` +
`JOIN pg_namespace n ON n.oid = s.relnamespace ` +
`WHERE n.nspname = $1 AND s.relkind = 'S'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Sequence{}
for q.Next() {
s := Sequence{}
// scan
err = q.Scan(&s.TableName)
if err != nil {
return nil, err
}
res = append(res, &s)
}
return res, nil
}
|
go
|
func PgSequences(db XODB, schema string) ([]*Sequence, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.relname ` + // ::varchar AS table_name
`FROM pg_class s ` +
`JOIN pg_depend d ON d.objid = s.oid ` +
`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid ` +
`JOIN pg_namespace n ON n.oid = s.relnamespace ` +
`WHERE n.nspname = $1 AND s.relkind = 'S'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Sequence{}
for q.Next() {
s := Sequence{}
// scan
err = q.Scan(&s.TableName)
if err != nil {
return nil, err
}
res = append(res, &s)
}
return res, nil
}
|
[
"func",
"PgSequences",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"Sequence",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`t.relname `",
"+",
"`FROM pg_class s `",
"+",
"`JOIN pg_depend d ON d.objid = s.oid `",
"+",
"`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid `",
"+",
"`JOIN pg_namespace n ON n.oid = s.relnamespace `",
"+",
"`WHERE n.nspname = $1 AND s.relkind = 'S'`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"Sequence",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"s",
":=",
"Sequence",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"s",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"s",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgSequences runs a custom query, returning results as Sequence.
|
[
"PgSequences",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Sequence",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/sequence.xo.go#L12-L47
|
train
|
xo/xo
|
models/sqcolumn.xo.go
|
SqTableColumns
|
func SqTableColumns(db XODB, table string) ([]*SqColumn, error) {
var err error
// sql query
var sqlstr = `PRAGMA table_info(` + table + `)`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqColumn{}
for q.Next() {
sc := SqColumn{}
// scan
err = q.Scan(&sc.FieldOrdinal, &sc.ColumnName, &sc.DataType, &sc.NotNull, &sc.DefaultValue, &sc.PkColIndex)
if err != nil {
return nil, err
}
res = append(res, &sc)
}
return res, nil
}
|
go
|
func SqTableColumns(db XODB, table string) ([]*SqColumn, error) {
var err error
// sql query
var sqlstr = `PRAGMA table_info(` + table + `)`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqColumn{}
for q.Next() {
sc := SqColumn{}
// scan
err = q.Scan(&sc.FieldOrdinal, &sc.ColumnName, &sc.DataType, &sc.NotNull, &sc.DefaultValue, &sc.PkColIndex)
if err != nil {
return nil, err
}
res = append(res, &sc)
}
return res, nil
}
|
[
"func",
"SqTableColumns",
"(",
"db",
"XODB",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"SqColumn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"sqlstr",
"=",
"`PRAGMA table_info(`",
"+",
"table",
"+",
"`)`",
"\n",
"XOLog",
"(",
"sqlstr",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"SqColumn",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"sc",
":=",
"SqColumn",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"sc",
".",
"FieldOrdinal",
",",
"&",
"sc",
".",
"ColumnName",
",",
"&",
"sc",
".",
"DataType",
",",
"&",
"sc",
".",
"NotNull",
",",
"&",
"sc",
".",
"DefaultValue",
",",
"&",
"sc",
".",
"PkColIndex",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"sc",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// SqTableColumns runs a custom query, returning results as SqColumn.
|
[
"SqTableColumns",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"SqColumn",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/sqcolumn.xo.go#L21-L50
|
train
|
xo/xo
|
examples/django/oracle/authuseruserpermission.xo.go
|
Save
|
func (auup *AuthUserUserPermission) Save(db XODB) error {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
}
|
go
|
func (auup *AuthUserUserPermission) Save(db XODB) error {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
}
|
[
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"auup",
".",
"Exists",
"(",
")",
"{",
"return",
"auup",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"auup",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthUserUserPermission to the database.
|
[
"Save",
"saves",
"the",
"AuthUserUserPermission",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L90-L96
|
train
|
xo/xo
|
examples/django/oracle/authuseruserpermission.xo.go
|
AuthUserUserPermissionByUserIDPermissionID
|
func AuthUserUserPermissionByUserIDPermissionID(db XODB, userID float64, permissionID float64) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, userID, permissionID)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, permissionID).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
}
|
go
|
func AuthUserUserPermissionByUserIDPermissionID(db XODB, userID float64, permissionID float64) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, userID, permissionID)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, permissionID).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
}
|
[
"func",
"AuthUserUserPermissionByUserIDPermissionID",
"(",
"db",
"XODB",
",",
"userID",
"float64",
",",
"permissionID",
"float64",
")",
"(",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM django.auth_user_user_permissions `",
"+",
"`WHERE user_id = :1 AND permission_id = :2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"userID",
",",
"permissionID",
")",
"\n",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"userID",
",",
"permissionID",
")",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"auup",
",",
"nil",
"\n",
"}"
] |
// AuthUserUserPermissionByUserIDPermissionID retrieves a row from 'django.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_use_user_id_14a6b632_uniq'.
|
[
"AuthUserUserPermissionByUserIDPermissionID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_use_user_id_14a6b632_uniq",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L145-L166
|
train
|
xo/xo
|
examples/django/oracle/authuseruserpermission.xo.go
|
AuthUserUserPermissionsByUserID
|
func AuthUserUserPermissionsByUserID(db XODB, userID float64) ([]*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1`
// run query
XOLog(sqlstr, userID)
q, err := db.Query(sqlstr, userID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserUserPermission{}
for q.Next() {
auup := AuthUserUserPermission{
_exists: true,
}
// scan
err = q.Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &auup)
}
return res, nil
}
|
go
|
func AuthUserUserPermissionsByUserID(db XODB, userID float64) ([]*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1`
// run query
XOLog(sqlstr, userID)
q, err := db.Query(sqlstr, userID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserUserPermission{}
for q.Next() {
auup := AuthUserUserPermission{
_exists: true,
}
// scan
err = q.Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &auup)
}
return res, nil
}
|
[
"func",
"AuthUserUserPermissionsByUserID",
"(",
"db",
"XODB",
",",
"userID",
"float64",
")",
"(",
"[",
"]",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM django.auth_user_user_permissions `",
"+",
"`WHERE user_id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"userID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"userID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"AuthUserUserPermission",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"auup",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthUserUserPermissionsByUserID retrieves a row from 'django.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_user_user_permissions1cca'.
|
[
"AuthUserUserPermissionsByUserID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_user_user_permissions1cca",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L171-L205
|
train
|
xo/xo
|
examples/django/sqlite3/djangomigration.xo.go
|
Save
|
func (dm *DjangoMigration) Save(db XODB) error {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
}
|
go
|
func (dm *DjangoMigration) Save(db XODB) error {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
}
|
[
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"dm",
".",
"Exists",
"(",
")",
"{",
"return",
"dm",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"dm",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the DjangoMigration to the database.
|
[
"Save",
"saves",
"the",
"DjangoMigration",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/djangomigration.xo.go#L94-L100
|
train
|
xo/xo
|
loaders/mysql.go
|
MySchema
|
func MySchema(args *internal.ArgType) (string, error) {
var err error
// sql query
const sqlstr = `SELECT SCHEMA()`
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
}
|
go
|
func MySchema(args *internal.ArgType) (string, error) {
var err error
// sql query
const sqlstr = `SELECT SCHEMA()`
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
}
|
[
"func",
"MySchema",
"(",
"args",
"*",
"internal",
".",
"ArgType",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT SCHEMA()`",
"\n",
"var",
"schema",
"string",
"\n",
"models",
".",
"XOLog",
"(",
"sqlstr",
")",
"\n",
"err",
"=",
"args",
".",
"DB",
".",
"QueryRow",
"(",
"sqlstr",
")",
".",
"Scan",
"(",
"&",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"schema",
",",
"nil",
"\n",
"}"
] |
// MySchema retrieves the name of the current schema.
|
[
"MySchema",
"retrieves",
"the",
"name",
"of",
"the",
"current",
"schema",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L35-L51
|
train
|
xo/xo
|
loaders/mysql.go
|
MyEnumValues
|
func MyEnumValues(db models.XODB, schema string, enum string) ([]*models.EnumValue, error) {
var err error
// load enum vals
res, err := models.MyEnumValues(db, schema, enum)
if err != nil {
return nil, err
}
// process enum vals
enumVals := []*models.EnumValue{}
for i, ev := range strings.Split(res.EnumValues[1:len(res.EnumValues)-1], "','") {
enumVals = append(enumVals, &models.EnumValue{
EnumValue: ev,
ConstValue: i + 1,
})
}
return enumVals, nil
}
|
go
|
func MyEnumValues(db models.XODB, schema string, enum string) ([]*models.EnumValue, error) {
var err error
// load enum vals
res, err := models.MyEnumValues(db, schema, enum)
if err != nil {
return nil, err
}
// process enum vals
enumVals := []*models.EnumValue{}
for i, ev := range strings.Split(res.EnumValues[1:len(res.EnumValues)-1], "','") {
enumVals = append(enumVals, &models.EnumValue{
EnumValue: ev,
ConstValue: i + 1,
})
}
return enumVals, nil
}
|
[
"func",
"MyEnumValues",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"enum",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"EnumValue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"res",
",",
"err",
":=",
"models",
".",
"MyEnumValues",
"(",
"db",
",",
"schema",
",",
"enum",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"enumVals",
":=",
"[",
"]",
"*",
"models",
".",
"EnumValue",
"{",
"}",
"\n",
"for",
"i",
",",
"ev",
":=",
"range",
"strings",
".",
"Split",
"(",
"res",
".",
"EnumValues",
"[",
"1",
":",
"len",
"(",
"res",
".",
"EnumValues",
")",
"-",
"1",
"]",
",",
"\"','\"",
")",
"{",
"enumVals",
"=",
"append",
"(",
"enumVals",
",",
"&",
"models",
".",
"EnumValue",
"{",
"EnumValue",
":",
"ev",
",",
"ConstValue",
":",
"i",
"+",
"1",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"enumVals",
",",
"nil",
"\n",
"}"
] |
// MyEnumValues loads the enum values.
|
[
"MyEnumValues",
"loads",
"the",
"enum",
"values",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L221-L240
|
train
|
xo/xo
|
loaders/mysql.go
|
MyTables
|
func MyTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MyTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Autoincrementing included
autoIncrements, err := models.MyAutoIncrements(db, schema)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.MyAutoIncrement{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the autoincrement
for _, autoInc := range autoIncrements {
if autoInc.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
go
|
func MyTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MyTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Autoincrementing included
autoIncrements, err := models.MyAutoIncrements(db, schema)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.MyAutoIncrement{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the autoincrement
for _, autoInc := range autoIncrements {
if autoInc.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
[
"func",
"MyTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"rows",
",",
"err",
":=",
"models",
".",
"MyTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"autoIncrements",
",",
"err",
":=",
"models",
".",
"MyAutoIncrements",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"autoIncrements",
"=",
"[",
"]",
"*",
"models",
".",
"MyAutoIncrement",
"{",
"}",
"\n",
"}",
"\n",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"for",
"_",
",",
"autoInc",
":=",
"range",
"autoIncrements",
"{",
"if",
"autoInc",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] |
// MyTables returns the MySql tables with the manual PK information added.
// ManualPk is true when the table's primary key is not autoincrement.
|
[
"MyTables",
"returns",
"the",
"MySql",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"s",
"primary",
"key",
"is",
"not",
"autoincrement",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L244-L278
|
train
|
xo/xo
|
loaders/mysql.go
|
MyQueryColumns
|
func MyQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MyTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
}
|
go
|
func MyQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MyTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
}
|
[
"func",
"MyQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"xoid",
":=",
"\"_xo_\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE VIEW `",
"+",
"xoid",
"+",
"` AS (`",
"+",
"strings",
".",
"Join",
"(",
"inspect",
",",
"\"\\n\"",
")",
"+",
"\\n",
"\n",
"`)`",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cols",
",",
"err",
":=",
"models",
".",
"MyTableColumns",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"xoid",
")",
"\n",
"dropq",
":=",
"`DROP VIEW `",
"+",
"xoid",
"\n",
"models",
".",
"XOLog",
"(",
"dropq",
")",
"\n",
"_",
",",
"_",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"dropq",
")",
"\n",
"}"
] |
// MyQueryColumns parses the query and generates a type for it.
|
[
"MyQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L281-L303
|
train
|
xo/xo
|
internal/argtype.go
|
NewDefaultArgs
|
func NewDefaultArgs() *ArgType {
fkMode := FkModeSmart
return &ArgType{
Suffix: ".xo.go",
Int32Type: "int",
Uint32Type: "uint",
ForeignKeyMode: &fkMode,
QueryParamDelimiter: "%%",
NameConflictSuffix: "Val",
// KnownTypeMap is the collection of known Go types.
KnownTypeMap: map[string]bool{
"bool": true,
"string": true,
"byte": true,
"rune": true,
"int": true,
"int16": true,
"int32": true,
"int64": true,
"uint": true,
"uint8": true,
"uint16": true,
"uint32": true,
"uint64": true,
"float32": true,
"float64": true,
"Slice": true,
"StringSlice": true,
},
// ShortNameTypeMap is the collection of Go style short names for types, mainly
// used for use with declaring a func receiver on a type.
ShortNameTypeMap: map[string]string{
"bool": "b",
"string": "s",
"byte": "b",
"rune": "r",
"int": "i",
"int16": "i",
"int32": "i",
"int64": "i",
"uint": "u",
"uint8": "u",
"uint16": "u",
"uint32": "u",
"uint64": "u",
"float32": "f",
"float64": "f",
"Slice": "s",
"StringSlice": "ss",
},
}
}
|
go
|
func NewDefaultArgs() *ArgType {
fkMode := FkModeSmart
return &ArgType{
Suffix: ".xo.go",
Int32Type: "int",
Uint32Type: "uint",
ForeignKeyMode: &fkMode,
QueryParamDelimiter: "%%",
NameConflictSuffix: "Val",
// KnownTypeMap is the collection of known Go types.
KnownTypeMap: map[string]bool{
"bool": true,
"string": true,
"byte": true,
"rune": true,
"int": true,
"int16": true,
"int32": true,
"int64": true,
"uint": true,
"uint8": true,
"uint16": true,
"uint32": true,
"uint64": true,
"float32": true,
"float64": true,
"Slice": true,
"StringSlice": true,
},
// ShortNameTypeMap is the collection of Go style short names for types, mainly
// used for use with declaring a func receiver on a type.
ShortNameTypeMap: map[string]string{
"bool": "b",
"string": "s",
"byte": "b",
"rune": "r",
"int": "i",
"int16": "i",
"int32": "i",
"int64": "i",
"uint": "u",
"uint8": "u",
"uint16": "u",
"uint32": "u",
"uint64": "u",
"float32": "f",
"float64": "f",
"Slice": "s",
"StringSlice": "ss",
},
}
}
|
[
"func",
"NewDefaultArgs",
"(",
")",
"*",
"ArgType",
"{",
"fkMode",
":=",
"FkModeSmart",
"\n",
"return",
"&",
"ArgType",
"{",
"Suffix",
":",
"\".xo.go\"",
",",
"Int32Type",
":",
"\"int\"",
",",
"Uint32Type",
":",
"\"uint\"",
",",
"ForeignKeyMode",
":",
"&",
"fkMode",
",",
"QueryParamDelimiter",
":",
"\"%%\"",
",",
"NameConflictSuffix",
":",
"\"Val\"",
",",
"KnownTypeMap",
":",
"map",
"[",
"string",
"]",
"bool",
"{",
"\"bool\"",
":",
"true",
",",
"\"string\"",
":",
"true",
",",
"\"byte\"",
":",
"true",
",",
"\"rune\"",
":",
"true",
",",
"\"int\"",
":",
"true",
",",
"\"int16\"",
":",
"true",
",",
"\"int32\"",
":",
"true",
",",
"\"int64\"",
":",
"true",
",",
"\"uint\"",
":",
"true",
",",
"\"uint8\"",
":",
"true",
",",
"\"uint16\"",
":",
"true",
",",
"\"uint32\"",
":",
"true",
",",
"\"uint64\"",
":",
"true",
",",
"\"float32\"",
":",
"true",
",",
"\"float64\"",
":",
"true",
",",
"\"Slice\"",
":",
"true",
",",
"\"StringSlice\"",
":",
"true",
",",
"}",
",",
"ShortNameTypeMap",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"bool\"",
":",
"\"b\"",
",",
"\"string\"",
":",
"\"s\"",
",",
"\"byte\"",
":",
"\"b\"",
",",
"\"rune\"",
":",
"\"r\"",
",",
"\"int\"",
":",
"\"i\"",
",",
"\"int16\"",
":",
"\"i\"",
",",
"\"int32\"",
":",
"\"i\"",
",",
"\"int64\"",
":",
"\"i\"",
",",
"\"uint\"",
":",
"\"u\"",
",",
"\"uint8\"",
":",
"\"u\"",
",",
"\"uint16\"",
":",
"\"u\"",
",",
"\"uint32\"",
":",
"\"u\"",
",",
"\"uint64\"",
":",
"\"u\"",
",",
"\"float32\"",
":",
"\"f\"",
",",
"\"float64\"",
":",
"\"f\"",
",",
"\"Slice\"",
":",
"\"s\"",
",",
"\"StringSlice\"",
":",
"\"ss\"",
",",
"}",
",",
"}",
"\n",
"}"
] |
// NewDefaultArgs returns the default arguments.
|
[
"NewDefaultArgs",
"returns",
"the",
"default",
"arguments",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/argtype.go#L156-L210
|
train
|
xo/xo
|
models/msidentity.xo.go
|
MsIdentities
|
func MsIdentities(db XODB, schema string) ([]*MsIdentity, error) {
var err error
// sql query
const sqlstr = `SELECT o.name as table_name ` +
`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id ` +
`WHERE c.is_identity = 1 ` +
`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MsIdentity{}
for q.Next() {
mi := MsIdentity{}
// scan
err = q.Scan(&mi.TableName)
if err != nil {
return nil, err
}
res = append(res, &mi)
}
return res, nil
}
|
go
|
func MsIdentities(db XODB, schema string) ([]*MsIdentity, error) {
var err error
// sql query
const sqlstr = `SELECT o.name as table_name ` +
`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id ` +
`WHERE c.is_identity = 1 ` +
`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MsIdentity{}
for q.Next() {
mi := MsIdentity{}
// scan
err = q.Scan(&mi.TableName)
if err != nil {
return nil, err
}
res = append(res, &mi)
}
return res, nil
}
|
[
"func",
"MsIdentities",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"MsIdentity",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT o.name as table_name `",
"+",
"`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id `",
"+",
"`WHERE c.is_identity = 1 `",
"+",
"`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"MsIdentity",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"mi",
":=",
"MsIdentity",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"mi",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"mi",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// MsIdentities runs a custom query, returning results as MsIdentity.
|
[
"MsIdentities",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"MsIdentity",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/msidentity.xo.go#L12-L44
|
train
|
xo/xo
|
loaders/postgres.go
|
PgRelkind
|
func PgRelkind(relType internal.RelType) string {
var s string
switch relType {
case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
}
|
go
|
func PgRelkind(relType internal.RelType) string {
var s string
switch relType {
case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
}
|
[
"func",
"PgRelkind",
"(",
"relType",
"internal",
".",
"RelType",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"switch",
"relType",
"{",
"case",
"internal",
".",
"Table",
":",
"s",
"=",
"\"r\"",
"\n",
"case",
"internal",
".",
"View",
":",
"s",
"=",
"\"v\"",
"\n",
"default",
":",
"panic",
"(",
"\"unsupported RelType\"",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// PgRelkind returns the postgres string representation for RelType.
|
[
"PgRelkind",
"returns",
"the",
"postgres",
"string",
"representation",
"for",
"RelType",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L39-L50
|
train
|
xo/xo
|
loaders/postgres.go
|
PgQueryStrip
|
func PgQueryStrip(query []string, queryComments []string) {
for i, l := range query {
pos := pgQueryStripRE.FindStringIndex(l)
if pos != nil {
query[i] = l[:pos[0]] + l[pos[1]:]
queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
}
|
go
|
func PgQueryStrip(query []string, queryComments []string) {
for i, l := range query {
pos := pgQueryStripRE.FindStringIndex(l)
if pos != nil {
query[i] = l[:pos[0]] + l[pos[1]:]
queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
}
|
[
"func",
"PgQueryStrip",
"(",
"query",
"[",
"]",
"string",
",",
"queryComments",
"[",
"]",
"string",
")",
"{",
"for",
"i",
",",
"l",
":=",
"range",
"query",
"{",
"pos",
":=",
"pgQueryStripRE",
".",
"FindStringIndex",
"(",
"l",
")",
"\n",
"if",
"pos",
"!=",
"nil",
"{",
"query",
"[",
"i",
"]",
"=",
"l",
"[",
":",
"pos",
"[",
"0",
"]",
"]",
"+",
"l",
"[",
"pos",
"[",
"1",
"]",
":",
"]",
"\n",
"queryComments",
"[",
"i",
"+",
"1",
"]",
"=",
"l",
"[",
"pos",
"[",
"0",
"]",
":",
"pos",
"[",
"1",
"]",
"]",
"\n",
"}",
"else",
"{",
"queryComments",
"[",
"i",
"+",
"1",
"]",
"=",
"\"\"",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// PgQueryStrip strips stuff.
|
[
"PgQueryStrip",
"strips",
"stuff",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L219-L229
|
train
|
xo/xo
|
loaders/postgres.go
|
PgTables
|
func PgTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.PgTables(db, schema, relkind)
if err != nil {
return nil, err
}
// Get the tables that have a sequence defined.
sequences, err := models.PgSequences(db, schema)
if err != nil {
// Set it to an empty set on error.
sequences = []*models.Sequence{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the sequence
for _, sequence := range sequences {
if sequence.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
go
|
func PgTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.PgTables(db, schema, relkind)
if err != nil {
return nil, err
}
// Get the tables that have a sequence defined.
sequences, err := models.PgSequences(db, schema)
if err != nil {
// Set it to an empty set on error.
sequences = []*models.Sequence{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the sequence
for _, sequence := range sequences {
if sequence.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
[
"func",
"PgTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"rows",
",",
"err",
":=",
"models",
".",
"PgTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"sequences",
",",
"err",
":=",
"models",
".",
"PgSequences",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"sequences",
"=",
"[",
"]",
"*",
"models",
".",
"Sequence",
"{",
"}",
"\n",
"}",
"\n",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"for",
"_",
",",
"sequence",
":=",
"range",
"sequences",
"{",
"if",
"sequence",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] |
// PgTables returns the Postgres tables with the manual PK information added.
// ManualPk is true when the table does not have a sequence defined.
|
[
"PgTables",
"returns",
"the",
"Postgres",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"does",
"not",
"have",
"a",
"sequence",
"defined",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L233-L267
|
train
|
xo/xo
|
loaders/postgres.go
|
PgQueryColumns
|
func PgQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// query to determine schema name where temporary view was created
var nspq = `SELECT n.nspname ` +
`FROM pg_class c ` +
`JOIN pg_namespace n ON n.oid = c.relnamespace ` +
`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`
// run query
var schema string
models.XOLog(nspq, xoid)
err = args.DB.QueryRow(nspq, xoid).Scan(&schema)
if err != nil {
return nil, err
}
// load column information
return models.PgTableColumns(args.DB, schema, xoid, false)
}
|
go
|
func PgQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// query to determine schema name where temporary view was created
var nspq = `SELECT n.nspname ` +
`FROM pg_class c ` +
`JOIN pg_namespace n ON n.oid = c.relnamespace ` +
`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`
// run query
var schema string
models.XOLog(nspq, xoid)
err = args.DB.QueryRow(nspq, xoid).Scan(&schema)
if err != nil {
return nil, err
}
// load column information
return models.PgTableColumns(args.DB, schema, xoid, false)
}
|
[
"func",
"PgQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"xoid",
":=",
"\"_xo_\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE TEMPORARY VIEW `",
"+",
"xoid",
"+",
"` AS (`",
"+",
"strings",
".",
"Join",
"(",
"inspect",
",",
"\"\\n\"",
")",
"+",
"\\n",
"\n",
"`)`",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"nspq",
"=",
"`SELECT n.nspname `",
"+",
"`FROM pg_class c `",
"+",
"`JOIN pg_namespace n ON n.oid = c.relnamespace `",
"+",
"`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`",
"\n",
"var",
"schema",
"string",
"\n",
"models",
".",
"XOLog",
"(",
"nspq",
",",
"xoid",
")",
"\n",
"err",
"=",
"args",
".",
"DB",
".",
"QueryRow",
"(",
"nspq",
",",
"xoid",
")",
".",
"Scan",
"(",
"&",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// PgQueryColumns parses the query and generates a type for it.
|
[
"PgQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L270-L298
|
train
|
xo/xo
|
loaders/postgres.go
|
PgIndexColumns
|
func PgIndexColumns(db models.XODB, schema string, table string, index string) ([]*models.IndexColumn, error) {
var err error
// load columns
cols, err := models.PgIndexColumns(db, schema, index)
if err != nil {
return nil, err
}
// load col order
colOrd, err := models.PgGetColOrder(db, schema, index)
if err != nil {
return nil, err
}
// build schema name used in errors
s := schema
if s != "" {
s = s + "."
}
// put cols in order using colOrder
ret := []*models.IndexColumn{}
for _, v := range strings.Split(colOrd.Ord, " ") {
cid, err := strconv.Atoi(v)
if err != nil {
return nil, fmt.Errorf("could not convert %s%s index %s column %s to int", s, table, index, v)
}
// find column
found := false
var c *models.IndexColumn
for _, ic := range cols {
if cid == ic.Cid {
found = true
c = ic
break
}
}
// sanity check
if !found {
return nil, fmt.Errorf("could not find %s%s index %s column id %d", s, table, index, cid)
}
ret = append(ret, c)
}
return ret, nil
}
|
go
|
func PgIndexColumns(db models.XODB, schema string, table string, index string) ([]*models.IndexColumn, error) {
var err error
// load columns
cols, err := models.PgIndexColumns(db, schema, index)
if err != nil {
return nil, err
}
// load col order
colOrd, err := models.PgGetColOrder(db, schema, index)
if err != nil {
return nil, err
}
// build schema name used in errors
s := schema
if s != "" {
s = s + "."
}
// put cols in order using colOrder
ret := []*models.IndexColumn{}
for _, v := range strings.Split(colOrd.Ord, " ") {
cid, err := strconv.Atoi(v)
if err != nil {
return nil, fmt.Errorf("could not convert %s%s index %s column %s to int", s, table, index, v)
}
// find column
found := false
var c *models.IndexColumn
for _, ic := range cols {
if cid == ic.Cid {
found = true
c = ic
break
}
}
// sanity check
if !found {
return nil, fmt.Errorf("could not find %s%s index %s column id %d", s, table, index, cid)
}
ret = append(ret, c)
}
return ret, nil
}
|
[
"func",
"PgIndexColumns",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
",",
"index",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"IndexColumn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"cols",
",",
"err",
":=",
"models",
".",
"PgIndexColumns",
"(",
"db",
",",
"schema",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"colOrd",
",",
"err",
":=",
"models",
".",
"PgGetColOrder",
"(",
"db",
",",
"schema",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"s",
":=",
"schema",
"\n",
"if",
"s",
"!=",
"\"\"",
"{",
"s",
"=",
"s",
"+",
"\".\"",
"\n",
"}",
"\n",
"ret",
":=",
"[",
"]",
"*",
"models",
".",
"IndexColumn",
"{",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"strings",
".",
"Split",
"(",
"colOrd",
".",
"Ord",
",",
"\" \"",
")",
"{",
"cid",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not convert %s%s index %s column %s to int\"",
",",
"s",
",",
"table",
",",
"index",
",",
"v",
")",
"\n",
"}",
"\n",
"found",
":=",
"false",
"\n",
"var",
"c",
"*",
"models",
".",
"IndexColumn",
"\n",
"for",
"_",
",",
"ic",
":=",
"range",
"cols",
"{",
"if",
"cid",
"==",
"ic",
".",
"Cid",
"{",
"found",
"=",
"true",
"\n",
"c",
"=",
"ic",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"could not find %s%s index %s column id %d\"",
",",
"s",
",",
"table",
",",
"index",
",",
"cid",
")",
"\n",
"}",
"\n",
"ret",
"=",
"append",
"(",
"ret",
",",
"c",
")",
"\n",
"}",
"\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] |
// PgIndexColumns returns the column list for an index.
|
[
"PgIndexColumns",
"returns",
"the",
"column",
"list",
"for",
"an",
"index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L301-L350
|
train
|
xo/xo
|
examples/django/postgres/djangocontenttype.xo.go
|
Update
|
func (dct *DjangoContentType) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dct._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_content_type SET (` +
`app_label, model` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, dct.AppLabel, dct.Model, dct.ID)
_, err = db.Exec(sqlstr, dct.AppLabel, dct.Model, dct.ID)
return err
}
|
go
|
func (dct *DjangoContentType) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dct._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_content_type SET (` +
`app_label, model` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, dct.AppLabel, dct.Model, dct.ID)
_, err = db.Exec(sqlstr, dct.AppLabel, dct.Model, dct.ID)
return err
}
|
[
"func",
"(",
"dct",
"*",
"DjangoContentType",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dct",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"dct",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE public.django_content_type SET (`",
"+",
"`app_label, model`",
"+",
"`) = ( `",
"+",
"`$1, $2`",
"+",
"`) WHERE id = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dct",
".",
"AppLabel",
",",
"dct",
".",
"Model",
",",
"dct",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dct",
".",
"AppLabel",
",",
"dct",
".",
"Model",
",",
"dct",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the DjangoContentType in the database.
|
[
"Update",
"updates",
"the",
"DjangoContentType",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangocontenttype.xo.go#L60-L84
|
train
|
xo/xo
|
examples/django/postgres/djangocontenttype.xo.go
|
Delete
|
func (dct *DjangoContentType) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return nil
}
// if deleted, bail
if dct._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.django_content_type WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err = db.Exec(sqlstr, dct.ID)
if err != nil {
return err
}
// set deleted
dct._deleted = true
return nil
}
|
go
|
func (dct *DjangoContentType) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return nil
}
// if deleted, bail
if dct._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.django_content_type WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err = db.Exec(sqlstr, dct.ID)
if err != nil {
return err
}
// set deleted
dct._deleted = true
return nil
}
|
[
"func",
"(",
"dct",
"*",
"DjangoContentType",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dct",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"dct",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM public.django_content_type WHERE id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dct",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dct",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"dct",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the DjangoContentType from the database.
|
[
"Delete",
"deletes",
"the",
"DjangoContentType",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangocontenttype.xo.go#L131-L158
|
train
|
xo/xo
|
examples/django/oracle/authgrouppermission.xo.go
|
AuthGroupPermissionByGroupIDPermissionID
|
func AuthGroupPermissionByGroupIDPermissionID(db XODB, groupID float64, permissionID float64) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE group_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, groupID, permissionID)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, groupID, permissionID).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
}
|
go
|
func AuthGroupPermissionByGroupIDPermissionID(db XODB, groupID float64, permissionID float64) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE group_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, groupID, permissionID)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, groupID, permissionID).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
}
|
[
"func",
"AuthGroupPermissionByGroupIDPermissionID",
"(",
"db",
"XODB",
",",
"groupID",
"float64",
",",
"permissionID",
"float64",
")",
"(",
"*",
"AuthGroupPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, group_id, permission_id `",
"+",
"`FROM django.auth_group_permissions `",
"+",
"`WHERE group_id = :1 AND permission_id = :2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"groupID",
",",
"permissionID",
")",
"\n",
"agp",
":=",
"AuthGroupPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"groupID",
",",
"permissionID",
")",
".",
"Scan",
"(",
"&",
"agp",
".",
"ID",
",",
"&",
"agp",
".",
"GroupID",
",",
"&",
"agp",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"agp",
",",
"nil",
"\n",
"}"
] |
// AuthGroupPermissionByGroupIDPermissionID retrieves a row from 'django.auth_group_permissions' as a AuthGroupPermission.
//
// Generated from index 'auth_gr_group_id_0cd325b0_uniq'.
|
[
"AuthGroupPermissionByGroupIDPermissionID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_group_permissions",
"as",
"a",
"AuthGroupPermission",
".",
"Generated",
"from",
"index",
"auth_gr_group_id_0cd325b0_uniq",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authgrouppermission.xo.go#L145-L166
|
train
|
xo/xo
|
models/procparam.xo.go
|
PgProcParams
|
func PgProcParams(db XODB, schema string, proc string) ([]*ProcParam, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) ` + // ::varchar AS param_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1 AND p.proname = $2`
// run query
XOLog(sqlstr, schema, proc)
q, err := db.Query(sqlstr, schema, proc)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*ProcParam{}
for q.Next() {
pp := ProcParam{}
// scan
err = q.Scan(&pp.ParamType)
if err != nil {
return nil, err
}
res = append(res, &pp)
}
return res, nil
}
|
go
|
func PgProcParams(db XODB, schema string, proc string) ([]*ProcParam, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) ` + // ::varchar AS param_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1 AND p.proname = $2`
// run query
XOLog(sqlstr, schema, proc)
q, err := db.Query(sqlstr, schema, proc)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*ProcParam{}
for q.Next() {
pp := ProcParam{}
// scan
err = q.Scan(&pp.ParamType)
if err != nil {
return nil, err
}
res = append(res, &pp)
}
return res, nil
}
|
[
"func",
"PgProcParams",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"proc",
"string",
")",
"(",
"[",
"]",
"*",
"ProcParam",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) `",
"+",
"`FROM pg_proc p `",
"+",
"`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid `",
"+",
"`WHERE n.nspname = $1 AND p.proname = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"proc",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"proc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"ProcParam",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pp",
":=",
"ProcParam",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pp",
".",
"ParamType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pp",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgProcParams runs a custom query, returning results as ProcParam.
|
[
"PgProcParams",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"ProcParam",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/procparam.xo.go#L12-L45
|
train
|
xo/xo
|
examples/django/mysql/authusergroup.xo.go
|
AuthUserGroupsByGroupID
|
func AuthUserGroupsByGroupID(db XODB, groupID int) ([]*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE group_id = ?`
// run query
XOLog(sqlstr, groupID)
q, err := db.Query(sqlstr, groupID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserGroup{}
for q.Next() {
aug := AuthUserGroup{
_exists: true,
}
// scan
err = q.Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
res = append(res, &aug)
}
return res, nil
}
|
go
|
func AuthUserGroupsByGroupID(db XODB, groupID int) ([]*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE group_id = ?`
// run query
XOLog(sqlstr, groupID)
q, err := db.Query(sqlstr, groupID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserGroup{}
for q.Next() {
aug := AuthUserGroup{
_exists: true,
}
// scan
err = q.Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
res = append(res, &aug)
}
return res, nil
}
|
[
"func",
"AuthUserGroupsByGroupID",
"(",
"db",
"XODB",
",",
"groupID",
"int",
")",
"(",
"[",
"]",
"*",
"AuthUserGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, group_id `",
"+",
"`FROM django.auth_user_groups `",
"+",
"`WHERE group_id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"groupID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"groupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"AuthUserGroup",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"aug",
":=",
"AuthUserGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"aug",
".",
"ID",
",",
"&",
"aug",
".",
"UserID",
",",
"&",
"aug",
".",
"GroupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"aug",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthUserGroupsByGroupID retrieves a row from 'django.auth_user_groups' as a AuthUserGroup.
//
// Generated from index 'auth_user_groups_group_id_97559544_fk_auth_group_id'.
|
[
"AuthUserGroupsByGroupID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_groups",
"as",
"a",
"AuthUserGroup",
".",
"Generated",
"from",
"index",
"auth_user_groups_group_id_97559544_fk_auth_group_id",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authusergroup.xo.go#L147-L181
|
train
|
xo/xo
|
examples/django/mysql/authusergroup.xo.go
|
AuthUserGroupByID
|
func AuthUserGroupByID(db XODB, id int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
}
|
go
|
func AuthUserGroupByID(db XODB, id int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
}
|
[
"func",
"AuthUserGroupByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthUserGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, group_id `",
"+",
"`FROM django.auth_user_groups `",
"+",
"`WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"aug",
":=",
"AuthUserGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"aug",
".",
"ID",
",",
"&",
"aug",
".",
"UserID",
",",
"&",
"aug",
".",
"GroupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"aug",
",",
"nil",
"\n",
"}"
] |
// AuthUserGroupByID retrieves a row from 'django.auth_user_groups' as a AuthUserGroup.
//
// Generated from index 'auth_user_groups_id_pkey'.
|
[
"AuthUserGroupByID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_groups",
"as",
"a",
"AuthUserGroup",
".",
"Generated",
"from",
"index",
"auth_user_groups_id_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authusergroup.xo.go#L186-L207
|
train
|
xo/xo
|
loaders/mssql.go
|
MsParseType
|
func MsParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
var typ string
switch dt {
case "tinyint", "bit":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "char", "varchar", "text", "nchar", "nvarchar", "ntext", "smallmoney", "money":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
case "smallint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "int":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigint":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "smallserial":
nilVal = "0"
typ = "uint16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "serial":
nilVal = "0"
typ = args.Uint32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigserial":
nilVal = "0"
typ = "uint64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "real":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "numeric", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "binary", "varbinary":
typ = "[]byte"
case "datetime", "datetime2", "timestamp":
nilVal = "time.Time{}"
typ = "time.Time"
case "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "interval":
typ = "*time.Duration"
default:
if strings.HasPrefix(dt, args.Schema+".") {
// in the same schema, so chop off
typ = snaker.SnakeToCamelIdentifier(dt[len(args.Schema)+1:])
nilVal = typ + "(0)"
} else {
typ = snaker.SnakeToCamelIdentifier(dt)
nilVal = typ + "{}"
}
}
return precision, nilVal, typ
}
|
go
|
func MsParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
var typ string
switch dt {
case "tinyint", "bit":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "char", "varchar", "text", "nchar", "nvarchar", "ntext", "smallmoney", "money":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
case "smallint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "int":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigint":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "smallserial":
nilVal = "0"
typ = "uint16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "serial":
nilVal = "0"
typ = args.Uint32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigserial":
nilVal = "0"
typ = "uint64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "real":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "numeric", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "binary", "varbinary":
typ = "[]byte"
case "datetime", "datetime2", "timestamp":
nilVal = "time.Time{}"
typ = "time.Time"
case "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "interval":
typ = "*time.Duration"
default:
if strings.HasPrefix(dt, args.Schema+".") {
// in the same schema, so chop off
typ = snaker.SnakeToCamelIdentifier(dt[len(args.Schema)+1:])
nilVal = typ + "(0)"
} else {
typ = snaker.SnakeToCamelIdentifier(dt)
nilVal = typ + "{}"
}
}
return precision, nilVal, typ
}
|
[
"func",
"MsParseType",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"dt",
"string",
",",
"nullable",
"bool",
")",
"(",
"int",
",",
"string",
",",
"string",
")",
"{",
"precision",
":=",
"0",
"\n",
"nilVal",
":=",
"\"nil\"",
"\n",
"dt",
",",
"precision",
",",
"_",
"=",
"args",
".",
"ParsePrecision",
"(",
"dt",
")",
"\n",
"var",
"typ",
"string",
"\n",
"switch",
"dt",
"{",
"case",
"\"tinyint\"",
",",
"\"bit\"",
":",
"nilVal",
"=",
"\"false\"",
"\n",
"typ",
"=",
"\"bool\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullBool{}\"",
"\n",
"typ",
"=",
"\"sql.NullBool\"",
"\n",
"}",
"\n",
"case",
"\"char\"",
",",
"\"varchar\"",
",",
"\"text\"",
",",
"\"nchar\"",
",",
"\"nvarchar\"",
",",
"\"ntext\"",
",",
"\"smallmoney\"",
",",
"\"money\"",
":",
"nilVal",
"=",
"`\"\"`",
"\n",
"typ",
"=",
"\"string\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullString{}\"",
"\n",
"typ",
"=",
"\"sql.NullString\"",
"\n",
"}",
"\n",
"case",
"\"smallint\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"int16\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"int\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"args",
".",
"Int32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"bigint\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"int64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"smallserial\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"uint16\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"serial\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"args",
".",
"Uint32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"bigserial\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"uint64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"real\"",
":",
"nilVal",
"=",
"\"0.0\"",
"\n",
"typ",
"=",
"\"float32\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullFloat64{}\"",
"\n",
"typ",
"=",
"\"sql.NullFloat64\"",
"\n",
"}",
"\n",
"case",
"\"numeric\"",
",",
"\"decimal\"",
":",
"nilVal",
"=",
"\"0.0\"",
"\n",
"typ",
"=",
"\"float64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullFloat64{}\"",
"\n",
"typ",
"=",
"\"sql.NullFloat64\"",
"\n",
"}",
"\n",
"case",
"\"binary\"",
",",
"\"varbinary\"",
":",
"typ",
"=",
"\"[]byte\"",
"\n",
"case",
"\"datetime\"",
",",
"\"datetime2\"",
",",
"\"timestamp\"",
":",
"nilVal",
"=",
"\"time.Time{}\"",
"\n",
"typ",
"=",
"\"time.Time\"",
"\n",
"case",
"\"time with time zone\"",
",",
"\"time without time zone\"",
",",
"\"timestamp without time zone\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"int64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"interval\"",
":",
"typ",
"=",
"\"*time.Duration\"",
"\n",
"default",
":",
"if",
"strings",
".",
"HasPrefix",
"(",
"dt",
",",
"args",
".",
"Schema",
"+",
"\".\"",
")",
"{",
"typ",
"=",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"dt",
"[",
"len",
"(",
"args",
".",
"Schema",
")",
"+",
"1",
":",
"]",
")",
"\n",
"nilVal",
"=",
"typ",
"+",
"\"(0)\"",
"\n",
"}",
"else",
"{",
"typ",
"=",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"dt",
")",
"\n",
"nilVal",
"=",
"typ",
"+",
"\"{}\"",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"precision",
",",
"nilVal",
",",
"typ",
"\n",
"}"
] |
// MsParseType parse a mssql type into a Go type based on the column
// definition.
|
[
"MsParseType",
"parse",
"a",
"mssql",
"type",
"into",
"a",
"Go",
"type",
"based",
"on",
"the",
"column",
"definition",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L68-L182
|
train
|
xo/xo
|
loaders/mssql.go
|
MsQueryColumns
|
func MsQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// process inspect -- cannot have 'order by' in a CREATE VIEW
ins := []string{}
for _, l := range inspect {
if !strings.HasPrefix(strings.ToUpper(l), "ORDER BY ") {
ins = append(ins, l)
}
}
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS ` + strings.Join(ins, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MsTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
}
|
go
|
func MsQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// process inspect -- cannot have 'order by' in a CREATE VIEW
ins := []string{}
for _, l := range inspect {
if !strings.HasPrefix(strings.ToUpper(l), "ORDER BY ") {
ins = append(ins, l)
}
}
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS ` + strings.Join(ins, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MsTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
}
|
[
"func",
"MsQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"ins",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"inspect",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"strings",
".",
"ToUpper",
"(",
"l",
")",
",",
"\"ORDER BY \"",
")",
"{",
"ins",
"=",
"append",
"(",
"ins",
",",
"l",
")",
"\n",
"}",
"\n",
"}",
"\n",
"xoid",
":=",
"\"_xo_\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE VIEW `",
"+",
"xoid",
"+",
"` AS `",
"+",
"strings",
".",
"Join",
"(",
"ins",
",",
"\"\\n\"",
")",
"\n",
"\\n",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"cols",
",",
"err",
":=",
"models",
".",
"MsTableColumns",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"xoid",
")",
"\n",
"dropq",
":=",
"`DROP VIEW `",
"+",
"xoid",
"\n",
"models",
".",
"XOLog",
"(",
"dropq",
")",
"\n",
"_",
",",
"_",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"dropq",
")",
"\n",
"}"
] |
// MsQueryColumns parses the query and generates a type for it.
|
[
"MsQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L185-L215
|
train
|
xo/xo
|
loaders/mssql.go
|
MsTables
|
func MsTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MsTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Identity included
identities, err := models.MsIdentities(db, schema)
if err != nil {
// Set it to an empty set on error.
identities = []*models.MsIdentity{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the identity
for _, identity := range identities {
if identity.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
go
|
func MsTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MsTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Identity included
identities, err := models.MsIdentities(db, schema)
if err != nil {
// Set it to an empty set on error.
identities = []*models.MsIdentity{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the identity
for _, identity := range identities {
if identity.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
[
"func",
"MsTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"rows",
",",
"err",
":=",
"models",
".",
"MsTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"identities",
",",
"err",
":=",
"models",
".",
"MsIdentities",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"identities",
"=",
"[",
"]",
"*",
"models",
".",
"MsIdentity",
"{",
"}",
"\n",
"}",
"\n",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"for",
"_",
",",
"identity",
":=",
"range",
"identities",
"{",
"if",
"identity",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] |
// MsTables returns the MsSQL tables with the manual PK information added.
// ManualPk is true when the table's primary key is not an identity.
|
[
"MsTables",
"returns",
"the",
"MsSQL",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"s",
"primary",
"key",
"is",
"not",
"an",
"identity",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L219-L253
|
train
|
xo/xo
|
examples/django/mysql/djangoadminlog.xo.go
|
Delete
|
func (dal *DjangoAdminLog) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return nil
}
// if deleted, bail
if dal._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_admin_log WHERE id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.Exec(sqlstr, dal.ID)
if err != nil {
return err
}
// set deleted
dal._deleted = true
return nil
}
|
go
|
func (dal *DjangoAdminLog) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return nil
}
// if deleted, bail
if dal._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_admin_log WHERE id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.Exec(sqlstr, dal.ID)
if err != nil {
return err
}
// set deleted
dal._deleted = true
return nil
}
|
[
"func",
"(",
"dal",
"*",
"DjangoAdminLog",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dal",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"dal",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.django_admin_log WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dal",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dal",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"dal",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the DjangoAdminLog from the database.
|
[
"Delete",
"deletes",
"the",
"DjangoAdminLog",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangoadminlog.xo.go#L108-L135
|
train
|
xo/xo
|
examples/django/mysql/djangosession.xo.go
|
DjangoSessionsByExpireDate
|
func DjangoSessionsByExpireDate(db XODB, expireDate *time.Time) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE expire_date = ?`
// run query
XOLog(sqlstr, expireDate)
q, err := db.Query(sqlstr, expireDate)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
}
|
go
|
func DjangoSessionsByExpireDate(db XODB, expireDate *time.Time) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE expire_date = ?`
// run query
XOLog(sqlstr, expireDate)
q, err := db.Query(sqlstr, expireDate)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
}
|
[
"func",
"DjangoSessionsByExpireDate",
"(",
"db",
"XODB",
",",
"expireDate",
"*",
"time",
".",
"Time",
")",
"(",
"[",
"]",
"*",
"DjangoSession",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`session_key, session_data, expire_date `",
"+",
"`FROM django.django_session `",
"+",
"`WHERE expire_date = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"expireDate",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"expireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"DjangoSession",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ds",
":=",
"DjangoSession",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ds",
".",
"SessionKey",
",",
"&",
"ds",
".",
"SessionData",
",",
"&",
"ds",
".",
"ExpireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ds",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// DjangoSessionsByExpireDate retrieves a row from 'django.django_session' as a DjangoSession.
//
// Generated from index 'django_session_de54fa62'.
|
[
"DjangoSessionsByExpireDate",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_session",
"as",
"a",
"DjangoSession",
".",
"Generated",
"from",
"index",
"django_session_de54fa62",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangosession.xo.go#L127-L161
|
train
|
xo/xo
|
examples/django/mysql/djangosession.xo.go
|
DjangoSessionBySessionKey
|
func DjangoSessionBySessionKey(db XODB, sessionKey string) (*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE session_key = ?`
// run query
XOLog(sqlstr, sessionKey)
ds := DjangoSession{
_exists: true,
}
err = db.QueryRow(sqlstr, sessionKey).Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
return &ds, nil
}
|
go
|
func DjangoSessionBySessionKey(db XODB, sessionKey string) (*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE session_key = ?`
// run query
XOLog(sqlstr, sessionKey)
ds := DjangoSession{
_exists: true,
}
err = db.QueryRow(sqlstr, sessionKey).Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
return &ds, nil
}
|
[
"func",
"DjangoSessionBySessionKey",
"(",
"db",
"XODB",
",",
"sessionKey",
"string",
")",
"(",
"*",
"DjangoSession",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`session_key, session_data, expire_date `",
"+",
"`FROM django.django_session `",
"+",
"`WHERE session_key = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"sessionKey",
")",
"\n",
"ds",
":=",
"DjangoSession",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"sessionKey",
")",
".",
"Scan",
"(",
"&",
"ds",
".",
"SessionKey",
",",
"&",
"ds",
".",
"SessionData",
",",
"&",
"ds",
".",
"ExpireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ds",
",",
"nil",
"\n",
"}"
] |
// DjangoSessionBySessionKey retrieves a row from 'django.django_session' as a DjangoSession.
//
// Generated from index 'django_session_session_key_pkey'.
|
[
"DjangoSessionBySessionKey",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_session",
"as",
"a",
"DjangoSession",
".",
"Generated",
"from",
"index",
"django_session_session_key_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangosession.xo.go#L166-L187
|
train
|
xo/xo
|
examples/django/mysql/authuseruserpermission.xo.go
|
Update
|
func (auup *AuthUserUserPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if auup._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.auth_user_user_permissions SET ` +
`user_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
_, err = db.Exec(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
return err
}
|
go
|
func (auup *AuthUserUserPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if auup._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.auth_user_user_permissions SET ` +
`user_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
_, err = db.Exec(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
return err
}
|
[
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"auup",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"auup",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE django.auth_user_user_permissions SET `",
"+",
"`user_id = ?, permission_id = ?`",
"+",
"` WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"auup",
".",
"UserID",
",",
"auup",
".",
"PermissionID",
",",
"auup",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"auup",
".",
"UserID",
",",
"auup",
".",
"PermissionID",
",",
"auup",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the AuthUserUserPermission in the database.
|
[
"Update",
"updates",
"the",
"AuthUserUserPermission",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authuseruserpermission.xo.go#L67-L89
|
train
|
xo/xo
|
examples/django/oracle/djangomigration.xo.go
|
Update
|
func (dm *DjangoMigration) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dm._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.django_migrations SET ` +
`app = :1, name = :2, applied = :3` +
` WHERE id = :4`
// run query
XOLog(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
_, err = db.Exec(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
return err
}
|
go
|
func (dm *DjangoMigration) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dm._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.django_migrations SET ` +
`app = :1, name = :2, applied = :3` +
` WHERE id = :4`
// run query
XOLog(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
_, err = db.Exec(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
return err
}
|
[
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dm",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"dm",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE django.django_migrations SET `",
"+",
"`app = :1, name = :2, applied = :3`",
"+",
"` WHERE id = :4`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dm",
".",
"App",
",",
"dm",
".",
"Name",
",",
"dm",
".",
"Applied",
",",
"dm",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dm",
".",
"App",
",",
"dm",
".",
"Name",
",",
"dm",
".",
"Applied",
",",
"dm",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the DjangoMigration in the database.
|
[
"Update",
"updates",
"the",
"DjangoMigration",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L70-L92
|
train
|
xo/xo
|
examples/django/oracle/djangomigration.xo.go
|
Delete
|
func (dm *DjangoMigration) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return nil
}
// if deleted, bail
if dm._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_migrations WHERE id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Exec(sqlstr, dm.ID)
if err != nil {
return err
}
// set deleted
dm._deleted = true
return nil
}
|
go
|
func (dm *DjangoMigration) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return nil
}
// if deleted, bail
if dm._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_migrations WHERE id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Exec(sqlstr, dm.ID)
if err != nil {
return err
}
// set deleted
dm._deleted = true
return nil
}
|
[
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dm",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"dm",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.django_migrations WHERE id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dm",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dm",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"dm",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the DjangoMigration from the database.
|
[
"Delete",
"deletes",
"the",
"DjangoMigration",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L104-L131
|
train
|
xo/xo
|
examples/django/oracle/djangomigration.xo.go
|
DjangoMigrationByID
|
func DjangoMigrationByID(db XODB, id float64) (*DjangoMigration, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app, name, applied ` +
`FROM django.django_migrations ` +
`WHERE id = :1`
// run query
XOLog(sqlstr, id)
dm := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dm.ID, &dm.App, &dm.Name, &dm.Applied)
if err != nil {
return nil, err
}
return &dm, nil
}
|
go
|
func DjangoMigrationByID(db XODB, id float64) (*DjangoMigration, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app, name, applied ` +
`FROM django.django_migrations ` +
`WHERE id = :1`
// run query
XOLog(sqlstr, id)
dm := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dm.ID, &dm.App, &dm.Name, &dm.Applied)
if err != nil {
return nil, err
}
return &dm, nil
}
|
[
"func",
"DjangoMigrationByID",
"(",
"db",
"XODB",
",",
"id",
"float64",
")",
"(",
"*",
"DjangoMigration",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, app, name, applied `",
"+",
"`FROM django.django_migrations `",
"+",
"`WHERE id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"dm",
":=",
"DjangoMigration",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"dm",
".",
"ID",
",",
"&",
"dm",
".",
"App",
",",
"&",
"dm",
".",
"Name",
",",
"&",
"dm",
".",
"Applied",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"dm",
",",
"nil",
"\n",
"}"
] |
// DjangoMigrationByID retrieves a row from 'django.django_migrations' as a DjangoMigration.
//
// Generated from index 'sys_c004953'.
|
[
"DjangoMigrationByID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_migrations",
"as",
"a",
"DjangoMigration",
".",
"Generated",
"from",
"index",
"sys_c004953",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L136-L157
|
train
|
xo/xo
|
examples/django/sqlite3/djangocontenttype.xo.go
|
DjangoContentTypeByID
|
func DjangoContentTypeByID(db XODB, id int) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django_content_type ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
}
|
go
|
func DjangoContentTypeByID(db XODB, id int) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django_content_type ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
}
|
[
"func",
"DjangoContentTypeByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"DjangoContentType",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, app_label, model `",
"+",
"`FROM django_content_type `",
"+",
"`WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"dct",
":=",
"DjangoContentType",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"dct",
".",
"ID",
",",
"&",
"dct",
".",
"AppLabel",
",",
"&",
"dct",
".",
"Model",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"dct",
",",
"nil",
"\n",
"}"
] |
// DjangoContentTypeByID retrieves a row from 'django_content_type' as a DjangoContentType.
//
// Generated from index 'django_content_type_id_pkey'.
|
[
"DjangoContentTypeByID",
"retrieves",
"a",
"row",
"from",
"django_content_type",
"as",
"a",
"DjangoContentType",
".",
"Generated",
"from",
"index",
"django_content_type_id_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/djangocontenttype.xo.go#L159-L180
|
train
|
xo/xo
|
examples/django/postgres/djangoadminlog.xo.go
|
Update
|
func (dal *DjangoAdminLog) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dal._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_admin_log SET (` +
`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id` +
`) = ( ` +
`$1, $2, $3, $4, $5, $6, $7` +
`) WHERE id = $8`
// run query
XOLog(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
_, err = db.Exec(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
return err
}
|
go
|
func (dal *DjangoAdminLog) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dal._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_admin_log SET (` +
`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id` +
`) = ( ` +
`$1, $2, $3, $4, $5, $6, $7` +
`) WHERE id = $8`
// run query
XOLog(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
_, err = db.Exec(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
return err
}
|
[
"func",
"(",
"dal",
"*",
"DjangoAdminLog",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"dal",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"dal",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE public.django_admin_log SET (`",
"+",
"`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id`",
"+",
"`) = ( `",
"+",
"`$1, $2, $3, $4, $5, $6, $7`",
"+",
"`) WHERE id = $8`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dal",
".",
"ActionTime",
",",
"dal",
".",
"ObjectID",
",",
"dal",
".",
"ObjectRepr",
",",
"dal",
".",
"ActionFlag",
",",
"dal",
".",
"ChangeMessage",
",",
"dal",
".",
"ContentTypeID",
",",
"dal",
".",
"UserID",
",",
"dal",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dal",
".",
"ActionTime",
",",
"dal",
".",
"ObjectID",
",",
"dal",
".",
"ObjectRepr",
",",
"dal",
".",
"ActionFlag",
",",
"dal",
".",
"ChangeMessage",
",",
"dal",
".",
"ContentTypeID",
",",
"dal",
".",
"UserID",
",",
"dal",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the DjangoAdminLog in the database.
|
[
"Update",
"updates",
"the",
"DjangoAdminLog",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangoadminlog.xo.go#L67-L91
|
train
|
xo/xo
|
examples/django/postgres/djangoadminlog.xo.go
|
DjangoAdminLogsByContentTypeID
|
func DjangoAdminLogsByContentTypeID(db XODB, contentTypeID sql.NullInt64) ([]*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id ` +
`FROM public.django_admin_log ` +
`WHERE content_type_id = $1`
// run query
XOLog(sqlstr, contentTypeID)
q, err := db.Query(sqlstr, contentTypeID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoAdminLog{}
for q.Next() {
dal := DjangoAdminLog{
_exists: true,
}
// scan
err = q.Scan(&dal.ID, &dal.ActionTime, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID)
if err != nil {
return nil, err
}
res = append(res, &dal)
}
return res, nil
}
|
go
|
func DjangoAdminLogsByContentTypeID(db XODB, contentTypeID sql.NullInt64) ([]*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id ` +
`FROM public.django_admin_log ` +
`WHERE content_type_id = $1`
// run query
XOLog(sqlstr, contentTypeID)
q, err := db.Query(sqlstr, contentTypeID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoAdminLog{}
for q.Next() {
dal := DjangoAdminLog{
_exists: true,
}
// scan
err = q.Scan(&dal.ID, &dal.ActionTime, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID)
if err != nil {
return nil, err
}
res = append(res, &dal)
}
return res, nil
}
|
[
"func",
"DjangoAdminLogsByContentTypeID",
"(",
"db",
"XODB",
",",
"contentTypeID",
"sql",
".",
"NullInt64",
")",
"(",
"[",
"]",
"*",
"DjangoAdminLog",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id `",
"+",
"`FROM public.django_admin_log `",
"+",
"`WHERE content_type_id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"contentTypeID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"contentTypeID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"DjangoAdminLog",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"dal",
":=",
"DjangoAdminLog",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"dal",
".",
"ID",
",",
"&",
"dal",
".",
"ActionTime",
",",
"&",
"dal",
".",
"ObjectID",
",",
"&",
"dal",
".",
"ObjectRepr",
",",
"&",
"dal",
".",
"ActionFlag",
",",
"&",
"dal",
".",
"ChangeMessage",
",",
"&",
"dal",
".",
"ContentTypeID",
",",
"&",
"dal",
".",
"UserID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"dal",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// DjangoAdminLogsByContentTypeID retrieves a row from 'public.django_admin_log' as a DjangoAdminLog.
//
// Generated from index 'django_admin_log_417f1b1c'.
|
[
"DjangoAdminLogsByContentTypeID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"django_admin_log",
"as",
"a",
"DjangoAdminLog",
".",
"Generated",
"from",
"index",
"django_admin_log_417f1b1c",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangoadminlog.xo.go#L184-L218
|
train
|
xo/xo
|
models/proc.xo.go
|
PgProcs
|
func PgProcs(db XODB, schema string) ([]*Proc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`p.proname, ` + // ::varchar AS proc_name
`pg_get_function_result(p.oid) ` + // ::varchar AS return_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Proc{}
for q.Next() {
p := Proc{}
// scan
err = q.Scan(&p.ProcName, &p.ReturnType)
if err != nil {
return nil, err
}
res = append(res, &p)
}
return res, nil
}
|
go
|
func PgProcs(db XODB, schema string) ([]*Proc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`p.proname, ` + // ::varchar AS proc_name
`pg_get_function_result(p.oid) ` + // ::varchar AS return_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Proc{}
for q.Next() {
p := Proc{}
// scan
err = q.Scan(&p.ProcName, &p.ReturnType)
if err != nil {
return nil, err
}
res = append(res, &p)
}
return res, nil
}
|
[
"func",
"PgProcs",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"Proc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`p.proname, `",
"+",
"`pg_get_function_result(p.oid) `",
"+",
"`FROM pg_proc p `",
"+",
"`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid `",
"+",
"`WHERE n.nspname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"Proc",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"p",
":=",
"Proc",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"p",
".",
"ProcName",
",",
"&",
"p",
".",
"ReturnType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"p",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgProcs runs a custom query, returning results as Proc.
|
[
"PgProcs",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Proc",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/proc.xo.go#L13-L47
|
train
|
xo/xo
|
examples/django/oracle/authgroup.xo.go
|
Delete
|
func (ag *AuthGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return nil
}
// if deleted, bail
if ag._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_group WHERE id = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag.ID)
if err != nil {
return err
}
// set deleted
ag._deleted = true
return nil
}
|
go
|
func (ag *AuthGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return nil
}
// if deleted, bail
if ag._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_group WHERE id = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag.ID)
if err != nil {
return err
}
// set deleted
ag._deleted = true
return nil
}
|
[
"func",
"(",
"ag",
"*",
"AuthGroup",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ag",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"ag",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_group WHERE id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ag",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ag",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ag",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthGroup from the database.
|
[
"Delete",
"deletes",
"the",
"AuthGroup",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authgroup.xo.go#L101-L128
|
train
|
xo/xo
|
examples/django/sqlite3/authgroup.xo.go
|
Update
|
func (ag *AuthGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ag._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group SET ` +
`name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ag.Name, ag.ID)
_, err = db.Exec(sqlstr, ag.Name, ag.ID)
return err
}
|
go
|
func (ag *AuthGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ag._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group SET ` +
`name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ag.Name, ag.ID)
_, err = db.Exec(sqlstr, ag.Name, ag.ID)
return err
}
|
[
"func",
"(",
"ag",
"*",
"AuthGroup",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ag",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"ag",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE auth_group SET `",
"+",
"`name = ?`",
"+",
"` WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ag",
".",
"Name",
",",
"ag",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ag",
".",
"Name",
",",
"ag",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the AuthGroup in the database.
|
[
"Update",
"updates",
"the",
"AuthGroup",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authgroup.xo.go#L66-L88
|
train
|
xo/xo
|
examples/django/oracle/authuser.xo.go
|
Delete
|
func (au *AuthUser) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !au._exists {
return nil
}
// if deleted, bail
if au._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user WHERE id = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.ID)
if err != nil {
return err
}
// set deleted
au._deleted = true
return nil
}
|
go
|
func (au *AuthUser) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !au._exists {
return nil
}
// if deleted, bail
if au._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user WHERE id = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.ID)
if err != nil {
return err
}
// set deleted
au._deleted = true
return nil
}
|
[
"func",
"(",
"au",
"*",
"AuthUser",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"au",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"au",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_user WHERE id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"au",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"au",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"au",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthUser from the database.
|
[
"Delete",
"deletes",
"the",
"AuthUser",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuser.xo.go#L111-L138
|
train
|
xo/xo
|
examples/django/oracle/authuser.xo.go
|
AuthUserByUsername
|
func AuthUserByUsername(db XODB, username sql.NullString) (*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM django.auth_user ` +
`WHERE username = :1`
// run query
XOLog(sqlstr, username)
au := AuthUser{
_exists: true,
}
err = db.QueryRow(sqlstr, username).Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
return &au, nil
}
|
go
|
func AuthUserByUsername(db XODB, username sql.NullString) (*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM django.auth_user ` +
`WHERE username = :1`
// run query
XOLog(sqlstr, username)
au := AuthUser{
_exists: true,
}
err = db.QueryRow(sqlstr, username).Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
return &au, nil
}
|
[
"func",
"AuthUserByUsername",
"(",
"db",
"XODB",
",",
"username",
"sql",
".",
"NullString",
")",
"(",
"*",
"AuthUser",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined `",
"+",
"`FROM django.auth_user `",
"+",
"`WHERE username = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"username",
")",
"\n",
"au",
":=",
"AuthUser",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"username",
")",
".",
"Scan",
"(",
"&",
"au",
".",
"ID",
",",
"&",
"au",
".",
"Password",
",",
"&",
"au",
".",
"LastLogin",
",",
"&",
"au",
".",
"IsSuperuser",
",",
"&",
"au",
".",
"Username",
",",
"&",
"au",
".",
"FirstName",
",",
"&",
"au",
".",
"LastName",
",",
"&",
"au",
".",
"Email",
",",
"&",
"au",
".",
"IsStaff",
",",
"&",
"au",
".",
"IsActive",
",",
"&",
"au",
".",
"DateJoined",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"au",
",",
"nil",
"\n",
"}"
] |
// AuthUserByUsername retrieves a row from 'django.auth_user' as a AuthUser.
//
// Generated from index 'sys_c004977'.
|
[
"AuthUserByUsername",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user",
"as",
"a",
"AuthUser",
".",
"Generated",
"from",
"index",
"sys_c004977",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuser.xo.go#L169-L190
|
train
|
xo/xo
|
internal/fkmode.go
|
UnmarshalText
|
func (f *FkMode) UnmarshalText(text []byte) error {
switch strings.ToLower(string(text)) {
case "smart", "default":
*f = FkModeSmart
case "parent":
*f = FkModeParent
case "field":
*f = FkModeField
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
}
|
go
|
func (f *FkMode) UnmarshalText(text []byte) error {
switch strings.ToLower(string(text)) {
case "smart", "default":
*f = FkModeSmart
case "parent":
*f = FkModeParent
case "field":
*f = FkModeField
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"FkMode",
")",
"UnmarshalText",
"(",
"text",
"[",
"]",
"byte",
")",
"error",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"text",
")",
")",
"{",
"case",
"\"smart\"",
",",
"\"default\"",
":",
"*",
"f",
"=",
"FkModeSmart",
"\n",
"case",
"\"parent\"",
":",
"*",
"f",
"=",
"FkModeParent",
"\n",
"case",
"\"field\"",
":",
"*",
"f",
"=",
"FkModeField",
"\n",
"case",
"\"key\"",
":",
"*",
"f",
"=",
"FkModeKey",
"\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"invalid FkMode\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UnmarshalText unmarshals FkMode from text.
|
[
"UnmarshalText",
"unmarshals",
"FkMode",
"from",
"text",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L44-L60
|
train
|
xo/xo
|
internal/fkmode.go
|
fkName
|
func fkName(mode FkMode, fkMap map[string]*ForeignKey, fk *ForeignKey) string {
switch mode {
case FkModeParent:
return fk.RefType.Name
case FkModeField:
return fk.RefType.Name + "By" + fk.Field.Name
case FkModeKey:
return fk.RefType.Name + "By" + snaker.SnakeToCamelIdentifier(fk.ForeignKey.ForeignKeyName)
}
// mode is FkModeSmart
// inspect all foreign keys and use FkModeField if conflict found
for _, f := range fkMap {
if fk != f && fk.Type.Name == f.Type.Name && fk.RefType.Name == f.RefType.Name {
return fkName(FkModeField, fkMap, fk)
}
}
// no conflict, so use FkModeParent
return fkName(FkModeParent, fkMap, fk)
}
|
go
|
func fkName(mode FkMode, fkMap map[string]*ForeignKey, fk *ForeignKey) string {
switch mode {
case FkModeParent:
return fk.RefType.Name
case FkModeField:
return fk.RefType.Name + "By" + fk.Field.Name
case FkModeKey:
return fk.RefType.Name + "By" + snaker.SnakeToCamelIdentifier(fk.ForeignKey.ForeignKeyName)
}
// mode is FkModeSmart
// inspect all foreign keys and use FkModeField if conflict found
for _, f := range fkMap {
if fk != f && fk.Type.Name == f.Type.Name && fk.RefType.Name == f.RefType.Name {
return fkName(FkModeField, fkMap, fk)
}
}
// no conflict, so use FkModeParent
return fkName(FkModeParent, fkMap, fk)
}
|
[
"func",
"fkName",
"(",
"mode",
"FkMode",
",",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"fk",
"*",
"ForeignKey",
")",
"string",
"{",
"switch",
"mode",
"{",
"case",
"FkModeParent",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"\n",
"case",
"FkModeField",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"+",
"\"By\"",
"+",
"fk",
".",
"Field",
".",
"Name",
"\n",
"case",
"FkModeKey",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"+",
"\"By\"",
"+",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"fk",
".",
"ForeignKey",
".",
"ForeignKeyName",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"fkMap",
"{",
"if",
"fk",
"!=",
"f",
"&&",
"fk",
".",
"Type",
".",
"Name",
"==",
"f",
".",
"Type",
".",
"Name",
"&&",
"fk",
".",
"RefType",
".",
"Name",
"==",
"f",
".",
"RefType",
".",
"Name",
"{",
"return",
"fkName",
"(",
"FkModeField",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fkName",
"(",
"FkModeParent",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}"
] |
// fkName returns the name for the foreign key.
|
[
"fkName",
"returns",
"the",
"name",
"for",
"the",
"foreign",
"key",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L79-L99
|
train
|
xo/xo
|
internal/fkmode.go
|
ForeignKeyName
|
func (a *ArgType) ForeignKeyName(fkMap map[string]*ForeignKey, fk *ForeignKey) string {
return fkName(*a.ForeignKeyMode, fkMap, fk)
}
|
go
|
func (a *ArgType) ForeignKeyName(fkMap map[string]*ForeignKey, fk *ForeignKey) string {
return fkName(*a.ForeignKeyMode, fkMap, fk)
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"ForeignKeyName",
"(",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"fk",
"*",
"ForeignKey",
")",
"string",
"{",
"return",
"fkName",
"(",
"*",
"a",
".",
"ForeignKeyMode",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}"
] |
// ForeignKeyName returns the foreign key name for the passed type.
|
[
"ForeignKeyName",
"returns",
"the",
"foreign",
"key",
"name",
"for",
"the",
"passed",
"type",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L102-L104
|
train
|
xo/xo
|
examples/django/postgres/authuseruserpermission.xo.go
|
Delete
|
func (auup *AuthUserUserPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return nil
}
// if deleted, bail
if auup._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.auth_user_user_permissions WHERE id = $1`
// run query
XOLog(sqlstr, auup.ID)
_, err = db.Exec(sqlstr, auup.ID)
if err != nil {
return err
}
// set deleted
auup._deleted = true
return nil
}
|
go
|
func (auup *AuthUserUserPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return nil
}
// if deleted, bail
if auup._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.auth_user_user_permissions WHERE id = $1`
// run query
XOLog(sqlstr, auup.ID)
_, err = db.Exec(sqlstr, auup.ID)
if err != nil {
return err
}
// set deleted
auup._deleted = true
return nil
}
|
[
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"auup",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"auup",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM public.auth_user_user_permissions WHERE id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"auup",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"auup",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"auup",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthUserUserPermission from the database.
|
[
"Delete",
"deletes",
"the",
"AuthUserUserPermission",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authuseruserpermission.xo.go#L131-L158
|
train
|
xo/xo
|
examples/django/postgres/authuseruserpermission.xo.go
|
AuthUserUserPermissionByID
|
func AuthUserUserPermissionByID(db XODB, id int) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM public.auth_user_user_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
}
|
go
|
func AuthUserUserPermissionByID(db XODB, id int) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM public.auth_user_user_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
}
|
[
"func",
"AuthUserUserPermissionByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM public.auth_user_user_permissions `",
"+",
"`WHERE id = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"auup",
",",
"nil",
"\n",
"}"
] |
// AuthUserUserPermissionByID retrieves a row from 'public.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_user_user_permissions_pkey'.
|
[
"AuthUserUserPermissionByID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_user_user_permissions_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authuseruserpermission.xo.go#L255-L276
|
train
|
xo/xo
|
examples/django/oracle/authusergroup.xo.go
|
Delete
|
func (aug *AuthUserGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return nil
}
// if deleted, bail
if aug._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user_groups WHERE id = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.Exec(sqlstr, aug.ID)
if err != nil {
return err
}
// set deleted
aug._deleted = true
return nil
}
|
go
|
func (aug *AuthUserGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return nil
}
// if deleted, bail
if aug._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user_groups WHERE id = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.Exec(sqlstr, aug.ID)
if err != nil {
return err
}
// set deleted
aug._deleted = true
return nil
}
|
[
"func",
"(",
"aug",
"*",
"AuthUserGroup",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"aug",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"aug",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_user_groups WHERE id = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"aug",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"aug",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"aug",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthUserGroup from the database.
|
[
"Delete",
"deletes",
"the",
"AuthUserGroup",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authusergroup.xo.go#L99-L126
|
train
|
xo/xo
|
models/myenumvalue.xo.go
|
MyEnumValues
|
func MyEnumValues(db XODB, schema string, enum string) (*MyEnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values ` +
`FROM information_schema.columns ` +
`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`
// run query
XOLog(sqlstr, schema, enum)
var mev MyEnumValue
err = db.QueryRow(sqlstr, schema, enum).Scan(&mev.EnumValues)
if err != nil {
return nil, err
}
return &mev, nil
}
|
go
|
func MyEnumValues(db XODB, schema string, enum string) (*MyEnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values ` +
`FROM information_schema.columns ` +
`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`
// run query
XOLog(sqlstr, schema, enum)
var mev MyEnumValue
err = db.QueryRow(sqlstr, schema, enum).Scan(&mev.EnumValues)
if err != nil {
return nil, err
}
return &mev, nil
}
|
[
"func",
"MyEnumValues",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"enum",
"string",
")",
"(",
"*",
"MyEnumValue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values `",
"+",
"`FROM information_schema.columns `",
"+",
"`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
"\n",
"var",
"mev",
"MyEnumValue",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
".",
"Scan",
"(",
"&",
"mev",
".",
"EnumValues",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"mev",
",",
"nil",
"\n",
"}"
] |
// MyEnumValues runs a custom query, returning results as MyEnumValue.
|
[
"MyEnumValues",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"MyEnumValue",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/myenumvalue.xo.go#L12-L30
|
train
|
xo/xo
|
examples/django/postgres/authusergroup.xo.go
|
Update
|
func (aug *AuthUserGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if aug._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth_user_groups SET (` +
`user_id, group_id` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, aug.UserID, aug.GroupID, aug.ID)
_, err = db.Exec(sqlstr, aug.UserID, aug.GroupID, aug.ID)
return err
}
|
go
|
func (aug *AuthUserGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if aug._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth_user_groups SET (` +
`user_id, group_id` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, aug.UserID, aug.GroupID, aug.ID)
_, err = db.Exec(sqlstr, aug.UserID, aug.GroupID, aug.ID)
return err
}
|
[
"func",
"(",
"aug",
"*",
"AuthUserGroup",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"aug",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"aug",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE public.auth_user_groups SET (`",
"+",
"`user_id, group_id`",
"+",
"`) = ( `",
"+",
"`$1, $2`",
"+",
"`) WHERE id = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"aug",
".",
"UserID",
",",
"aug",
".",
"GroupID",
",",
"aug",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"aug",
".",
"UserID",
",",
"aug",
".",
"GroupID",
",",
"aug",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the AuthUserGroup in the database.
|
[
"Update",
"updates",
"the",
"AuthUserGroup",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authusergroup.xo.go#L60-L84
|
train
|
xo/xo
|
models/column.xo.go
|
MyTableColumns
|
func MyTableColumns(db XODB, schema string, table string) ([]*Column, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`ordinal_position AS field_ordinal, ` +
`column_name, ` +
`IF(data_type = 'enum', column_name, column_type) AS data_type, ` +
`IF(is_nullable = 'YES', false, true) AS not_null, ` +
`column_default AS default_value, ` +
`IF(column_key = 'PRI', true, false) AS is_primary_key ` +
`FROM information_schema.columns ` +
`WHERE table_schema = ? AND table_name = ? ` +
`ORDER BY ordinal_position`
// run query
XOLog(sqlstr, schema, table)
q, err := db.Query(sqlstr, schema, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Column{}
for q.Next() {
c := Column{}
// scan
err = q.Scan(&c.FieldOrdinal, &c.ColumnName, &c.DataType, &c.NotNull, &c.DefaultValue, &c.IsPrimaryKey)
if err != nil {
return nil, err
}
res = append(res, &c)
}
return res, nil
}
|
go
|
func MyTableColumns(db XODB, schema string, table string) ([]*Column, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`ordinal_position AS field_ordinal, ` +
`column_name, ` +
`IF(data_type = 'enum', column_name, column_type) AS data_type, ` +
`IF(is_nullable = 'YES', false, true) AS not_null, ` +
`column_default AS default_value, ` +
`IF(column_key = 'PRI', true, false) AS is_primary_key ` +
`FROM information_schema.columns ` +
`WHERE table_schema = ? AND table_name = ? ` +
`ORDER BY ordinal_position`
// run query
XOLog(sqlstr, schema, table)
q, err := db.Query(sqlstr, schema, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Column{}
for q.Next() {
c := Column{}
// scan
err = q.Scan(&c.FieldOrdinal, &c.ColumnName, &c.DataType, &c.NotNull, &c.DefaultValue, &c.IsPrimaryKey)
if err != nil {
return nil, err
}
res = append(res, &c)
}
return res, nil
}
|
[
"func",
"MyTableColumns",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`ordinal_position AS field_ordinal, `",
"+",
"`column_name, `",
"+",
"`IF(data_type = 'enum', column_name, column_type) AS data_type, `",
"+",
"`IF(is_nullable = 'YES', false, true) AS not_null, `",
"+",
"`column_default AS default_value, `",
"+",
"`IF(column_key = 'PRI', true, false) AS is_primary_key `",
"+",
"`FROM information_schema.columns `",
"+",
"`WHERE table_schema = ? AND table_name = ? `",
"+",
"`ORDER BY ordinal_position`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"table",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"Column",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"c",
":=",
"Column",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"c",
".",
"FieldOrdinal",
",",
"&",
"c",
".",
"ColumnName",
",",
"&",
"c",
".",
"DataType",
",",
"&",
"c",
".",
"NotNull",
",",
"&",
"c",
".",
"DefaultValue",
",",
"&",
"c",
".",
"IsPrimaryKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"c",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// MyTableColumns runs a custom query, returning results as Column.
|
[
"MyTableColumns",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Column",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/column.xo.go#L66-L104
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
AuthenticateUser
|
func (s *AuthServer) AuthenticateUser(req AuthenticateUserRequest) error {
err := s.authenticateUser(req)
if err != nil {
s.EmitAuditEvent(events.UserLocalLoginFailure, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
s.EmitAuditEvent(events.UserLocalLogin, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: true,
})
}
return err
}
|
go
|
func (s *AuthServer) AuthenticateUser(req AuthenticateUserRequest) error {
err := s.authenticateUser(req)
if err != nil {
s.EmitAuditEvent(events.UserLocalLoginFailure, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
s.EmitAuditEvent(events.UserLocalLogin, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: true,
})
}
return err
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateUser",
"(",
"req",
"AuthenticateUserRequest",
")",
"error",
"{",
"err",
":=",
"s",
".",
"authenticateUser",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserLocalLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"req",
".",
"Username",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodLocal",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"events",
".",
"AuthAttemptErr",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserLocalLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"req",
".",
"Username",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodLocal",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// AuthenticateUser authenticates user based on the request type
|
[
"AuthenticateUser",
"authenticates",
"user",
"based",
"on",
"the",
"request",
"type"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L85-L102
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
AuthenticateWebUser
|
func (s *AuthServer) AuthenticateWebUser(req AuthenticateUserRequest) (services.WebSession, error) {
if req.Session != nil {
session, err := s.GetWebSession(req.Username, req.Session.ID)
if err != nil {
return nil, trace.AccessDenied("session is invalid or has expired")
}
return session, nil
}
if err := s.AuthenticateUser(req); err != nil {
return nil, trace.Wrap(err)
}
sess, err := s.NewWebSession(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(req.Username, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
go
|
func (s *AuthServer) AuthenticateWebUser(req AuthenticateUserRequest) (services.WebSession, error) {
if req.Session != nil {
session, err := s.GetWebSession(req.Username, req.Session.ID)
if err != nil {
return nil, trace.AccessDenied("session is invalid or has expired")
}
return session, nil
}
if err := s.AuthenticateUser(req); err != nil {
return nil, trace.Wrap(err)
}
sess, err := s.NewWebSession(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(req.Username, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateWebUser",
"(",
"req",
"AuthenticateUserRequest",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"if",
"req",
".",
"Session",
"!=",
"nil",
"{",
"session",
",",
"err",
":=",
"s",
".",
"GetWebSession",
"(",
"req",
".",
"Username",
",",
"req",
".",
"Session",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"session is invalid or has expired\"",
")",
"\n",
"}",
"\n",
"return",
"session",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"AuthenticateUser",
"(",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"req",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"req",
".",
"Username",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"GenerateWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] |
// AuthenticateWebUser authenticates web user, creates and returns web session
// in case if authentication is successful. In case if existing session id
// is used to authenticate, returns session associated with the existing session id
// instead of creating the new one
|
[
"AuthenticateWebUser",
"authenticates",
"web",
"user",
"creates",
"and",
"returns",
"web",
"session",
"in",
"case",
"if",
"authentication",
"is",
"successful",
".",
"In",
"case",
"if",
"existing",
"session",
"id",
"is",
"used",
"to",
"authenticate",
"returns",
"session",
"associated",
"with",
"the",
"existing",
"session",
"id",
"instead",
"of",
"creating",
"the",
"new",
"one"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L165-L188
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
CheckAndSetDefaults
|
func (a *AuthenticateSSHRequest) CheckAndSetDefaults() error {
if err := a.AuthenticateUserRequest.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
if len(a.PublicKey) == 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.CompatibilityMode)
if err != nil {
return trace.Wrap(err)
}
a.CompatibilityMode = certificateFormat
return nil
}
|
go
|
func (a *AuthenticateSSHRequest) CheckAndSetDefaults() error {
if err := a.AuthenticateUserRequest.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
if len(a.PublicKey) == 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.CompatibilityMode)
if err != nil {
return trace.Wrap(err)
}
a.CompatibilityMode = certificateFormat
return nil
}
|
[
"func",
"(",
"a",
"*",
"AuthenticateSSHRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"AuthenticateUserRequest",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"PublicKey",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"missing parameter 'public_key'\"",
")",
"\n",
"}",
"\n",
"certificateFormat",
",",
"err",
":=",
"utils",
".",
"CheckCertificateFormatFlag",
"(",
"a",
".",
"CompatibilityMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"CompatibilityMode",
"=",
"certificateFormat",
"\n",
"return",
"nil",
"\n",
"}"
] |
// CheckAndSetDefaults checks and sets default certificate values
|
[
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"certificate",
"values"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L203-L216
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
SSHCertPublicKeys
|
func (c *TrustedCerts) SSHCertPublicKeys() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(c.HostCertificates))
for _, keyBytes := range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)
}
return out, nil
}
|
go
|
func (c *TrustedCerts) SSHCertPublicKeys() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(c.HostCertificates))
for _, keyBytes := range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)
}
return out, nil
}
|
[
"func",
"(",
"c",
"*",
"TrustedCerts",
")",
"SSHCertPublicKeys",
"(",
")",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"0",
",",
"len",
"(",
"c",
".",
"HostCertificates",
")",
")",
"\n",
"for",
"_",
",",
"keyBytes",
":=",
"range",
"c",
".",
"HostCertificates",
"{",
"publicKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"publicKey",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] |
// SSHCertPublicKeys returns a list of trusted host SSH certificate authority public keys
|
[
"SSHCertPublicKeys",
"returns",
"a",
"list",
"of",
"trusted",
"host",
"SSH",
"certificate",
"authority",
"public",
"keys"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L247-L257
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
AuthoritiesToTrustedCerts
|
func AuthoritiesToTrustedCerts(authorities []services.CertAuthority) []TrustedCerts {
out := make([]TrustedCerts, len(authorities))
for i, ca := range authorities {
out[i] = TrustedCerts{
ClusterName: ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),
}
}
return out
}
|
go
|
func AuthoritiesToTrustedCerts(authorities []services.CertAuthority) []TrustedCerts {
out := make([]TrustedCerts, len(authorities))
for i, ca := range authorities {
out[i] = TrustedCerts{
ClusterName: ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),
}
}
return out
}
|
[
"func",
"AuthoritiesToTrustedCerts",
"(",
"authorities",
"[",
"]",
"services",
".",
"CertAuthority",
")",
"[",
"]",
"TrustedCerts",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"TrustedCerts",
",",
"len",
"(",
"authorities",
")",
")",
"\n",
"for",
"i",
",",
"ca",
":=",
"range",
"authorities",
"{",
"out",
"[",
"i",
"]",
"=",
"TrustedCerts",
"{",
"ClusterName",
":",
"ca",
".",
"GetClusterName",
"(",
")",
",",
"HostCertificates",
":",
"ca",
".",
"GetCheckingKeys",
"(",
")",
",",
"TLSCertificates",
":",
"services",
".",
"TLSCerts",
"(",
"ca",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] |
// AuthoritiesToTrustedCerts serializes authorities to TrustedCerts data structure
|
[
"AuthoritiesToTrustedCerts",
"serializes",
"authorities",
"to",
"TrustedCerts",
"data",
"structure"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L260-L270
|
train
|
gravitational/teleport
|
lib/auth/methods.go
|
AuthenticateSSHUser
|
func (s *AuthServer) AuthenticateSSHUser(req AuthenticateSSHRequest) (*SSHLoginResponse, error) {
clusterName, err := s.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.AuthenticateUser(req.AuthenticateUserRequest); err != nil {
return nil, trace.Wrap(err)
}
user, err := s.GetUser(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), s, user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Return the host CA for this cluster only.
authority, err := s.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
hostCertAuthorities := []services.CertAuthority{
authority,
}
certs, err := s.generateUserCert(certRequest{
user: user,
roles: roles,
ttl: req.TTL,
publicKey: req.PublicKey,
compatibility: req.CompatibilityMode,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &SSHLoginResponse{
Username: req.Username,
Cert: certs.ssh,
TLSCert: certs.tls,
HostSigners: AuthoritiesToTrustedCerts(hostCertAuthorities),
}, nil
}
|
go
|
func (s *AuthServer) AuthenticateSSHUser(req AuthenticateSSHRequest) (*SSHLoginResponse, error) {
clusterName, err := s.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.AuthenticateUser(req.AuthenticateUserRequest); err != nil {
return nil, trace.Wrap(err)
}
user, err := s.GetUser(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), s, user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Return the host CA for this cluster only.
authority, err := s.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
hostCertAuthorities := []services.CertAuthority{
authority,
}
certs, err := s.generateUserCert(certRequest{
user: user,
roles: roles,
ttl: req.TTL,
publicKey: req.PublicKey,
compatibility: req.CompatibilityMode,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &SSHLoginResponse{
Username: req.Username,
Cert: certs.ssh,
TLSCert: certs.tls,
HostSigners: AuthoritiesToTrustedCerts(hostCertAuthorities),
}, nil
}
|
[
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateSSHUser",
"(",
"req",
"AuthenticateSSHRequest",
")",
"(",
"*",
"SSHLoginResponse",
",",
"error",
")",
"{",
"clusterName",
",",
"err",
":=",
"s",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"AuthenticateUser",
"(",
"req",
".",
"AuthenticateUserRequest",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"s",
".",
"GetUser",
"(",
"req",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roles",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"s",
",",
"user",
".",
"GetTraits",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"authority",
",",
"err",
":=",
"s",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"clusterName",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"hostCertAuthorities",
":=",
"[",
"]",
"services",
".",
"CertAuthority",
"{",
"authority",
",",
"}",
"\n",
"certs",
",",
"err",
":=",
"s",
".",
"generateUserCert",
"(",
"certRequest",
"{",
"user",
":",
"user",
",",
"roles",
":",
"roles",
",",
"ttl",
":",
"req",
".",
"TTL",
",",
"publicKey",
":",
"req",
".",
"PublicKey",
",",
"compatibility",
":",
"req",
".",
"CompatibilityMode",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"SSHLoginResponse",
"{",
"Username",
":",
"req",
".",
"Username",
",",
"Cert",
":",
"certs",
".",
"ssh",
",",
"TLSCert",
":",
"certs",
".",
"tls",
",",
"HostSigners",
":",
"AuthoritiesToTrustedCerts",
"(",
"hostCertAuthorities",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// AuthenticateSSHUser authenticates web user, creates and returns web session
// in case if authentication is successful
|
[
"AuthenticateSSHUser",
"authenticates",
"web",
"user",
"creates",
"and",
"returns",
"web",
"session",
"in",
"case",
"if",
"authentication",
"is",
"successful"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L274-L320
|
train
|
gravitational/teleport
|
lib/pam/pam.go
|
unregisterHandler
|
func unregisterHandler(handlerIndex int) {
handlerMu.Lock()
defer handlerMu.Unlock()
delete(handlers, handlerIndex)
}
|
go
|
func unregisterHandler(handlerIndex int) {
handlerMu.Lock()
defer handlerMu.Unlock()
delete(handlers, handlerIndex)
}
|
[
"func",
"unregisterHandler",
"(",
"handlerIndex",
"int",
")",
"{",
"handlerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"handlerMu",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"handlers",
",",
"handlerIndex",
")",
"\n",
"}"
] |
// unregisterHandler will remove the PAM handle from the package level map
// once no more C callbacks can come back.
|
[
"unregisterHandler",
"will",
"remove",
"the",
"PAM",
"handle",
"from",
"the",
"package",
"level",
"map",
"once",
"no",
"more",
"C",
"callbacks",
"can",
"come",
"back",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L140-L145
|
train
|
gravitational/teleport
|
lib/pam/pam.go
|
lookupHandler
|
func lookupHandler(handlerIndex int) (handler, error) {
handlerMu.Lock()
defer handlerMu.Unlock()
handle, ok := handlers[handlerIndex]
if !ok {
return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
}
|
go
|
func lookupHandler(handlerIndex int) (handler, error) {
handlerMu.Lock()
defer handlerMu.Unlock()
handle, ok := handlers[handlerIndex]
if !ok {
return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
}
|
[
"func",
"lookupHandler",
"(",
"handlerIndex",
"int",
")",
"(",
"handler",
",",
"error",
")",
"{",
"handlerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"handlerMu",
".",
"Unlock",
"(",
")",
"\n",
"handle",
",",
"ok",
":=",
"handlers",
"[",
"handlerIndex",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"handler with index %v not registered\"",
",",
"handlerIndex",
")",
"\n",
"}",
"\n",
"return",
"handle",
",",
"nil",
"\n",
"}"
] |
// lookupHandler returns a particular handler from the package level map.
|
[
"lookupHandler",
"returns",
"a",
"particular",
"handler",
"from",
"the",
"package",
"level",
"map",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L148-L158
|
train
|
gravitational/teleport
|
lib/pam/pam.go
|
Open
|
func Open(config *Config) (*PAM, error) {
if config == nil {
return nil, trace.BadParameter("PAM configuration is required.")
}
err := config.CheckDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
p := &PAM{
pamh: nil,
stdin: config.Stdin,
stdout: config.Stdout,
stderr: config.Stderr,
}
// Both config.ServiceName and config.Username convert between Go strings to
// C strings. Since the C strings are allocated on the heap in Go code, this
// memory must be released (and will be on the call to the Close method).
p.service_name = C.CString(config.ServiceName)
p.user = C.CString(config.Username)
// C code does not know that this PAM context exists. To ensure the
// conversation function can get messages to the right context, a handle
// registry at the package level is created (handlers). Each instance of the
// PAM context has it's own handle which is used to communicate between C
// and a instance of a PAM context.
p.handlerIndex = registerHandler(p)
// Create and initialize a PAM context. The pam_start function will
// allocate pamh if needed and the pam_end function will release any
// allocated memory.
p.retval = C._pam_start(pamHandle, p.service_name, p.user, p.conv, &p.pamh)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
// Check that the *nix account is valid. Checking an account varies based off
// the PAM modules used in the account stack. Typically this consists of
// checking if the account is expired or has access restrictions.
//
// Note: This function does not perform any authentication!
retval := C._pam_acct_mgmt(pamHandle, p.pamh, 0)
if retval != C.PAM_SUCCESS {
return nil, p.codeToError(retval)
}
// Open a user session. Opening a session varies based off the PAM modules
// used in the "session" stack. Opening a session typically consists of
// printing the MOTD, mounting a home directory, updating auth.log.
p.retval = C._pam_open_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
return p, nil
}
|
go
|
func Open(config *Config) (*PAM, error) {
if config == nil {
return nil, trace.BadParameter("PAM configuration is required.")
}
err := config.CheckDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
p := &PAM{
pamh: nil,
stdin: config.Stdin,
stdout: config.Stdout,
stderr: config.Stderr,
}
// Both config.ServiceName and config.Username convert between Go strings to
// C strings. Since the C strings are allocated on the heap in Go code, this
// memory must be released (and will be on the call to the Close method).
p.service_name = C.CString(config.ServiceName)
p.user = C.CString(config.Username)
// C code does not know that this PAM context exists. To ensure the
// conversation function can get messages to the right context, a handle
// registry at the package level is created (handlers). Each instance of the
// PAM context has it's own handle which is used to communicate between C
// and a instance of a PAM context.
p.handlerIndex = registerHandler(p)
// Create and initialize a PAM context. The pam_start function will
// allocate pamh if needed and the pam_end function will release any
// allocated memory.
p.retval = C._pam_start(pamHandle, p.service_name, p.user, p.conv, &p.pamh)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
// Check that the *nix account is valid. Checking an account varies based off
// the PAM modules used in the account stack. Typically this consists of
// checking if the account is expired or has access restrictions.
//
// Note: This function does not perform any authentication!
retval := C._pam_acct_mgmt(pamHandle, p.pamh, 0)
if retval != C.PAM_SUCCESS {
return nil, p.codeToError(retval)
}
// Open a user session. Opening a session varies based off the PAM modules
// used in the "session" stack. Opening a session typically consists of
// printing the MOTD, mounting a home directory, updating auth.log.
p.retval = C._pam_open_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
return p, nil
}
|
[
"func",
"Open",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"PAM",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"PAM configuration is required.\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"config",
".",
"CheckDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"p",
":=",
"&",
"PAM",
"{",
"pamh",
":",
"nil",
",",
"stdin",
":",
"config",
".",
"Stdin",
",",
"stdout",
":",
"config",
".",
"Stdout",
",",
"stderr",
":",
"config",
".",
"Stderr",
",",
"}",
"\n",
"p",
".",
"service_name",
"=",
"C",
".",
"CString",
"(",
"config",
".",
"ServiceName",
")",
"\n",
"p",
".",
"user",
"=",
"C",
".",
"CString",
"(",
"config",
".",
"Username",
")",
"\n",
"p",
".",
"handlerIndex",
"=",
"registerHandler",
"(",
"p",
")",
"\n",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_start",
"(",
"pamHandle",
",",
"p",
".",
"service_name",
",",
"p",
".",
"user",
",",
"p",
".",
"conv",
",",
"&",
"p",
".",
"pamh",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n",
"retval",
":=",
"C",
".",
"_pam_acct_mgmt",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"retval",
")",
"\n",
"}",
"\n",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_open_session",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] |
// Open creates a PAM context and initiates a PAM transaction to check the
// account and then opens a session.
|
[
"Open",
"creates",
"a",
"PAM",
"context",
"and",
"initiates",
"a",
"PAM",
"transaction",
"to",
"check",
"the",
"account",
"and",
"then",
"opens",
"a",
"session",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L215-L271
|
train
|
gravitational/teleport
|
lib/pam/pam.go
|
Close
|
func (p *PAM) Close() error {
// Close the PAM session. Closing a session can entail anything from
// unmounting a home directory and updating auth.log.
p.retval = C._pam_close_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return p.codeToError(p.retval)
}
// Terminate the PAM transaction.
retval := C._pam_end(pamHandle, p.pamh, p.retval)
if retval != C.PAM_SUCCESS {
return p.codeToError(retval)
}
// Unregister handler index at the package level.
unregisterHandler(p.handlerIndex)
// Release the memory allocated for the conversation function.
C.free(unsafe.Pointer(p.conv))
// Release strings that were allocated when opening the PAM context.
C.free(unsafe.Pointer(p.service_name))
C.free(unsafe.Pointer(p.user))
return nil
}
|
go
|
func (p *PAM) Close() error {
// Close the PAM session. Closing a session can entail anything from
// unmounting a home directory and updating auth.log.
p.retval = C._pam_close_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return p.codeToError(p.retval)
}
// Terminate the PAM transaction.
retval := C._pam_end(pamHandle, p.pamh, p.retval)
if retval != C.PAM_SUCCESS {
return p.codeToError(retval)
}
// Unregister handler index at the package level.
unregisterHandler(p.handlerIndex)
// Release the memory allocated for the conversation function.
C.free(unsafe.Pointer(p.conv))
// Release strings that were allocated when opening the PAM context.
C.free(unsafe.Pointer(p.service_name))
C.free(unsafe.Pointer(p.user))
return nil
}
|
[
"func",
"(",
"p",
"*",
"PAM",
")",
"Close",
"(",
")",
"error",
"{",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_close_session",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n",
"retval",
":=",
"C",
".",
"_pam_end",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"p",
".",
"retval",
")",
"\n",
"if",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"p",
".",
"codeToError",
"(",
"retval",
")",
"\n",
"}",
"\n",
"unregisterHandler",
"(",
"p",
".",
"handlerIndex",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"conv",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"service_name",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"user",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close will close the session, the PAM context, and release any allocated
// memory.
|
[
"Close",
"will",
"close",
"the",
"session",
"the",
"PAM",
"context",
"and",
"release",
"any",
"allocated",
"memory",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L275-L300
|
train
|
gravitational/teleport
|
lib/pam/pam.go
|
codeToError
|
func (p *PAM) codeToError(returnValue C.int) error {
// Error strings are not allocated on the heap, so memory does not need
// released.
err := C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
}
|
go
|
func (p *PAM) codeToError(returnValue C.int) error {
// Error strings are not allocated on the heap, so memory does not need
// released.
err := C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
}
|
[
"func",
"(",
"p",
"*",
"PAM",
")",
"codeToError",
"(",
"returnValue",
"C",
".",
"int",
")",
"error",
"{",
"err",
":=",
"C",
".",
"_pam_strerror",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"returnValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"C",
".",
"GoString",
"(",
"err",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// codeToError returns a human readable string from the PAM error.
|
[
"codeToError",
"returns",
"a",
"human",
"readable",
"string",
"from",
"the",
"PAM",
"error",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L334-L343
|
train
|
gravitational/teleport
|
lib/utils/fakeconn.go
|
DualPipeNetConn
|
func DualPipeNetConn(srcAddr net.Addr, dstAddr net.Addr) (*PipeNetConn, *PipeNetConn) {
server, client := net.Pipe()
serverConn := NewPipeNetConn(server, server, server, dstAddr, srcAddr)
clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
}
|
go
|
func DualPipeNetConn(srcAddr net.Addr, dstAddr net.Addr) (*PipeNetConn, *PipeNetConn) {
server, client := net.Pipe()
serverConn := NewPipeNetConn(server, server, server, dstAddr, srcAddr)
clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
}
|
[
"func",
"DualPipeNetConn",
"(",
"srcAddr",
"net",
".",
"Addr",
",",
"dstAddr",
"net",
".",
"Addr",
")",
"(",
"*",
"PipeNetConn",
",",
"*",
"PipeNetConn",
")",
"{",
"server",
",",
"client",
":=",
"net",
".",
"Pipe",
"(",
")",
"\n",
"serverConn",
":=",
"NewPipeNetConn",
"(",
"server",
",",
"server",
",",
"server",
",",
"dstAddr",
",",
"srcAddr",
")",
"\n",
"clientConn",
":=",
"NewPipeNetConn",
"(",
"client",
",",
"client",
",",
"client",
",",
"srcAddr",
",",
"dstAddr",
")",
"\n",
"return",
"serverConn",
",",
"clientConn",
"\n",
"}"
] |
// DualPipeAddrConn creates a net.Pipe to connect a client and a server. The
// two net.Conn instances are wrapped in an addrConn which holds the source and
// destination addresses.
|
[
"DualPipeAddrConn",
"creates",
"a",
"net",
".",
"Pipe",
"to",
"connect",
"a",
"client",
"and",
"a",
"server",
".",
"The",
"two",
"net",
".",
"Conn",
"instances",
"are",
"wrapped",
"in",
"an",
"addrConn",
"which",
"holds",
"the",
"source",
"and",
"destination",
"addresses",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/fakeconn.go#L89-L96
|
train
|
gravitational/teleport
|
lib/services/clustername.go
|
NewClusterName
|
func NewClusterName(spec ClusterNameSpecV2) (ClusterName, error) {
cn := ClusterNameV2{
Kind: KindClusterName,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterName,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cn, nil
}
|
go
|
func NewClusterName(spec ClusterNameSpecV2) (ClusterName, error) {
cn := ClusterNameV2{
Kind: KindClusterName,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterName,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cn, nil
}
|
[
"func",
"NewClusterName",
"(",
"spec",
"ClusterNameSpecV2",
")",
"(",
"ClusterName",
",",
"error",
")",
"{",
"cn",
":=",
"ClusterNameV2",
"{",
"Kind",
":",
"KindClusterName",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"MetaNameClusterName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"err",
":=",
"cn",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"cn",
",",
"nil",
"\n",
"}"
] |
// NewClusterName is a convenience wrapper to create a ClusterName resource.
|
[
"NewClusterName",
"is",
"a",
"convenience",
"wrapper",
"to",
"create",
"a",
"ClusterName",
"resource",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L46-L61
|
train
|
gravitational/teleport
|
lib/services/clustername.go
|
GetClusterNameSchema
|
func GetClusterNameSchema(extensionSchema string) string {
var clusterNameSchema string
if clusterNameSchema == "" {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, "")
} else {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterNameSchema, DefaultDefinitions)
}
|
go
|
func GetClusterNameSchema(extensionSchema string) string {
var clusterNameSchema string
if clusterNameSchema == "" {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, "")
} else {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterNameSchema, DefaultDefinitions)
}
|
[
"func",
"GetClusterNameSchema",
"(",
"extensionSchema",
"string",
")",
"string",
"{",
"var",
"clusterNameSchema",
"string",
"\n",
"if",
"clusterNameSchema",
"==",
"\"\"",
"{",
"clusterNameSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"ClusterNameSpecSchemaTemplate",
",",
"\"\"",
")",
"\n",
"}",
"else",
"{",
"clusterNameSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"ClusterNameSpecSchemaTemplate",
",",
"\",\"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"clusterNameSchema",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] |
// GetClusterNameSchema returns the schema with optionally injected
// schema for extensions.
|
[
"GetClusterNameSchema",
"returns",
"the",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L166-L174
|
train
|
gravitational/teleport
|
lib/services/clustername.go
|
Unmarshal
|
func (t *TeleportClusterNameMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterName, error) {
var clusterName ClusterNameV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &clusterName); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetClusterNameSchema(""), &clusterName, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = clusterName.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterName.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterName.SetExpiry(cfg.Expires)
}
return &clusterName, nil
}
|
go
|
func (t *TeleportClusterNameMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterName, error) {
var clusterName ClusterNameV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &clusterName); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetClusterNameSchema(""), &clusterName, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = clusterName.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterName.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterName.SetExpiry(cfg.Expires)
}
return &clusterName, nil
}
|
[
"func",
"(",
"t",
"*",
"TeleportClusterNameMarshaler",
")",
"Unmarshal",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ClusterName",
",",
"error",
")",
"{",
"var",
"clusterName",
"ClusterNameV2",
"\n",
"if",
"len",
"(",
"bytes",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing resource data\"",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"clusterName",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
"=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetClusterNameSchema",
"(",
"\"\"",
")",
",",
"&",
"clusterName",
",",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"clusterName",
".",
"CheckAndSetDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"clusterName",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"clusterName",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"clusterName",
",",
"nil",
"\n",
"}"
] |
// Unmarshal unmarshals ClusterName from JSON.
|
[
"Unmarshal",
"unmarshals",
"ClusterName",
"from",
"JSON",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L203-L239
|
train
|
gravitational/teleport
|
lib/services/clustername.go
|
Marshal
|
func (t *TeleportClusterNameMarshaler) Marshal(c ClusterName, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterNameV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
}
|
go
|
func (t *TeleportClusterNameMarshaler) Marshal(c ClusterName, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterNameV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
}
|
[
"func",
"(",
"t",
"*",
"TeleportClusterNameMarshaler",
")",
"Marshal",
"(",
"c",
"ClusterName",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"resource",
":=",
"c",
".",
"(",
"type",
")",
"{",
"case",
"*",
"ClusterNameV2",
":",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"copy",
":=",
"*",
"resource",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"resource",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"resource",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"unrecognized resource version %T\"",
",",
"c",
")",
"\n",
"}",
"\n",
"}"
] |
// Marshal marshals ClusterName to JSON.
|
[
"Marshal",
"marshals",
"ClusterName",
"to",
"JSON",
"."
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L242-L260
|
train
|
gravitational/teleport
|
lib/services/trust.go
|
Check
|
func (c CertAuthType) Check() error {
if c != HostCA && c != UserCA {
return trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
}
|
go
|
func (c CertAuthType) Check() error {
if c != HostCA && c != UserCA {
return trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
}
|
[
"func",
"(",
"c",
"CertAuthType",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"c",
"!=",
"HostCA",
"&&",
"c",
"!=",
"UserCA",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"'%v' authority type is not supported\"",
",",
"c",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check checks if certificate authority type value is correct
|
[
"Check",
"checks",
"if",
"certificate",
"authority",
"type",
"value",
"is",
"correct"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trust.go#L81-L86
|
train
|
gravitational/teleport
|
lib/services/trust.go
|
Check
|
func (c *CertAuthID) Check() error {
if err := c.Type.Check(); err != nil {
return trace.Wrap(err)
}
if strings.TrimSpace(c.DomainName) == "" {
return trace.BadParameter("identity validation error: empty domain name")
}
return nil
}
|
go
|
func (c *CertAuthID) Check() error {
if err := c.Type.Check(); err != nil {
return trace.Wrap(err)
}
if strings.TrimSpace(c.DomainName) == "" {
return trace.BadParameter("identity validation error: empty domain name")
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"CertAuthID",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"Type",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"TrimSpace",
"(",
"c",
".",
"DomainName",
")",
"==",
"\"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"identity validation error: empty domain name\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Check returns error if any of the id parameters are bad, nil otherwise
|
[
"Check",
"returns",
"error",
"if",
"any",
"of",
"the",
"id",
"parameters",
"are",
"bad",
"nil",
"otherwise"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trust.go#L99-L107
|
train
|
gravitational/teleport
|
lib/services/tunnel.go
|
NewReverseTunnel
|
func NewReverseTunnel(clusterName string, dialAddrs []string) ReverseTunnel {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs,
},
}
}
|
go
|
func NewReverseTunnel(clusterName string, dialAddrs []string) ReverseTunnel {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs,
},
}
}
|
[
"func",
"NewReverseTunnel",
"(",
"clusterName",
"string",
",",
"dialAddrs",
"[",
"]",
"string",
")",
"ReverseTunnel",
"{",
"return",
"&",
"ReverseTunnelV2",
"{",
"Kind",
":",
"KindReverseTunnel",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"clusterName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"ReverseTunnelSpecV2",
"{",
"ClusterName",
":",
"clusterName",
",",
"DialAddrs",
":",
"dialAddrs",
",",
"}",
",",
"}",
"\n",
"}"
] |
// NewReverseTunnel returns new version of reverse tunnel
|
[
"NewReverseTunnel",
"returns",
"new",
"version",
"of",
"reverse",
"tunnel"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L55-L68
|
train
|
gravitational/teleport
|
lib/services/tunnel.go
|
V2
|
func (r *ReverseTunnelV1) V2() *ReverseTunnelV2 {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: r.DomainName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.DialAddrs,
},
}
}
|
go
|
func (r *ReverseTunnelV1) V2() *ReverseTunnelV2 {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: r.DomainName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.DialAddrs,
},
}
}
|
[
"func",
"(",
"r",
"*",
"ReverseTunnelV1",
")",
"V2",
"(",
")",
"*",
"ReverseTunnelV2",
"{",
"return",
"&",
"ReverseTunnelV2",
"{",
"Kind",
":",
"KindReverseTunnel",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"r",
".",
"DomainName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"ReverseTunnelSpecV2",
"{",
"ClusterName",
":",
"r",
".",
"DomainName",
",",
"Type",
":",
"ProxyTunnel",
",",
"DialAddrs",
":",
"r",
".",
"DialAddrs",
",",
"}",
",",
"}",
"\n",
"}"
] |
// V2 returns V2 version of reverse tunnel
|
[
"V2",
"returns",
"V2",
"version",
"of",
"reverse",
"tunnel"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L240-L254
|
train
|
gravitational/teleport
|
lib/services/tunnel.go
|
UnmarshalReverseTunnel
|
func UnmarshalReverseTunnel(data []byte, opts ...MarshalOption) (ReverseTunnel, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel data")
}
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var r ReverseTunnelV1
err := json.Unmarshal(data, &r)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := r.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return r.V2(), nil
case V2:
var r ReverseTunnelV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &r); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetReverseTunnelSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.SetExpiry(cfg.Expires)
}
return &r, nil
}
return nil, trace.BadParameter("reverse tunnel version %v is not supported", h.Version)
}
|
go
|
func UnmarshalReverseTunnel(data []byte, opts ...MarshalOption) (ReverseTunnel, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel data")
}
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var r ReverseTunnelV1
err := json.Unmarshal(data, &r)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := r.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return r.V2(), nil
case V2:
var r ReverseTunnelV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &r); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetReverseTunnelSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.SetExpiry(cfg.Expires)
}
return &r, nil
}
return nil, trace.BadParameter("reverse tunnel version %v is not supported", h.Version)
}
|
[
"func",
"UnmarshalReverseTunnel",
"(",
"data",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ReverseTunnel",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"missing tunnel data\"",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"\"",
":",
"var",
"r",
"ReverseTunnelV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"v2",
":=",
"r",
".",
"V2",
"(",
")",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"v2",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"r",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"r",
"ReverseTunnelV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetReverseTunnelSchema",
"(",
")",
",",
"&",
"r",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"r",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"r",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"reverse tunnel version %v is not supported\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] |
// UnmarshalReverseTunnel unmarshals reverse tunnel from JSON or YAML,
// sets defaults and checks the schema
|
[
"UnmarshalReverseTunnel",
"unmarshals",
"reverse",
"tunnel",
"from",
"JSON",
"or",
"YAML",
"sets",
"defaults",
"and",
"checks",
"the",
"schema"
] |
d5243dbe8d36bba44bf640c08f1c49185ed2c8a4
|
https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L264-L313
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.