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
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDependsByClassidObjidObjsubid
|
func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
}
|
go
|
func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
}
|
[
"func",
"PgDependsByClassidObjidObjsubid",
"(",
"db",
"XODB",
",",
"classid",
"pgtypes",
".",
"Oid",
",",
"objid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"[",
"]",
"*",
"PgDepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype `",
"+",
"`FROM pg_catalog.pg_depend `",
"+",
"`WHERE classid = $1 AND objid = $2 AND objsubid = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgDepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pd",
":=",
"PgDepend",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Classid",
",",
"&",
"pd",
".",
"Objid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Refclassid",
",",
"&",
"pd",
".",
"Refobjid",
",",
"&",
"pd",
".",
"Refobjsubid",
",",
"&",
"pd",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pd",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgDependsByClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_depend' as a PgDepend.
//
// Generated from index 'pg_depend_depender_index'.
|
[
"PgDependsByClassidObjidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_depend",
"as",
"a",
"PgDepend",
".",
"Generated",
"from",
"index",
"pg_depend_depender_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42636-L42668
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDescriptionByObjoidClassoidObjsubid
|
func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
}
|
go
|
func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
}
|
[
"func",
"PgDescriptionByObjoidClassoidObjsubid",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"*",
"PgDescription",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description `",
"+",
"`FROM pg_catalog.pg_description `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
"\n",
"pd",
":=",
"PgDescription",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Objoid",
",",
"&",
"pd",
".",
"Classoid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Description",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pd",
",",
"nil",
"\n",
"}"
] |
// PgDescriptionByObjoidClassoidObjsubid retrieves a row from 'pg_catalog.pg_description' as a PgDescription.
//
// Generated from index 'pg_description_o_c_o_index'.
|
[
"PgDescriptionByObjoidClassoidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_description",
"as",
"a",
"PgDescription",
".",
"Generated",
"from",
"index",
"pg_description_o_c_o_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42710-L42729
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByOid
|
func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByOid retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_oid_index'.
|
[
"PgEnumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42734-L42753
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByEnumtypidEnumlabel
|
func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByEnumtypidEnumlabel",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumlabel",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumlabel = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByEnumtypidEnumlabel retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_label_index'.
|
[
"PgEnumByEnumtypidEnumlabel",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_label_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42758-L42777
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByEnumtypidEnumsortorder
|
func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByEnumtypidEnumsortorder",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumsortorder",
"float32",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumsortorder = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByEnumtypidEnumsortorder retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_sortorder_index'.
|
[
"PgEnumByEnumtypidEnumsortorder",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_sortorder_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42782-L42801
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEventTriggerByEvtname
|
func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
}
|
go
|
func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
}
|
[
"func",
"PgEventTriggerByEvtname",
"(",
"db",
"XODB",
",",
"evtname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEventTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags `",
"+",
"`FROM pg_catalog.pg_event_trigger `",
"+",
"`WHERE evtname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"evtname",
")",
"\n",
"pet",
":=",
"PgEventTrigger",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"evtname",
")",
".",
"Scan",
"(",
"&",
"pet",
".",
"Tableoid",
",",
"&",
"pet",
".",
"Cmax",
",",
"&",
"pet",
".",
"Xmax",
",",
"&",
"pet",
".",
"Cmin",
",",
"&",
"pet",
".",
"Xmin",
",",
"&",
"pet",
".",
"Oid",
",",
"&",
"pet",
".",
"Ctid",
",",
"&",
"pet",
".",
"Evtname",
",",
"&",
"pet",
".",
"Evtevent",
",",
"&",
"pet",
".",
"Evtowner",
",",
"&",
"pet",
".",
"Evtfoid",
",",
"&",
"pet",
".",
"Evtenabled",
",",
"&",
"pet",
".",
"Evttags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pet",
",",
"nil",
"\n",
"}"
] |
// PgEventTriggerByEvtname retrieves a row from 'pg_catalog.pg_event_trigger' as a PgEventTrigger.
//
// Generated from index 'pg_event_trigger_evtname_index'.
|
[
"PgEventTriggerByEvtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_event_trigger",
"as",
"a",
"PgEventTrigger",
".",
"Generated",
"from",
"index",
"pg_event_trigger_evtname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42806-L42825
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgExtensionByExtname
|
func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgExtensionByExtname",
"(",
"db",
"XODB",
",",
"extname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgExtension",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition `",
"+",
"`FROM pg_catalog.pg_extension `",
"+",
"`WHERE extname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"extname",
")",
"\n",
"pe",
":=",
"PgExtension",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"extname",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Extname",
",",
"&",
"pe",
".",
"Extowner",
",",
"&",
"pe",
".",
"Extnamespace",
",",
"&",
"pe",
".",
"Extrelocatable",
",",
"&",
"pe",
".",
"Extversion",
",",
"&",
"pe",
".",
"Extconfig",
",",
"&",
"pe",
".",
"Extcondition",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgExtensionByExtname retrieves a row from 'pg_catalog.pg_extension' as a PgExtension.
//
// Generated from index 'pg_extension_name_index'.
|
[
"PgExtensionByExtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_extension",
"as",
"a",
"PgExtension",
".",
"Generated",
"from",
"index",
"pg_extension_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42854-L42873
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignDataWrapperByOid
|
func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
}
|
go
|
func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
}
|
[
"func",
"PgForeignDataWrapperByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignDataWrapper",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions `",
"+",
"`FROM pg_catalog.pg_foreign_data_wrapper `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pfdw",
":=",
"PgForeignDataWrapper",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pfdw",
".",
"Tableoid",
",",
"&",
"pfdw",
".",
"Cmax",
",",
"&",
"pfdw",
".",
"Xmax",
",",
"&",
"pfdw",
".",
"Cmin",
",",
"&",
"pfdw",
".",
"Xmin",
",",
"&",
"pfdw",
".",
"Oid",
",",
"&",
"pfdw",
".",
"Ctid",
",",
"&",
"pfdw",
".",
"Fdwname",
",",
"&",
"pfdw",
".",
"Fdwowner",
",",
"&",
"pfdw",
".",
"Fdwhandler",
",",
"&",
"pfdw",
".",
"Fdwvalidator",
",",
"&",
"pfdw",
".",
"Fdwacl",
",",
"&",
"pfdw",
".",
"Fdwoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pfdw",
",",
"nil",
"\n",
"}"
] |
// PgForeignDataWrapperByOid retrieves a row from 'pg_catalog.pg_foreign_data_wrapper' as a PgForeignDataWrapper.
//
// Generated from index 'pg_foreign_data_wrapper_oid_index'.
|
[
"PgForeignDataWrapperByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_data_wrapper",
"as",
"a",
"PgForeignDataWrapper",
".",
"Generated",
"from",
"index",
"pg_foreign_data_wrapper_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42926-L42945
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignServerBySrvname
|
func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
}
|
go
|
func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
}
|
[
"func",
"PgForeignServerBySrvname",
"(",
"db",
"XODB",
",",
"srvname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgForeignServer",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions `",
"+",
"`FROM pg_catalog.pg_foreign_server `",
"+",
"`WHERE srvname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"srvname",
")",
"\n",
"pfs",
":=",
"PgForeignServer",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"srvname",
")",
".",
"Scan",
"(",
"&",
"pfs",
".",
"Tableoid",
",",
"&",
"pfs",
".",
"Cmax",
",",
"&",
"pfs",
".",
"Xmax",
",",
"&",
"pfs",
".",
"Cmin",
",",
"&",
"pfs",
".",
"Xmin",
",",
"&",
"pfs",
".",
"Oid",
",",
"&",
"pfs",
".",
"Ctid",
",",
"&",
"pfs",
".",
"Srvname",
",",
"&",
"pfs",
".",
"Srvowner",
",",
"&",
"pfs",
".",
"Srvfdw",
",",
"&",
"pfs",
".",
"Srvtype",
",",
"&",
"pfs",
".",
"Srvversion",
",",
"&",
"pfs",
".",
"Srvacl",
",",
"&",
"pfs",
".",
"Srvoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pfs",
",",
"nil",
"\n",
"}"
] |
// PgForeignServerBySrvname retrieves a row from 'pg_catalog.pg_foreign_server' as a PgForeignServer.
//
// Generated from index 'pg_foreign_server_name_index'.
|
[
"PgForeignServerBySrvname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_server",
"as",
"a",
"PgForeignServer",
".",
"Generated",
"from",
"index",
"pg_foreign_server_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42950-L42969
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignTableByFtrelid
|
func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
}
|
go
|
func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
}
|
[
"func",
"PgForeignTableByFtrelid",
"(",
"db",
"XODB",
",",
"ftrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignTable",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions `",
"+",
"`FROM pg_catalog.pg_foreign_table `",
"+",
"`WHERE ftrelid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ftrelid",
")",
"\n",
"pft",
":=",
"PgForeignTable",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"ftrelid",
")",
".",
"Scan",
"(",
"&",
"pft",
".",
"Tableoid",
",",
"&",
"pft",
".",
"Cmax",
",",
"&",
"pft",
".",
"Xmax",
",",
"&",
"pft",
".",
"Cmin",
",",
"&",
"pft",
".",
"Xmin",
",",
"&",
"pft",
".",
"Ctid",
",",
"&",
"pft",
".",
"Ftrelid",
",",
"&",
"pft",
".",
"Ftserver",
",",
"&",
"pft",
".",
"Ftoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pft",
",",
"nil",
"\n",
"}"
] |
// PgForeignTableByFtrelid retrieves a row from 'pg_catalog.pg_foreign_table' as a PgForeignTable.
//
// Generated from index 'pg_foreign_table_relid_index'.
|
[
"PgForeignTableByFtrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_table",
"as",
"a",
"PgForeignTable",
".",
"Generated",
"from",
"index",
"pg_foreign_table_relid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42998-L43017
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgIndexByIndexrelid
|
func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
}
|
go
|
func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
}
|
[
"func",
"PgIndexByIndexrelid",
"(",
"db",
"XODB",
",",
"indexrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indexrelid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"indexrelid",
")",
"\n",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"indexrelid",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] |
// PgIndexByIndexrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indexrelid_index'.
|
[
"PgIndexByIndexrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indexrelid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43022-L43041
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgIndicesByIndrelid
|
func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
go
|
func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
[
"func",
"PgIndicesByIndrelid",
"(",
"db",
"XODB",
",",
"indrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indrelid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgIndex",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgIndicesByIndrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indrelid_index'.
|
[
"PgIndicesByIndrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indrelid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43046-L43078
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgInheritsByInhparent
|
func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
go
|
func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
[
"func",
"PgInheritsByInhparent",
"(",
"db",
"XODB",
",",
"inhparent",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhparent = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgInherit",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgInheritsByInhparent retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_parent_index'.
|
[
"PgInheritsByInhparent",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_parent_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43083-L43115
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgInheritByInhrelidInhseqno
|
func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
}
|
go
|
func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
}
|
[
"func",
"PgInheritByInhrelidInhseqno",
"(",
"db",
"XODB",
",",
"inhrelid",
"pgtypes",
".",
"Oid",
",",
"inhseqno",
"int",
")",
"(",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhrelid = $1 AND inhseqno = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
"\n",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] |
// PgInheritByInhrelidInhseqno retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_relid_seqno_index'.
|
[
"PgInheritByInhrelidInhseqno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_relid_seqno_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43120-L43139
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLanguageByLanname
|
func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
}
|
go
|
func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
}
|
[
"func",
"PgLanguageByLanname",
"(",
"db",
"XODB",
",",
"lanname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgLanguage",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl `",
"+",
"`FROM pg_catalog.pg_language `",
"+",
"`WHERE lanname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"lanname",
")",
"\n",
"pl",
":=",
"PgLanguage",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"lanname",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Oid",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Lanname",
",",
"&",
"pl",
".",
"Lanowner",
",",
"&",
"pl",
".",
"Lanispl",
",",
"&",
"pl",
".",
"Lanpltrusted",
",",
"&",
"pl",
".",
"Lanplcallfoid",
",",
"&",
"pl",
".",
"Laninline",
",",
"&",
"pl",
".",
"Lanvalidator",
",",
"&",
"pl",
".",
"Lanacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] |
// PgLanguageByLanname retrieves a row from 'pg_catalog.pg_language' as a PgLanguage.
//
// Generated from index 'pg_language_name_index'.
|
[
"PgLanguageByLanname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_language",
"as",
"a",
"PgLanguage",
".",
"Generated",
"from",
"index",
"pg_language_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43144-L43163
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLargeobjectByLoidPageno
|
func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
}
|
go
|
func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
}
|
[
"func",
"PgLargeobjectByLoidPageno",
"(",
"db",
"XODB",
",",
"loid",
"pgtypes",
".",
"Oid",
",",
"pageno",
"int",
")",
"(",
"*",
"PgLargeobject",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data `",
"+",
"`FROM pg_catalog.pg_largeobject `",
"+",
"`WHERE loid = $1 AND pageno = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
"\n",
"pl",
":=",
"PgLargeobject",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Loid",
",",
"&",
"pl",
".",
"Pageno",
",",
"&",
"pl",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] |
// PgLargeobjectByLoidPageno retrieves a row from 'pg_catalog.pg_largeobject' as a PgLargeobject.
//
// Generated from index 'pg_largeobject_loid_pn_index'.
|
[
"PgLargeobjectByLoidPageno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject",
"as",
"a",
"PgLargeobject",
".",
"Generated",
"from",
"index",
"pg_largeobject_loid_pn_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43192-L43211
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLargeobjectMetadatumByOid
|
func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
}
|
go
|
func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
}
|
[
"func",
"PgLargeobjectMetadatumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgLargeobjectMetadatum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl `",
"+",
"`FROM pg_catalog.pg_largeobject_metadata `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"plm",
":=",
"PgLargeobjectMetadatum",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"plm",
".",
"Tableoid",
",",
"&",
"plm",
".",
"Cmax",
",",
"&",
"plm",
".",
"Xmax",
",",
"&",
"plm",
".",
"Cmin",
",",
"&",
"plm",
".",
"Xmin",
",",
"&",
"plm",
".",
"Oid",
",",
"&",
"plm",
".",
"Ctid",
",",
"&",
"plm",
".",
"Lomowner",
",",
"&",
"plm",
".",
"Lomacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"plm",
",",
"nil",
"\n",
"}"
] |
// PgLargeobjectMetadatumByOid retrieves a row from 'pg_catalog.pg_largeobject_metadata' as a PgLargeobjectMetadatum.
//
// Generated from index 'pg_largeobject_metadata_oid_index'.
|
[
"PgLargeobjectMetadatumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject_metadata",
"as",
"a",
"PgLargeobjectMetadatum",
".",
"Generated",
"from",
"index",
"pg_largeobject_metadata_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43216-L43235
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgNamespaceByNspname
|
func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
}
|
go
|
func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
}
|
[
"func",
"PgNamespaceByNspname",
"(",
"db",
"XODB",
",",
"nspname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgNamespace",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl `",
"+",
"`FROM pg_catalog.pg_namespace `",
"+",
"`WHERE nspname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"nspname",
")",
"\n",
"pn",
":=",
"PgNamespace",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"nspname",
")",
".",
"Scan",
"(",
"&",
"pn",
".",
"Tableoid",
",",
"&",
"pn",
".",
"Cmax",
",",
"&",
"pn",
".",
"Xmax",
",",
"&",
"pn",
".",
"Cmin",
",",
"&",
"pn",
".",
"Xmin",
",",
"&",
"pn",
".",
"Oid",
",",
"&",
"pn",
".",
"Ctid",
",",
"&",
"pn",
".",
"Nspname",
",",
"&",
"pn",
".",
"Nspowner",
",",
"&",
"pn",
".",
"Nspacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pn",
",",
"nil",
"\n",
"}"
] |
// PgNamespaceByNspname retrieves a row from 'pg_catalog.pg_namespace' as a PgNamespace.
//
// Generated from index 'pg_namespace_nspname_index'.
|
[
"PgNamespaceByNspname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_namespace",
"as",
"a",
"PgNamespace",
".",
"Generated",
"from",
"index",
"pg_namespace_nspname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43240-L43259
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpclassByOpcmethodOpcnameOpcnamespace
|
func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"(",
"db",
"XODB",
",",
"opcmethod",
"pgtypes",
".",
"Oid",
",",
"opcname",
"pgtypes",
".",
"Name",
",",
"opcnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpclassByOpcmethodOpcnameOpcnamespace retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_am_name_nsp_index'.
|
[
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_am_name_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43288-L43307
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpclassByOid
|
func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpclassByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpclassByOid retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_oid_index'.
|
[
"PgOpclassByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43312-L43331
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOperatorByOid
|
func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOperatorByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOperator",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin `",
"+",
"`FROM pg_catalog.pg_operator `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOperator",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Oprname",
",",
"&",
"po",
".",
"Oprnamespace",
",",
"&",
"po",
".",
"Oprowner",
",",
"&",
"po",
".",
"Oprkind",
",",
"&",
"po",
".",
"Oprcanmerge",
",",
"&",
"po",
".",
"Oprcanhash",
",",
"&",
"po",
".",
"Oprleft",
",",
"&",
"po",
".",
"Oprright",
",",
"&",
"po",
".",
"Oprresult",
",",
"&",
"po",
".",
"Oprcom",
",",
"&",
"po",
".",
"Oprnegate",
",",
"&",
"po",
".",
"Oprcode",
",",
"&",
"po",
".",
"Oprrest",
",",
"&",
"po",
".",
"Oprjoin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOperatorByOid retrieves a row from 'pg_catalog.pg_operator' as a PgOperator.
//
// Generated from index 'pg_operator_oid_index'.
|
[
"PgOperatorByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_operator",
"as",
"a",
"PgOperator",
".",
"Generated",
"from",
"index",
"pg_operator_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43336-L43355
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpfamilyByOpfmethodOpfnameOpfnamespace
|
func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"(",
"db",
"XODB",
",",
"opfmethod",
"pgtypes",
".",
"Oid",
",",
"opfname",
"pgtypes",
".",
"Name",
",",
"opfnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpfamily",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner `",
"+",
"`FROM pg_catalog.pg_opfamily `",
"+",
"`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opfmethod",
",",
"&",
"po",
".",
"Opfname",
",",
"&",
"po",
".",
"Opfnamespace",
",",
"&",
"po",
".",
"Opfowner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpfamilyByOpfmethodOpfnameOpfnamespace retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_am_name_nsp_index'.
|
[
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opfamily",
"as",
"a",
"PgOpfamily",
".",
"Generated",
"from",
"index",
"pg_opfamily_am_name_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43384-L43403
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpfamilyByOid
|
func PgOpfamilyByOid(db XODB, oid pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpfamilyByOid(db XODB, oid pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpfamilyByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpfamily",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner `",
"+",
"`FROM pg_catalog.pg_opfamily `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opfmethod",
",",
"&",
"po",
".",
"Opfname",
",",
"&",
"po",
".",
"Opfnamespace",
",",
"&",
"po",
".",
"Opfowner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpfamilyByOid retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_oid_index'.
|
[
"PgOpfamilyByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opfamily",
"as",
"a",
"PgOpfamily",
".",
"Generated",
"from",
"index",
"pg_opfamily_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43408-L43427
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgPltemplateByTmplname
|
func PgPltemplateByTmplname(db XODB, tmplname pgtypes.Name) (*PgPltemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl ` +
`FROM pg_catalog.pg_pltemplate ` +
`WHERE tmplname = $1`
// run query
XOLog(sqlstr, tmplname)
pp := PgPltemplate{}
err = db.QueryRow(sqlstr, tmplname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Tmplname, &pp.Tmpltrusted, &pp.Tmpldbacreate, &pp.Tmplhandler, &pp.Tmplinline, &pp.Tmplvalidator, &pp.Tmpllibrary, &pp.Tmplacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgPltemplateByTmplname(db XODB, tmplname pgtypes.Name) (*PgPltemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl ` +
`FROM pg_catalog.pg_pltemplate ` +
`WHERE tmplname = $1`
// run query
XOLog(sqlstr, tmplname)
pp := PgPltemplate{}
err = db.QueryRow(sqlstr, tmplname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Tmplname, &pp.Tmpltrusted, &pp.Tmpldbacreate, &pp.Tmplhandler, &pp.Tmplinline, &pp.Tmplvalidator, &pp.Tmpllibrary, &pp.Tmplacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgPltemplateByTmplname",
"(",
"db",
"XODB",
",",
"tmplname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgPltemplate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl `",
"+",
"`FROM pg_catalog.pg_pltemplate `",
"+",
"`WHERE tmplname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"tmplname",
")",
"\n",
"pp",
":=",
"PgPltemplate",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"tmplname",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Tmplname",
",",
"&",
"pp",
".",
"Tmpltrusted",
",",
"&",
"pp",
".",
"Tmpldbacreate",
",",
"&",
"pp",
".",
"Tmplhandler",
",",
"&",
"pp",
".",
"Tmplinline",
",",
"&",
"pp",
".",
"Tmplvalidator",
",",
"&",
"pp",
".",
"Tmpllibrary",
",",
"&",
"pp",
".",
"Tmplacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgPltemplateByTmplname retrieves a row from 'pg_catalog.pg_pltemplate' as a PgPltemplate.
//
// Generated from index 'pg_pltemplate_name_index'.
|
[
"PgPltemplateByTmplname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_pltemplate",
"as",
"a",
"PgPltemplate",
".",
"Generated",
"from",
"index",
"pg_pltemplate_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43432-L43451
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgPolicyByOid
|
func PgPolicyByOid(db XODB, oid pgtypes.Oid) (*PgPolicy, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck ` +
`FROM pg_catalog.pg_policy ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pp := PgPolicy{}
err = db.QueryRow(sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgPolicyByOid(db XODB, oid pgtypes.Oid) (*PgPolicy, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck ` +
`FROM pg_catalog.pg_policy ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pp := PgPolicy{}
err = db.QueryRow(sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgPolicyByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgPolicy",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck `",
"+",
"`FROM pg_catalog.pg_policy `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pp",
":=",
"PgPolicy",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Oid",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Polname",
",",
"&",
"pp",
".",
"Polrelid",
",",
"&",
"pp",
".",
"Polcmd",
",",
"&",
"pp",
".",
"Polroles",
",",
"&",
"pp",
".",
"Polqual",
",",
"&",
"pp",
".",
"Polwithcheck",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgPolicyByOid retrieves a row from 'pg_catalog.pg_policy' as a PgPolicy.
//
// Generated from index 'pg_policy_oid_index'.
|
[
"PgPolicyByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_policy",
"as",
"a",
"PgPolicy",
".",
"Generated",
"from",
"index",
"pg_policy_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43456-L43475
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgProcByPronameProargtypesPronamespace
|
func PgProcByPronameProargtypesPronamespace(db XODB, proname pgtypes.Name, proargtypes pgtypes.Oidvector, pronamespace pgtypes.Oid) (*PgProc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
`FROM pg_catalog.pg_proc ` +
`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`
// run query
XOLog(sqlstr, proname, proargtypes, pronamespace)
pp := PgProc{}
err = db.QueryRow(sqlstr, proname, proargtypes, pronamespace).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Protransform, &pp.Proisagg, &pp.Proiswindow, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgProcByPronameProargtypesPronamespace(db XODB, proname pgtypes.Name, proargtypes pgtypes.Oidvector, pronamespace pgtypes.Oid) (*PgProc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
`FROM pg_catalog.pg_proc ` +
`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`
// run query
XOLog(sqlstr, proname, proargtypes, pronamespace)
pp := PgProc{}
err = db.QueryRow(sqlstr, proname, proargtypes, pronamespace).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Protransform, &pp.Proisagg, &pp.Proiswindow, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgProcByPronameProargtypesPronamespace",
"(",
"db",
"XODB",
",",
"proname",
"pgtypes",
".",
"Name",
",",
"proargtypes",
"pgtypes",
".",
"Oidvector",
",",
"pronamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgProc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl `",
"+",
"`FROM pg_catalog.pg_proc `",
"+",
"`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"proname",
",",
"proargtypes",
",",
"pronamespace",
")",
"\n",
"pp",
":=",
"PgProc",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"proname",
",",
"proargtypes",
",",
"pronamespace",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Oid",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Proname",
",",
"&",
"pp",
".",
"Pronamespace",
",",
"&",
"pp",
".",
"Proowner",
",",
"&",
"pp",
".",
"Prolang",
",",
"&",
"pp",
".",
"Procost",
",",
"&",
"pp",
".",
"Prorows",
",",
"&",
"pp",
".",
"Provariadic",
",",
"&",
"pp",
".",
"Protransform",
",",
"&",
"pp",
".",
"Proisagg",
",",
"&",
"pp",
".",
"Proiswindow",
",",
"&",
"pp",
".",
"Prosecdef",
",",
"&",
"pp",
".",
"Proleakproof",
",",
"&",
"pp",
".",
"Proisstrict",
",",
"&",
"pp",
".",
"Proretset",
",",
"&",
"pp",
".",
"Provolatile",
",",
"&",
"pp",
".",
"Pronargs",
",",
"&",
"pp",
".",
"Pronargdefaults",
",",
"&",
"pp",
".",
"Prorettype",
",",
"&",
"pp",
".",
"Proargtypes",
",",
"&",
"pp",
".",
"Proallargtypes",
",",
"&",
"pp",
".",
"Proargmodes",
",",
"&",
"pp",
".",
"Proargnames",
",",
"&",
"pp",
".",
"Proargdefaults",
",",
"&",
"pp",
".",
"Protrftypes",
",",
"&",
"pp",
".",
"Prosrc",
",",
"&",
"pp",
".",
"Probin",
",",
"&",
"pp",
".",
"Proconfig",
",",
"&",
"pp",
".",
"Proacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgProcByPronameProargtypesPronamespace retrieves a row from 'pg_catalog.pg_proc' as a PgProc.
//
// Generated from index 'pg_proc_proname_args_nsp_index'.
|
[
"PgProcByPronameProargtypesPronamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_proc",
"as",
"a",
"PgProc",
".",
"Generated",
"from",
"index",
"pg_proc_proname_args_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43528-L43547
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgRangeByRngtypid
|
func PgRangeByRngtypid(db XODB, rngtypid pgtypes.Oid) (*PgRange, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff ` +
`FROM pg_catalog.pg_range ` +
`WHERE rngtypid = $1`
// run query
XOLog(sqlstr, rngtypid)
pr := PgRange{}
err = db.QueryRow(sqlstr, rngtypid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Rngtypid, &pr.Rngsubtype, &pr.Rngcollation, &pr.Rngsubopc, &pr.Rngcanonical, &pr.Rngsubdiff)
if err != nil {
return nil, err
}
return &pr, nil
}
|
go
|
func PgRangeByRngtypid(db XODB, rngtypid pgtypes.Oid) (*PgRange, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff ` +
`FROM pg_catalog.pg_range ` +
`WHERE rngtypid = $1`
// run query
XOLog(sqlstr, rngtypid)
pr := PgRange{}
err = db.QueryRow(sqlstr, rngtypid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Rngtypid, &pr.Rngsubtype, &pr.Rngcollation, &pr.Rngsubopc, &pr.Rngcanonical, &pr.Rngsubdiff)
if err != nil {
return nil, err
}
return &pr, nil
}
|
[
"func",
"PgRangeByRngtypid",
"(",
"db",
"XODB",
",",
"rngtypid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgRange",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff `",
"+",
"`FROM pg_catalog.pg_range `",
"+",
"`WHERE rngtypid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"rngtypid",
")",
"\n",
"pr",
":=",
"PgRange",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"rngtypid",
")",
".",
"Scan",
"(",
"&",
"pr",
".",
"Tableoid",
",",
"&",
"pr",
".",
"Cmax",
",",
"&",
"pr",
".",
"Xmax",
",",
"&",
"pr",
".",
"Cmin",
",",
"&",
"pr",
".",
"Xmin",
",",
"&",
"pr",
".",
"Ctid",
",",
"&",
"pr",
".",
"Rngtypid",
",",
"&",
"pr",
".",
"Rngsubtype",
",",
"&",
"pr",
".",
"Rngcollation",
",",
"&",
"pr",
".",
"Rngsubopc",
",",
"&",
"pr",
".",
"Rngcanonical",
",",
"&",
"pr",
".",
"Rngsubdiff",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pr",
",",
"nil",
"\n",
"}"
] |
// PgRangeByRngtypid retrieves a row from 'pg_catalog.pg_range' as a PgRange.
//
// Generated from index 'pg_range_rngtypid_index'.
|
[
"PgRangeByRngtypid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_range",
"as",
"a",
"PgRange",
".",
"Generated",
"from",
"index",
"pg_range_rngtypid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43552-L43571
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgReplicationOriginByRoident
|
func PgReplicationOriginByRoident(db XODB, roident pgtypes.Oid) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roident = $1`
// run query
XOLog(sqlstr, roident)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roident).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
go
|
func PgReplicationOriginByRoident(db XODB, roident pgtypes.Oid) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roident = $1`
// run query
XOLog(sqlstr, roident)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roident).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
[
"func",
"PgReplicationOriginByRoident",
"(",
"db",
"XODB",
",",
"roident",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgReplicationOrigin",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `",
"+",
"`FROM pg_catalog.pg_replication_origin `",
"+",
"`WHERE roident = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"roident",
")",
"\n",
"pro",
":=",
"PgReplicationOrigin",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"roident",
")",
".",
"Scan",
"(",
"&",
"pro",
".",
"Tableoid",
",",
"&",
"pro",
".",
"Cmax",
",",
"&",
"pro",
".",
"Xmax",
",",
"&",
"pro",
".",
"Cmin",
",",
"&",
"pro",
".",
"Xmin",
",",
"&",
"pro",
".",
"Ctid",
",",
"&",
"pro",
".",
"Roident",
",",
"&",
"pro",
".",
"Roname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pro",
",",
"nil",
"\n",
"}"
] |
// PgReplicationOriginByRoident retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roiident_index'.
|
[
"PgReplicationOriginByRoident",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_replication_origin",
"as",
"a",
"PgReplicationOrigin",
".",
"Generated",
"from",
"index",
"pg_replication_origin_roiident_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43576-L43595
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgReplicationOriginByRoname
|
func PgReplicationOriginByRoname(db XODB, roname string) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roname = $1`
// run query
XOLog(sqlstr, roname)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roname).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
go
|
func PgReplicationOriginByRoname(db XODB, roname string) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roname = $1`
// run query
XOLog(sqlstr, roname)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roname).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
[
"func",
"PgReplicationOriginByRoname",
"(",
"db",
"XODB",
",",
"roname",
"string",
")",
"(",
"*",
"PgReplicationOrigin",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `",
"+",
"`FROM pg_catalog.pg_replication_origin `",
"+",
"`WHERE roname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"roname",
")",
"\n",
"pro",
":=",
"PgReplicationOrigin",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"roname",
")",
".",
"Scan",
"(",
"&",
"pro",
".",
"Tableoid",
",",
"&",
"pro",
".",
"Cmax",
",",
"&",
"pro",
".",
"Xmax",
",",
"&",
"pro",
".",
"Cmin",
",",
"&",
"pro",
".",
"Xmin",
",",
"&",
"pro",
".",
"Ctid",
",",
"&",
"pro",
".",
"Roident",
",",
"&",
"pro",
".",
"Roname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pro",
",",
"nil",
"\n",
"}"
] |
// PgReplicationOriginByRoname retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roname_index'.
|
[
"PgReplicationOriginByRoname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_replication_origin",
"as",
"a",
"PgReplicationOrigin",
".",
"Generated",
"from",
"index",
"pg_replication_origin_roname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43600-L43619
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgRewriteByOid
|
func PgRewriteByOid(db XODB, oid pgtypes.Oid) (*PgRewrite, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
`FROM pg_catalog.pg_rewrite ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pr := PgRewrite{}
err = db.QueryRow(sqlstr, oid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Oid, &pr.Ctid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction)
if err != nil {
return nil, err
}
return &pr, nil
}
|
go
|
func PgRewriteByOid(db XODB, oid pgtypes.Oid) (*PgRewrite, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
`FROM pg_catalog.pg_rewrite ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pr := PgRewrite{}
err = db.QueryRow(sqlstr, oid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Oid, &pr.Ctid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction)
if err != nil {
return nil, err
}
return &pr, nil
}
|
[
"func",
"PgRewriteByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgRewrite",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action `",
"+",
"`FROM pg_catalog.pg_rewrite `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pr",
":=",
"PgRewrite",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pr",
".",
"Tableoid",
",",
"&",
"pr",
".",
"Cmax",
",",
"&",
"pr",
".",
"Xmax",
",",
"&",
"pr",
".",
"Cmin",
",",
"&",
"pr",
".",
"Xmin",
",",
"&",
"pr",
".",
"Oid",
",",
"&",
"pr",
".",
"Ctid",
",",
"&",
"pr",
".",
"Rulename",
",",
"&",
"pr",
".",
"EvClass",
",",
"&",
"pr",
".",
"EvType",
",",
"&",
"pr",
".",
"EvEnabled",
",",
"&",
"pr",
".",
"IsInstead",
",",
"&",
"pr",
".",
"EvQual",
",",
"&",
"pr",
".",
"EvAction",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pr",
",",
"nil",
"\n",
"}"
] |
// PgRewriteByOid retrieves a row from 'pg_catalog.pg_rewrite' as a PgRewrite.
//
// Generated from index 'pg_rewrite_oid_index'.
|
[
"PgRewriteByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_rewrite",
"as",
"a",
"PgRewrite",
".",
"Generated",
"from",
"index",
"pg_rewrite_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43624-L43643
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgSeclabelByObjoidClassoidObjsubidProvider
|
func PgSeclabelByObjoidClassoidObjsubidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int, provider string) (*PgSeclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label ` +
`FROM pg_catalog.pg_seclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`
// run query
XOLog(sqlstr, objoid, classoid, objsubid, provider)
ps := PgSeclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Objsubid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgSeclabelByObjoidClassoidObjsubidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int, provider string) (*PgSeclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label ` +
`FROM pg_catalog.pg_seclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`
// run query
XOLog(sqlstr, objoid, classoid, objsubid, provider)
ps := PgSeclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Objsubid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgSeclabelByObjoidClassoidObjsubidProvider",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
",",
"provider",
"string",
")",
"(",
"*",
"PgSeclabel",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label `",
"+",
"`FROM pg_catalog.pg_seclabel `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
",",
"provider",
")",
"\n",
"ps",
":=",
"PgSeclabel",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
",",
"provider",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Provider",
",",
"&",
"ps",
".",
"Label",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgSeclabelByObjoidClassoidObjsubidProvider retrieves a row from 'pg_catalog.pg_seclabel' as a PgSeclabel.
//
// Generated from index 'pg_seclabel_object_index'.
|
[
"PgSeclabelByObjoidClassoidObjsubidProvider",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_seclabel",
"as",
"a",
"PgSeclabel",
".",
"Generated",
"from",
"index",
"pg_seclabel_object_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43672-L43691
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdependsByDbidClassidObjidObjsubid
|
func PgShdependsByDbidClassidObjidObjsubid(db XODB, dbid pgtypes.Oid, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`
// run query
XOLog(sqlstr, dbid, classid, objid, objsubid)
q, err := db.Query(sqlstr, dbid, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
go
|
func PgShdependsByDbidClassidObjidObjsubid(db XODB, dbid pgtypes.Oid, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`
// run query
XOLog(sqlstr, dbid, classid, objid, objsubid)
q, err := db.Query(sqlstr, dbid, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
[
"func",
"PgShdependsByDbidClassidObjidObjsubid",
"(",
"db",
"XODB",
",",
"dbid",
"pgtypes",
".",
"Oid",
",",
"classid",
"pgtypes",
".",
"Oid",
",",
"objid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"[",
"]",
"*",
"PgShdepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `",
"+",
"`FROM pg_catalog.pg_shdepend `",
"+",
"`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dbid",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"dbid",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgShdepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ps",
":=",
"PgShdepend",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Dbid",
",",
"&",
"ps",
".",
"Classid",
",",
"&",
"ps",
".",
"Objid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Refclassid",
",",
"&",
"ps",
".",
"Refobjid",
",",
"&",
"ps",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ps",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgShdependsByDbidClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_depender_index'.
|
[
"PgShdependsByDbidClassidObjidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdepend",
"as",
"a",
"PgShdepend",
".",
"Generated",
"from",
"index",
"pg_shdepend_depender_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43696-L43728
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdependsByRefclassidRefobjid
|
func PgShdependsByRefclassidRefobjid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE refclassid = $1 AND refobjid = $2`
// run query
XOLog(sqlstr, refclassid, refobjid)
q, err := db.Query(sqlstr, refclassid, refobjid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
go
|
func PgShdependsByRefclassidRefobjid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE refclassid = $1 AND refobjid = $2`
// run query
XOLog(sqlstr, refclassid, refobjid)
q, err := db.Query(sqlstr, refclassid, refobjid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
[
"func",
"PgShdependsByRefclassidRefobjid",
"(",
"db",
"XODB",
",",
"refclassid",
"pgtypes",
".",
"Oid",
",",
"refobjid",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgShdepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `",
"+",
"`FROM pg_catalog.pg_shdepend `",
"+",
"`WHERE refclassid = $1 AND refobjid = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"refclassid",
",",
"refobjid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"refclassid",
",",
"refobjid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgShdepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ps",
":=",
"PgShdepend",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Dbid",
",",
"&",
"ps",
".",
"Classid",
",",
"&",
"ps",
".",
"Objid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Refclassid",
",",
"&",
"ps",
".",
"Refobjid",
",",
"&",
"ps",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ps",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgShdependsByRefclassidRefobjid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_reference_index'.
|
[
"PgShdependsByRefclassidRefobjid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdepend",
"as",
"a",
"PgShdepend",
".",
"Generated",
"from",
"index",
"pg_shdepend_reference_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43733-L43765
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdescriptionByObjoidClassoid
|
func PgShdescriptionByObjoidClassoid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid) (*PgShdescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description ` +
`FROM pg_catalog.pg_shdescription ` +
`WHERE objoid = $1 AND classoid = $2`
// run query
XOLog(sqlstr, objoid, classoid)
ps := PgShdescription{}
err = db.QueryRow(sqlstr, objoid, classoid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Description)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgShdescriptionByObjoidClassoid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid) (*PgShdescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description ` +
`FROM pg_catalog.pg_shdescription ` +
`WHERE objoid = $1 AND classoid = $2`
// run query
XOLog(sqlstr, objoid, classoid)
ps := PgShdescription{}
err = db.QueryRow(sqlstr, objoid, classoid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Description)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgShdescriptionByObjoidClassoid",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgShdescription",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description `",
"+",
"`FROM pg_catalog.pg_shdescription `",
"+",
"`WHERE objoid = $1 AND classoid = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
")",
"\n",
"ps",
":=",
"PgShdescription",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Description",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgShdescriptionByObjoidClassoid retrieves a row from 'pg_catalog.pg_shdescription' as a PgShdescription.
//
// Generated from index 'pg_shdescription_o_c_index'.
|
[
"PgShdescriptionByObjoidClassoid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdescription",
"as",
"a",
"PgShdescription",
".",
"Generated",
"from",
"index",
"pg_shdescription_o_c_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43770-L43789
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShseclabelByObjoidClassoidProvider
|
func PgShseclabelByObjoidClassoidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label ` +
`FROM pg_catalog.pg_shseclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND provider = $3`
// run query
XOLog(sqlstr, objoid, classoid, provider)
ps := PgShseclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgShseclabelByObjoidClassoidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label ` +
`FROM pg_catalog.pg_shseclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND provider = $3`
// run query
XOLog(sqlstr, objoid, classoid, provider)
ps := PgShseclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgShseclabelByObjoidClassoidProvider",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"provider",
"string",
")",
"(",
"*",
"PgShseclabel",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label `",
"+",
"`FROM pg_catalog.pg_shseclabel `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND provider = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"provider",
")",
"\n",
"ps",
":=",
"PgShseclabel",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"provider",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Provider",
",",
"&",
"ps",
".",
"Label",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgShseclabelByObjoidClassoidProvider retrieves a row from 'pg_catalog.pg_shseclabel' as a PgShseclabel.
//
// Generated from index 'pg_shseclabel_object_index'.
|
[
"PgShseclabelByObjoidClassoidProvider",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shseclabel",
"as",
"a",
"PgShseclabel",
".",
"Generated",
"from",
"index",
"pg_shseclabel_object_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43794-L43813
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgStatisticByStarelidStaattnumStainherit
|
func PgStatisticByStarelidStaattnumStainherit(db XODB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 ` +
`FROM pg_catalog.pg_statistic ` +
`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`
// run query
XOLog(sqlstr, starelid, staattnum, stainherit)
ps := PgStatistic{}
err = db.QueryRow(sqlstr, starelid, staattnum, stainherit).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Starelid, &ps.Staattnum, &ps.Stainherit, &ps.Stanullfrac, &ps.Stawidth, &ps.Stadistinct, &ps.Stakind1, &ps.Stakind2, &ps.Stakind3, &ps.Stakind4, &ps.Stakind5, &ps.Staop1, &ps.Staop2, &ps.Staop3, &ps.Staop4, &ps.Staop5, &ps.Stanumbers1, &ps.Stanumbers2, &ps.Stanumbers3, &ps.Stanumbers4, &ps.Stanumbers5, &ps.Stavalues1, &ps.Stavalues2, &ps.Stavalues3, &ps.Stavalues4, &ps.Stavalues5)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgStatisticByStarelidStaattnumStainherit(db XODB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 ` +
`FROM pg_catalog.pg_statistic ` +
`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`
// run query
XOLog(sqlstr, starelid, staattnum, stainherit)
ps := PgStatistic{}
err = db.QueryRow(sqlstr, starelid, staattnum, stainherit).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Starelid, &ps.Staattnum, &ps.Stainherit, &ps.Stanullfrac, &ps.Stawidth, &ps.Stadistinct, &ps.Stakind1, &ps.Stakind2, &ps.Stakind3, &ps.Stakind4, &ps.Stakind5, &ps.Staop1, &ps.Staop2, &ps.Staop3, &ps.Staop4, &ps.Staop5, &ps.Stanumbers1, &ps.Stanumbers2, &ps.Stanumbers3, &ps.Stanumbers4, &ps.Stanumbers5, &ps.Stavalues1, &ps.Stavalues2, &ps.Stavalues3, &ps.Stavalues4, &ps.Stavalues5)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgStatisticByStarelidStaattnumStainherit",
"(",
"db",
"XODB",
",",
"starelid",
"pgtypes",
".",
"Oid",
",",
"staattnum",
"int16",
",",
"stainherit",
"bool",
")",
"(",
"*",
"PgStatistic",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 `",
"+",
"`FROM pg_catalog.pg_statistic `",
"+",
"`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"starelid",
",",
"staattnum",
",",
"stainherit",
")",
"\n",
"ps",
":=",
"PgStatistic",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"starelid",
",",
"staattnum",
",",
"stainherit",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Starelid",
",",
"&",
"ps",
".",
"Staattnum",
",",
"&",
"ps",
".",
"Stainherit",
",",
"&",
"ps",
".",
"Stanullfrac",
",",
"&",
"ps",
".",
"Stawidth",
",",
"&",
"ps",
".",
"Stadistinct",
",",
"&",
"ps",
".",
"Stakind1",
",",
"&",
"ps",
".",
"Stakind2",
",",
"&",
"ps",
".",
"Stakind3",
",",
"&",
"ps",
".",
"Stakind4",
",",
"&",
"ps",
".",
"Stakind5",
",",
"&",
"ps",
".",
"Staop1",
",",
"&",
"ps",
".",
"Staop2",
",",
"&",
"ps",
".",
"Staop3",
",",
"&",
"ps",
".",
"Staop4",
",",
"&",
"ps",
".",
"Staop5",
",",
"&",
"ps",
".",
"Stanumbers1",
",",
"&",
"ps",
".",
"Stanumbers2",
",",
"&",
"ps",
".",
"Stanumbers3",
",",
"&",
"ps",
".",
"Stanumbers4",
",",
"&",
"ps",
".",
"Stanumbers5",
",",
"&",
"ps",
".",
"Stavalues1",
",",
"&",
"ps",
".",
"Stavalues2",
",",
"&",
"ps",
".",
"Stavalues3",
",",
"&",
"ps",
".",
"Stavalues4",
",",
"&",
"ps",
".",
"Stavalues5",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgStatisticByStarelidStaattnumStainherit retrieves a row from 'pg_catalog.pg_statistic' as a PgStatistic.
//
// Generated from index 'pg_statistic_relid_att_inh_index'.
|
[
"PgStatisticByStarelidStaattnumStainherit",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_statistic",
"as",
"a",
"PgStatistic",
".",
"Generated",
"from",
"index",
"pg_statistic_relid_att_inh_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43818-L43837
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTablespaceByOid
|
func PgTablespaceByOid(db XODB, oid pgtypes.Oid) (*PgTablespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions ` +
`FROM pg_catalog.pg_tablespace ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTablespace{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTablespaceByOid(db XODB, oid pgtypes.Oid) (*PgTablespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions ` +
`FROM pg_catalog.pg_tablespace ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTablespace{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTablespaceByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTablespace",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions `",
"+",
"`FROM pg_catalog.pg_tablespace `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTablespace",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Spcname",
",",
"&",
"pt",
".",
"Spcowner",
",",
"&",
"pt",
".",
"Spcacl",
",",
"&",
"pt",
".",
"Spcoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTablespaceByOid retrieves a row from 'pg_catalog.pg_tablespace' as a PgTablespace.
//
// Generated from index 'pg_tablespace_oid_index'.
|
[
"PgTablespaceByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_tablespace",
"as",
"a",
"PgTablespace",
".",
"Generated",
"from",
"index",
"pg_tablespace_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43842-L43861
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTransformByOid
|
func PgTransformByOid(db XODB, oid pgtypes.Oid) (*PgTransform, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql ` +
`FROM pg_catalog.pg_transform ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTransform{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTransformByOid(db XODB, oid pgtypes.Oid) (*PgTransform, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql ` +
`FROM pg_catalog.pg_transform ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTransform{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTransformByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTransform",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql `",
"+",
"`FROM pg_catalog.pg_transform `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTransform",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Trftype",
",",
"&",
"pt",
".",
"Trflang",
",",
"&",
"pt",
".",
"Trffromsql",
",",
"&",
"pt",
".",
"Trftosql",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTransformByOid retrieves a row from 'pg_catalog.pg_transform' as a PgTransform.
//
// Generated from index 'pg_transform_oid_index'.
|
[
"PgTransformByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_transform",
"as",
"a",
"PgTransform",
".",
"Generated",
"from",
"index",
"pg_transform_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43890-L43909
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTriggerByOid
|
func PgTriggerByOid(db XODB, oid pgtypes.Oid) (*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTrigger{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTriggerByOid(db XODB, oid pgtypes.Oid) (*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTrigger{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTriggerByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `",
"+",
"`FROM pg_catalog.pg_trigger `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTrigger",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Tgrelid",
",",
"&",
"pt",
".",
"Tgname",
",",
"&",
"pt",
".",
"Tgfoid",
",",
"&",
"pt",
".",
"Tgtype",
",",
"&",
"pt",
".",
"Tgenabled",
",",
"&",
"pt",
".",
"Tgisinternal",
",",
"&",
"pt",
".",
"Tgconstrrelid",
",",
"&",
"pt",
".",
"Tgconstrindid",
",",
"&",
"pt",
".",
"Tgconstraint",
",",
"&",
"pt",
".",
"Tgdeferrable",
",",
"&",
"pt",
".",
"Tginitdeferred",
",",
"&",
"pt",
".",
"Tgnargs",
",",
"&",
"pt",
".",
"Tgattr",
",",
"&",
"pt",
".",
"Tgargs",
",",
"&",
"pt",
".",
"Tgqual",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTriggerByOid retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_oid_index'.
|
[
"PgTriggerByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_trigger",
"as",
"a",
"PgTrigger",
".",
"Generated",
"from",
"index",
"pg_trigger_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43938-L43957
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTriggersByTgconstraint
|
func PgTriggersByTgconstraint(db XODB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE tgconstraint = $1`
// run query
XOLog(sqlstr, tgconstraint)
q, err := db.Query(sqlstr, tgconstraint)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgTrigger{}
for q.Next() {
pt := PgTrigger{}
// scan
err = q.Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
res = append(res, &pt)
}
return res, nil
}
|
go
|
func PgTriggersByTgconstraint(db XODB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE tgconstraint = $1`
// run query
XOLog(sqlstr, tgconstraint)
q, err := db.Query(sqlstr, tgconstraint)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgTrigger{}
for q.Next() {
pt := PgTrigger{}
// scan
err = q.Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
res = append(res, &pt)
}
return res, nil
}
|
[
"func",
"PgTriggersByTgconstraint",
"(",
"db",
"XODB",
",",
"tgconstraint",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `",
"+",
"`FROM pg_catalog.pg_trigger `",
"+",
"`WHERE tgconstraint = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"tgconstraint",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"tgconstraint",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgTrigger",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pt",
":=",
"PgTrigger",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Tgrelid",
",",
"&",
"pt",
".",
"Tgname",
",",
"&",
"pt",
".",
"Tgfoid",
",",
"&",
"pt",
".",
"Tgtype",
",",
"&",
"pt",
".",
"Tgenabled",
",",
"&",
"pt",
".",
"Tgisinternal",
",",
"&",
"pt",
".",
"Tgconstrrelid",
",",
"&",
"pt",
".",
"Tgconstrindid",
",",
"&",
"pt",
".",
"Tgconstraint",
",",
"&",
"pt",
".",
"Tgdeferrable",
",",
"&",
"pt",
".",
"Tginitdeferred",
",",
"&",
"pt",
".",
"Tgnargs",
",",
"&",
"pt",
".",
"Tgattr",
",",
"&",
"pt",
".",
"Tgargs",
",",
"&",
"pt",
".",
"Tgqual",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pt",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgTriggersByTgconstraint retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_tgconstraint_index'.
|
[
"PgTriggersByTgconstraint",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_trigger",
"as",
"a",
"PgTrigger",
".",
"Generated",
"from",
"index",
"pg_trigger_tgconstraint_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43962-L43994
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigByCfgnameCfgnamespace
|
func PgTsConfigByCfgnameCfgnamespace(db XODB, cfgname pgtypes.Name, cfgnamespace pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE cfgname = $1 AND cfgnamespace = $2`
// run query
XOLog(sqlstr, cfgname, cfgnamespace)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, cfgname, cfgnamespace).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
go
|
func PgTsConfigByCfgnameCfgnamespace(db XODB, cfgname pgtypes.Name, cfgnamespace pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE cfgname = $1 AND cfgnamespace = $2`
// run query
XOLog(sqlstr, cfgname, cfgnamespace)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, cfgname, cfgnamespace).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
[
"func",
"PgTsConfigByCfgnameCfgnamespace",
"(",
"db",
"XODB",
",",
"cfgname",
"pgtypes",
".",
"Name",
",",
"cfgnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `",
"+",
"`FROM pg_catalog.pg_ts_config `",
"+",
"`WHERE cfgname = $1 AND cfgnamespace = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"cfgname",
",",
"cfgnamespace",
")",
"\n",
"ptc",
":=",
"PgTsConfig",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"cfgname",
",",
"cfgnamespace",
")",
".",
"Scan",
"(",
"&",
"ptc",
".",
"Tableoid",
",",
"&",
"ptc",
".",
"Cmax",
",",
"&",
"ptc",
".",
"Xmax",
",",
"&",
"ptc",
".",
"Cmin",
",",
"&",
"ptc",
".",
"Xmin",
",",
"&",
"ptc",
".",
"Oid",
",",
"&",
"ptc",
".",
"Ctid",
",",
"&",
"ptc",
".",
"Cfgname",
",",
"&",
"ptc",
".",
"Cfgnamespace",
",",
"&",
"ptc",
".",
"Cfgowner",
",",
"&",
"ptc",
".",
"Cfgparser",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptc",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigByCfgnameCfgnamespace retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_cfgname_index'.
|
[
"PgTsConfigByCfgnameCfgnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config",
"as",
"a",
"PgTsConfig",
".",
"Generated",
"from",
"index",
"pg_ts_config_cfgname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44023-L44042
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigByOid
|
func PgTsConfigByOid(db XODB, oid pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, oid).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
go
|
func PgTsConfigByOid(db XODB, oid pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, oid).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
[
"func",
"PgTsConfigByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `",
"+",
"`FROM pg_catalog.pg_ts_config `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptc",
":=",
"PgTsConfig",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptc",
".",
"Tableoid",
",",
"&",
"ptc",
".",
"Cmax",
",",
"&",
"ptc",
".",
"Xmax",
",",
"&",
"ptc",
".",
"Cmin",
",",
"&",
"ptc",
".",
"Xmin",
",",
"&",
"ptc",
".",
"Oid",
",",
"&",
"ptc",
".",
"Ctid",
",",
"&",
"ptc",
".",
"Cfgname",
",",
"&",
"ptc",
".",
"Cfgnamespace",
",",
"&",
"ptc",
".",
"Cfgowner",
",",
"&",
"ptc",
".",
"Cfgparser",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptc",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigByOid retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_oid_index'.
|
[
"PgTsConfigByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config",
"as",
"a",
"PgTsConfig",
".",
"Generated",
"from",
"index",
"pg_ts_config_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44047-L44066
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigMapByMapcfgMaptokentypeMapseqno
|
func PgTsConfigMapByMapcfgMaptokentypeMapseqno(db XODB, mapcfg pgtypes.Oid, maptokentype int, mapseqno int) (*PgTsConfigMap, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict ` +
`FROM pg_catalog.pg_ts_config_map ` +
`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`
// run query
XOLog(sqlstr, mapcfg, maptokentype, mapseqno)
ptcm := PgTsConfigMap{}
err = db.QueryRow(sqlstr, mapcfg, maptokentype, mapseqno).Scan(&ptcm.Tableoid, &ptcm.Cmax, &ptcm.Xmax, &ptcm.Cmin, &ptcm.Xmin, &ptcm.Ctid, &ptcm.Mapcfg, &ptcm.Maptokentype, &ptcm.Mapseqno, &ptcm.Mapdict)
if err != nil {
return nil, err
}
return &ptcm, nil
}
|
go
|
func PgTsConfigMapByMapcfgMaptokentypeMapseqno(db XODB, mapcfg pgtypes.Oid, maptokentype int, mapseqno int) (*PgTsConfigMap, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict ` +
`FROM pg_catalog.pg_ts_config_map ` +
`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`
// run query
XOLog(sqlstr, mapcfg, maptokentype, mapseqno)
ptcm := PgTsConfigMap{}
err = db.QueryRow(sqlstr, mapcfg, maptokentype, mapseqno).Scan(&ptcm.Tableoid, &ptcm.Cmax, &ptcm.Xmax, &ptcm.Cmin, &ptcm.Xmin, &ptcm.Ctid, &ptcm.Mapcfg, &ptcm.Maptokentype, &ptcm.Mapseqno, &ptcm.Mapdict)
if err != nil {
return nil, err
}
return &ptcm, nil
}
|
[
"func",
"PgTsConfigMapByMapcfgMaptokentypeMapseqno",
"(",
"db",
"XODB",
",",
"mapcfg",
"pgtypes",
".",
"Oid",
",",
"maptokentype",
"int",
",",
"mapseqno",
"int",
")",
"(",
"*",
"PgTsConfigMap",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict `",
"+",
"`FROM pg_catalog.pg_ts_config_map `",
"+",
"`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"mapcfg",
",",
"maptokentype",
",",
"mapseqno",
")",
"\n",
"ptcm",
":=",
"PgTsConfigMap",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"mapcfg",
",",
"maptokentype",
",",
"mapseqno",
")",
".",
"Scan",
"(",
"&",
"ptcm",
".",
"Tableoid",
",",
"&",
"ptcm",
".",
"Cmax",
",",
"&",
"ptcm",
".",
"Xmax",
",",
"&",
"ptcm",
".",
"Cmin",
",",
"&",
"ptcm",
".",
"Xmin",
",",
"&",
"ptcm",
".",
"Ctid",
",",
"&",
"ptcm",
".",
"Mapcfg",
",",
"&",
"ptcm",
".",
"Maptokentype",
",",
"&",
"ptcm",
".",
"Mapseqno",
",",
"&",
"ptcm",
".",
"Mapdict",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptcm",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigMapByMapcfgMaptokentypeMapseqno retrieves a row from 'pg_catalog.pg_ts_config_map' as a PgTsConfigMap.
//
// Generated from index 'pg_ts_config_map_index'.
|
[
"PgTsConfigMapByMapcfgMaptokentypeMapseqno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config_map",
"as",
"a",
"PgTsConfigMap",
".",
"Generated",
"from",
"index",
"pg_ts_config_map_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44071-L44090
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsDictByDictnameDictnamespace
|
func PgTsDictByDictnameDictnamespace(db XODB, dictname pgtypes.Name, dictnamespace pgtypes.Oid) (*PgTsDict, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
`FROM pg_catalog.pg_ts_dict ` +
`WHERE dictname = $1 AND dictnamespace = $2`
// run query
XOLog(sqlstr, dictname, dictnamespace)
ptd := PgTsDict{}
err = db.QueryRow(sqlstr, dictname, dictnamespace).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Oid, &ptd.Ctid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption)
if err != nil {
return nil, err
}
return &ptd, nil
}
|
go
|
func PgTsDictByDictnameDictnamespace(db XODB, dictname pgtypes.Name, dictnamespace pgtypes.Oid) (*PgTsDict, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
`FROM pg_catalog.pg_ts_dict ` +
`WHERE dictname = $1 AND dictnamespace = $2`
// run query
XOLog(sqlstr, dictname, dictnamespace)
ptd := PgTsDict{}
err = db.QueryRow(sqlstr, dictname, dictnamespace).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Oid, &ptd.Ctid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption)
if err != nil {
return nil, err
}
return &ptd, nil
}
|
[
"func",
"PgTsDictByDictnameDictnamespace",
"(",
"db",
"XODB",
",",
"dictname",
"pgtypes",
".",
"Name",
",",
"dictnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsDict",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption `",
"+",
"`FROM pg_catalog.pg_ts_dict `",
"+",
"`WHERE dictname = $1 AND dictnamespace = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"dictname",
",",
"dictnamespace",
")",
"\n",
"ptd",
":=",
"PgTsDict",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"dictname",
",",
"dictnamespace",
")",
".",
"Scan",
"(",
"&",
"ptd",
".",
"Tableoid",
",",
"&",
"ptd",
".",
"Cmax",
",",
"&",
"ptd",
".",
"Xmax",
",",
"&",
"ptd",
".",
"Cmin",
",",
"&",
"ptd",
".",
"Xmin",
",",
"&",
"ptd",
".",
"Oid",
",",
"&",
"ptd",
".",
"Ctid",
",",
"&",
"ptd",
".",
"Dictname",
",",
"&",
"ptd",
".",
"Dictnamespace",
",",
"&",
"ptd",
".",
"Dictowner",
",",
"&",
"ptd",
".",
"Dicttemplate",
",",
"&",
"ptd",
".",
"Dictinitoption",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptd",
",",
"nil",
"\n",
"}"
] |
// PgTsDictByDictnameDictnamespace retrieves a row from 'pg_catalog.pg_ts_dict' as a PgTsDict.
//
// Generated from index 'pg_ts_dict_dictname_index'.
|
[
"PgTsDictByDictnameDictnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_dict",
"as",
"a",
"PgTsDict",
".",
"Generated",
"from",
"index",
"pg_ts_dict_dictname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44095-L44114
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsParserByOid
|
func PgTsParserByOid(db XODB, oid pgtypes.Oid) (*PgTsParser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
`FROM pg_catalog.pg_ts_parser ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptp := PgTsParser{}
err = db.QueryRow(sqlstr, oid).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Oid, &ptp.Ctid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype)
if err != nil {
return nil, err
}
return &ptp, nil
}
|
go
|
func PgTsParserByOid(db XODB, oid pgtypes.Oid) (*PgTsParser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
`FROM pg_catalog.pg_ts_parser ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptp := PgTsParser{}
err = db.QueryRow(sqlstr, oid).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Oid, &ptp.Ctid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype)
if err != nil {
return nil, err
}
return &ptp, nil
}
|
[
"func",
"PgTsParserByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsParser",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype `",
"+",
"`FROM pg_catalog.pg_ts_parser `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptp",
":=",
"PgTsParser",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptp",
".",
"Tableoid",
",",
"&",
"ptp",
".",
"Cmax",
",",
"&",
"ptp",
".",
"Xmax",
",",
"&",
"ptp",
".",
"Cmin",
",",
"&",
"ptp",
".",
"Xmin",
",",
"&",
"ptp",
".",
"Oid",
",",
"&",
"ptp",
".",
"Ctid",
",",
"&",
"ptp",
".",
"Prsname",
",",
"&",
"ptp",
".",
"Prsnamespace",
",",
"&",
"ptp",
".",
"Prsstart",
",",
"&",
"ptp",
".",
"Prstoken",
",",
"&",
"ptp",
".",
"Prsend",
",",
"&",
"ptp",
".",
"Prsheadline",
",",
"&",
"ptp",
".",
"Prslextype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptp",
",",
"nil",
"\n",
"}"
] |
// PgTsParserByOid retrieves a row from 'pg_catalog.pg_ts_parser' as a PgTsParser.
//
// Generated from index 'pg_ts_parser_oid_index'.
|
[
"PgTsParserByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_parser",
"as",
"a",
"PgTsParser",
".",
"Generated",
"from",
"index",
"pg_ts_parser_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44143-L44162
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsTemplateByOid
|
func PgTsTemplateByOid(db XODB, oid pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, oid).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
go
|
func PgTsTemplateByOid(db XODB, oid pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, oid).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
[
"func",
"PgTsTemplateByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsTemplate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize `",
"+",
"`FROM pg_catalog.pg_ts_template `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptt",
":=",
"PgTsTemplate",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptt",
".",
"Tableoid",
",",
"&",
"ptt",
".",
"Cmax",
",",
"&",
"ptt",
".",
"Xmax",
",",
"&",
"ptt",
".",
"Cmin",
",",
"&",
"ptt",
".",
"Xmin",
",",
"&",
"ptt",
".",
"Oid",
",",
"&",
"ptt",
".",
"Ctid",
",",
"&",
"ptt",
".",
"Tmplname",
",",
"&",
"ptt",
".",
"Tmplnamespace",
",",
"&",
"ptt",
".",
"Tmplinit",
",",
"&",
"ptt",
".",
"Tmpllexize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptt",
",",
"nil",
"\n",
"}"
] |
// PgTsTemplateByOid retrieves a row from 'pg_catalog.pg_ts_template' as a PgTsTemplate.
//
// Generated from index 'pg_ts_template_oid_index'.
|
[
"PgTsTemplateByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_template",
"as",
"a",
"PgTsTemplate",
".",
"Generated",
"from",
"index",
"pg_ts_template_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44191-L44210
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsTemplateByTmplnameTmplnamespace
|
func PgTsTemplateByTmplnameTmplnamespace(db XODB, tmplname pgtypes.Name, tmplnamespace pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE tmplname = $1 AND tmplnamespace = $2`
// run query
XOLog(sqlstr, tmplname, tmplnamespace)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, tmplname, tmplnamespace).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
go
|
func PgTsTemplateByTmplnameTmplnamespace(db XODB, tmplname pgtypes.Name, tmplnamespace pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE tmplname = $1 AND tmplnamespace = $2`
// run query
XOLog(sqlstr, tmplname, tmplnamespace)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, tmplname, tmplnamespace).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
[
"func",
"PgTsTemplateByTmplnameTmplnamespace",
"(",
"db",
"XODB",
",",
"tmplname",
"pgtypes",
".",
"Name",
",",
"tmplnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsTemplate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize `",
"+",
"`FROM pg_catalog.pg_ts_template `",
"+",
"`WHERE tmplname = $1 AND tmplnamespace = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"tmplname",
",",
"tmplnamespace",
")",
"\n",
"ptt",
":=",
"PgTsTemplate",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"tmplname",
",",
"tmplnamespace",
")",
".",
"Scan",
"(",
"&",
"ptt",
".",
"Tableoid",
",",
"&",
"ptt",
".",
"Cmax",
",",
"&",
"ptt",
".",
"Xmax",
",",
"&",
"ptt",
".",
"Cmin",
",",
"&",
"ptt",
".",
"Xmin",
",",
"&",
"ptt",
".",
"Oid",
",",
"&",
"ptt",
".",
"Ctid",
",",
"&",
"ptt",
".",
"Tmplname",
",",
"&",
"ptt",
".",
"Tmplnamespace",
",",
"&",
"ptt",
".",
"Tmplinit",
",",
"&",
"ptt",
".",
"Tmpllexize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ptt",
",",
"nil",
"\n",
"}"
] |
// PgTsTemplateByTmplnameTmplnamespace retrieves a row from 'pg_catalog.pg_ts_template' as a PgTsTemplate.
//
// Generated from index 'pg_ts_template_tmplname_index'.
|
[
"PgTsTemplateByTmplnameTmplnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_template",
"as",
"a",
"PgTsTemplate",
".",
"Generated",
"from",
"index",
"pg_ts_template_tmplname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44215-L44234
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTypeByOid
|
func PgTypeByOid(db XODB, oid pgtypes.Oid) (*PgType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl ` +
`FROM pg_catalog.pg_type ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgType{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Typname, &pt.Typnamespace, &pt.Typowner, &pt.Typlen, &pt.Typbyval, &pt.Typtype, &pt.Typcategory, &pt.Typispreferred, &pt.Typisdefined, &pt.Typdelim, &pt.Typrelid, &pt.Typelem, &pt.Typarray, &pt.Typinput, &pt.Typoutput, &pt.Typreceive, &pt.Typsend, &pt.Typmodin, &pt.Typmodout, &pt.Typanalyze, &pt.Typalign, &pt.Typstorage, &pt.Typnotnull, &pt.Typbasetype, &pt.Typtypmod, &pt.Typndims, &pt.Typcollation, &pt.Typdefaultbin, &pt.Typdefault, &pt.Typacl)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTypeByOid(db XODB, oid pgtypes.Oid) (*PgType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl ` +
`FROM pg_catalog.pg_type ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgType{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Typname, &pt.Typnamespace, &pt.Typowner, &pt.Typlen, &pt.Typbyval, &pt.Typtype, &pt.Typcategory, &pt.Typispreferred, &pt.Typisdefined, &pt.Typdelim, &pt.Typrelid, &pt.Typelem, &pt.Typarray, &pt.Typinput, &pt.Typoutput, &pt.Typreceive, &pt.Typsend, &pt.Typmodin, &pt.Typmodout, &pt.Typanalyze, &pt.Typalign, &pt.Typstorage, &pt.Typnotnull, &pt.Typbasetype, &pt.Typtypmod, &pt.Typndims, &pt.Typcollation, &pt.Typdefaultbin, &pt.Typdefault, &pt.Typacl)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTypeByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgType",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl `",
"+",
"`FROM pg_catalog.pg_type `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgType",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Typname",
",",
"&",
"pt",
".",
"Typnamespace",
",",
"&",
"pt",
".",
"Typowner",
",",
"&",
"pt",
".",
"Typlen",
",",
"&",
"pt",
".",
"Typbyval",
",",
"&",
"pt",
".",
"Typtype",
",",
"&",
"pt",
".",
"Typcategory",
",",
"&",
"pt",
".",
"Typispreferred",
",",
"&",
"pt",
".",
"Typisdefined",
",",
"&",
"pt",
".",
"Typdelim",
",",
"&",
"pt",
".",
"Typrelid",
",",
"&",
"pt",
".",
"Typelem",
",",
"&",
"pt",
".",
"Typarray",
",",
"&",
"pt",
".",
"Typinput",
",",
"&",
"pt",
".",
"Typoutput",
",",
"&",
"pt",
".",
"Typreceive",
",",
"&",
"pt",
".",
"Typsend",
",",
"&",
"pt",
".",
"Typmodin",
",",
"&",
"pt",
".",
"Typmodout",
",",
"&",
"pt",
".",
"Typanalyze",
",",
"&",
"pt",
".",
"Typalign",
",",
"&",
"pt",
".",
"Typstorage",
",",
"&",
"pt",
".",
"Typnotnull",
",",
"&",
"pt",
".",
"Typbasetype",
",",
"&",
"pt",
".",
"Typtypmod",
",",
"&",
"pt",
".",
"Typndims",
",",
"&",
"pt",
".",
"Typcollation",
",",
"&",
"pt",
".",
"Typdefaultbin",
",",
"&",
"pt",
".",
"Typdefault",
",",
"&",
"pt",
".",
"Typacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTypeByOid retrieves a row from 'pg_catalog.pg_type' as a PgType.
//
// Generated from index 'pg_type_oid_index'.
|
[
"PgTypeByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_type",
"as",
"a",
"PgType",
".",
"Generated",
"from",
"index",
"pg_type_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44239-L44258
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgUserMappingByOid
|
func PgUserMappingByOid(db XODB, oid pgtypes.Oid) (*PgUserMapping, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, umuser, umserver, umoptions ` +
`FROM pg_catalog.pg_user_mapping ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pum := PgUserMapping{}
err = db.QueryRow(sqlstr, oid).Scan(&pum.Tableoid, &pum.Cmax, &pum.Xmax, &pum.Cmin, &pum.Xmin, &pum.Oid, &pum.Ctid, &pum.Umuser, &pum.Umserver, &pum.Umoptions)
if err != nil {
return nil, err
}
return &pum, nil
}
|
go
|
func PgUserMappingByOid(db XODB, oid pgtypes.Oid) (*PgUserMapping, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, umuser, umserver, umoptions ` +
`FROM pg_catalog.pg_user_mapping ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pum := PgUserMapping{}
err = db.QueryRow(sqlstr, oid).Scan(&pum.Tableoid, &pum.Cmax, &pum.Xmax, &pum.Cmin, &pum.Xmin, &pum.Oid, &pum.Ctid, &pum.Umuser, &pum.Umserver, &pum.Umoptions)
if err != nil {
return nil, err
}
return &pum, nil
}
|
[
"func",
"PgUserMappingByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgUserMapping",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, umuser, umserver, umoptions `",
"+",
"`FROM pg_catalog.pg_user_mapping `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pum",
":=",
"PgUserMapping",
"{",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pum",
".",
"Tableoid",
",",
"&",
"pum",
".",
"Cmax",
",",
"&",
"pum",
".",
"Xmax",
",",
"&",
"pum",
".",
"Cmin",
",",
"&",
"pum",
".",
"Xmin",
",",
"&",
"pum",
".",
"Oid",
",",
"&",
"pum",
".",
"Ctid",
",",
"&",
"pum",
".",
"Umuser",
",",
"&",
"pum",
".",
"Umserver",
",",
"&",
"pum",
".",
"Umoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pum",
",",
"nil",
"\n",
"}"
] |
// PgUserMappingByOid retrieves a row from 'pg_catalog.pg_user_mapping' as a PgUserMapping.
//
// Generated from index 'pg_user_mapping_oid_index'.
|
[
"PgUserMappingByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_user_mapping",
"as",
"a",
"PgUserMapping",
".",
"Generated",
"from",
"index",
"pg_user_mapping_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44287-L44306
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
Scan
|
func (ss *StringSlice) Scan(src interface{}) error {
buf, ok := src.([]byte)
if !ok {
return errors.New("invalid StringSlice")
}
// change quote escapes for csv parser
str := quoteEscapeRegex.ReplaceAllString(string(buf), `$1""`)
str = strings.Replace(str, `\\`, `\`, -1)
// remove braces
str = str[1 : len(str)-1]
// bail if only one
if len(str) == 0 {
*ss = StringSlice([]string{})
return nil
}
// parse with csv reader
cr := csv.NewReader(strings.NewReader(str))
slice, err := cr.Read()
if err != nil {
fmt.Printf("exiting!: %v\n", err)
return err
}
*ss = StringSlice(slice)
return nil
}
|
go
|
func (ss *StringSlice) Scan(src interface{}) error {
buf, ok := src.([]byte)
if !ok {
return errors.New("invalid StringSlice")
}
// change quote escapes for csv parser
str := quoteEscapeRegex.ReplaceAllString(string(buf), `$1""`)
str = strings.Replace(str, `\\`, `\`, -1)
// remove braces
str = str[1 : len(str)-1]
// bail if only one
if len(str) == 0 {
*ss = StringSlice([]string{})
return nil
}
// parse with csv reader
cr := csv.NewReader(strings.NewReader(str))
slice, err := cr.Read()
if err != nil {
fmt.Printf("exiting!: %v\n", err)
return err
}
*ss = StringSlice(slice)
return nil
}
|
[
"func",
"(",
"ss",
"*",
"StringSlice",
")",
"Scan",
"(",
"src",
"interface",
"{",
"}",
")",
"error",
"{",
"buf",
",",
"ok",
":=",
"src",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"invalid StringSlice\"",
")",
"\n",
"}",
"\n",
"str",
":=",
"quoteEscapeRegex",
".",
"ReplaceAllString",
"(",
"string",
"(",
"buf",
")",
",",
"`$1\"\"`",
")",
"\n",
"str",
"=",
"strings",
".",
"Replace",
"(",
"str",
",",
"`\\\\`",
",",
"`\\`",
",",
"-",
"1",
")",
"\n",
"str",
"=",
"str",
"[",
"1",
":",
"len",
"(",
"str",
")",
"-",
"1",
"]",
"\n",
"if",
"len",
"(",
"str",
")",
"==",
"0",
"{",
"*",
"ss",
"=",
"StringSlice",
"(",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"cr",
":=",
"csv",
".",
"NewReader",
"(",
"strings",
".",
"NewReader",
"(",
"str",
")",
")",
"\n",
"slice",
",",
"err",
":=",
"cr",
".",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"exiting!: %v\\n\"",
",",
"\\n",
")",
"\n",
"err",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"*",
"ss",
"=",
"StringSlice",
"(",
"slice",
")",
"\n",
"}"
] |
// Scan satisfies the sql.Scanner interface for StringSlice.
|
[
"Scan",
"satisfies",
"the",
"sql",
".",
"Scanner",
"interface",
"for",
"StringSlice",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44359-L44389
|
train
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
Value
|
func (ss StringSlice) Value() (driver.Value, error) {
v := make([]string, len(ss))
for i, s := range ss {
v[i] = `"` + strings.Replace(strings.Replace(s, `\`, `\\\`, -1), `"`, `\"`, -1) + `"`
}
return "{" + strings.Join(v, ",") + "}", nil
}
|
go
|
func (ss StringSlice) Value() (driver.Value, error) {
v := make([]string, len(ss))
for i, s := range ss {
v[i] = `"` + strings.Replace(strings.Replace(s, `\`, `\\\`, -1), `"`, `\"`, -1) + `"`
}
return "{" + strings.Join(v, ",") + "}", nil
}
|
[
"func",
"(",
"ss",
"StringSlice",
")",
"Value",
"(",
")",
"(",
"driver",
".",
"Value",
",",
"error",
")",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"ss",
")",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"ss",
"{",
"v",
"[",
"i",
"]",
"=",
"`\"`",
"+",
"strings",
".",
"Replace",
"(",
"strings",
".",
"Replace",
"(",
"s",
",",
"`\\`",
",",
"`\\\\\\`",
",",
"-",
"1",
")",
",",
"`\"`",
",",
"`\\\"`",
",",
"-",
"1",
")",
"+",
"`\"`",
"\n",
"}",
"\n",
"return",
"\"{\"",
"+",
"strings",
".",
"Join",
"(",
"v",
",",
"\",\"",
")",
"+",
"\"}\"",
",",
"nil",
"\n",
"}"
] |
// Value satisfies the driver.Valuer interface for StringSlice.
|
[
"Value",
"satisfies",
"the",
"driver",
".",
"Valuer",
"interface",
"for",
"StringSlice",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44392-L44398
|
train
|
xo/xo
|
examples/django/mysql/djangocontenttype.xo.go
|
Save
|
func (dct *DjangoContentType) Save(db XODB) error {
if dct.Exists() {
return dct.Update(db)
}
return dct.Insert(db)
}
|
go
|
func (dct *DjangoContentType) Save(db XODB) error {
if dct.Exists() {
return dct.Update(db)
}
return dct.Insert(db)
}
|
[
"func",
"(",
"dct",
"*",
"DjangoContentType",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"dct",
".",
"Exists",
"(",
")",
"{",
"return",
"dct",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"dct",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the DjangoContentType to the database.
|
[
"Save",
"saves",
"the",
"DjangoContentType",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangocontenttype.xo.go#L92-L98
|
train
|
xo/xo
|
examples/django/mysql/djangocontenttype.xo.go
|
DjangoContentTypeByAppLabelModel
|
func DjangoContentTypeByAppLabelModel(db XODB, appLabel string, model string) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django.django_content_type ` +
`WHERE app_label = ? AND model = ?`
// run query
XOLog(sqlstr, appLabel, model)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, appLabel, model).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
}
|
go
|
func DjangoContentTypeByAppLabelModel(db XODB, appLabel string, model string) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django.django_content_type ` +
`WHERE app_label = ? AND model = ?`
// run query
XOLog(sqlstr, appLabel, model)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, appLabel, model).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
}
|
[
"func",
"DjangoContentTypeByAppLabelModel",
"(",
"db",
"XODB",
",",
"appLabel",
"string",
",",
"model",
"string",
")",
"(",
"*",
"DjangoContentType",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, app_label, model `",
"+",
"`FROM django.django_content_type `",
"+",
"`WHERE app_label = ? AND model = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"appLabel",
",",
"model",
")",
"\n",
"dct",
":=",
"DjangoContentType",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"appLabel",
",",
"model",
")",
".",
"Scan",
"(",
"&",
"dct",
".",
"ID",
",",
"&",
"dct",
".",
"AppLabel",
",",
"&",
"dct",
".",
"Model",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"dct",
",",
"nil",
"\n",
"}"
] |
// DjangoContentTypeByAppLabelModel retrieves a row from 'django.django_content_type' as a DjangoContentType.
//
// Generated from index 'django_content_type_app_label_76bd3d3b_uniq'.
|
[
"DjangoContentTypeByAppLabelModel",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_content_type",
"as",
"a",
"DjangoContentType",
".",
"Generated",
"from",
"index",
"django_content_type_app_label_76bd3d3b_uniq",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangocontenttype.xo.go#L133-L154
|
train
|
xo/xo
|
examples/django/mysql/authgroup.xo.go
|
Save
|
func (ag *AuthGroup) Save(db XODB) error {
if ag.Exists() {
return ag.Update(db)
}
return ag.Insert(db)
}
|
go
|
func (ag *AuthGroup) Save(db XODB) error {
if ag.Exists() {
return ag.Update(db)
}
return ag.Insert(db)
}
|
[
"func",
"(",
"ag",
"*",
"AuthGroup",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"ag",
".",
"Exists",
"(",
")",
"{",
"return",
"ag",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"ag",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthGroup to the database.
|
[
"Save",
"saves",
"the",
"AuthGroup",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authgroup.xo.go#L91-L97
|
train
|
xo/xo
|
examples/django/mysql/authgroup.xo.go
|
AuthGroupByID
|
func AuthGroupByID(db XODB, id int) (*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM django.auth_group ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
ag := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
}
|
go
|
func AuthGroupByID(db XODB, id int) (*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM django.auth_group ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
ag := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
}
|
[
"func",
"AuthGroupByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name `",
"+",
"`FROM django.auth_group `",
"+",
"`WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"ag",
":=",
"AuthGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"ag",
".",
"ID",
",",
"&",
"ag",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ag",
",",
"nil",
"\n",
"}"
] |
// AuthGroupByID retrieves a row from 'django.auth_group' as a AuthGroup.
//
// Generated from index 'auth_group_id_pkey'.
|
[
"AuthGroupByID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_group",
"as",
"a",
"AuthGroup",
".",
"Generated",
"from",
"index",
"auth_group_id_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authgroup.xo.go#L132-L153
|
train
|
xo/xo
|
examples/django/oracle/djangosession.xo.go
|
Save
|
func (ds *DjangoSession) Save(db XODB) error {
if ds.Exists() {
return ds.Update(db)
}
return ds.Insert(db)
}
|
go
|
func (ds *DjangoSession) Save(db XODB) error {
if ds.Exists() {
return ds.Update(db)
}
return ds.Insert(db)
}
|
[
"func",
"(",
"ds",
"*",
"DjangoSession",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"ds",
".",
"Exists",
"(",
")",
"{",
"return",
"ds",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"ds",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the DjangoSession to the database.
|
[
"Save",
"saves",
"the",
"DjangoSession",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangosession.xo.go#L94-L100
|
train
|
xo/xo
|
examples/django/oracle/djangosession.xo.go
|
Delete
|
func (ds *DjangoSession) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ds._exists {
return nil
}
// if deleted, bail
if ds._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_session WHERE session_key = :1`
// run query
XOLog(sqlstr, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionKey)
if err != nil {
return err
}
// set deleted
ds._deleted = true
return nil
}
|
go
|
func (ds *DjangoSession) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ds._exists {
return nil
}
// if deleted, bail
if ds._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_session WHERE session_key = :1`
// run query
XOLog(sqlstr, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionKey)
if err != nil {
return err
}
// set deleted
ds._deleted = true
return nil
}
|
[
"func",
"(",
"ds",
"*",
"DjangoSession",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ds",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"ds",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM django.django_session WHERE session_key = :1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ds",
".",
"SessionKey",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ds",
".",
"SessionKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ds",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the DjangoSession from the database.
|
[
"Delete",
"deletes",
"the",
"DjangoSession",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangosession.xo.go#L103-L130
|
train
|
xo/xo
|
examples/django/oracle/authpermission.xo.go
|
Save
|
func (ap *AuthPermission) Save(db XODB) error {
if ap.Exists() {
return ap.Update(db)
}
return ap.Insert(db)
}
|
go
|
func (ap *AuthPermission) Save(db XODB) error {
if ap.Exists() {
return ap.Update(db)
}
return ap.Insert(db)
}
|
[
"func",
"(",
"ap",
"*",
"AuthPermission",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"ap",
".",
"Exists",
"(",
")",
"{",
"return",
"ap",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"ap",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthPermission to the database.
|
[
"Save",
"saves",
"the",
"AuthPermission",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authpermission.xo.go#L94-L100
|
train
|
xo/xo
|
examples/django/oracle/authpermission.xo.go
|
AuthPermissionsByContentTypeID
|
func AuthPermissionsByContentTypeID(db XODB, contentTypeID float64) ([]*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM django.auth_permission ` +
`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 := []*AuthPermission{}
for q.Next() {
ap := AuthPermission{
_exists: true,
}
// scan
err = q.Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
res = append(res, &ap)
}
return res, nil
}
|
go
|
func AuthPermissionsByContentTypeID(db XODB, contentTypeID float64) ([]*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM django.auth_permission ` +
`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 := []*AuthPermission{}
for q.Next() {
ap := AuthPermission{
_exists: true,
}
// scan
err = q.Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
res = append(res, &ap)
}
return res, nil
}
|
[
"func",
"AuthPermissionsByContentTypeID",
"(",
"db",
"XODB",
",",
"contentTypeID",
"float64",
")",
"(",
"[",
"]",
"*",
"AuthPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name, content_type_id, codename `",
"+",
"`FROM django.auth_permission `",
"+",
"`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",
":=",
"[",
"]",
"*",
"AuthPermission",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ap",
":=",
"AuthPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ap",
".",
"ID",
",",
"&",
"ap",
".",
"Name",
",",
"&",
"ap",
".",
"ContentTypeID",
",",
"&",
"ap",
".",
"Codename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ap",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthPermissionsByContentTypeID retrieves a row from 'django.auth_permission' as a AuthPermission.
//
// Generated from index 'auth_permission_417f1b1c'.
|
[
"AuthPermissionsByContentTypeID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_permission",
"as",
"a",
"AuthPermission",
".",
"Generated",
"from",
"index",
"auth_permission_417f1b1c",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authpermission.xo.go#L142-L176
|
train
|
xo/xo
|
models/pgcolorder.xo.go
|
PgGetColOrder
|
func PgGetColOrder(db XODB, schema string, index string) (*PgColOrder, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`i.indkey ` + // ::varchar AS ord
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`WHERE n.nspname = $1 AND ic.relname = $2`
// run query
XOLog(sqlstr, schema, index)
var pco PgColOrder
err = db.QueryRow(sqlstr, schema, index).Scan(&pco.Ord)
if err != nil {
return nil, err
}
return &pco, nil
}
|
go
|
func PgGetColOrder(db XODB, schema string, index string) (*PgColOrder, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`i.indkey ` + // ::varchar AS ord
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`WHERE n.nspname = $1 AND ic.relname = $2`
// run query
XOLog(sqlstr, schema, index)
var pco PgColOrder
err = db.QueryRow(sqlstr, schema, index).Scan(&pco.Ord)
if err != nil {
return nil, err
}
return &pco, nil
}
|
[
"func",
"PgGetColOrder",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"index",
"string",
")",
"(",
"*",
"PgColOrder",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`i.indkey `",
"+",
"`FROM pg_index i `",
"+",
"`JOIN ONLY pg_class c ON c.oid = i.indrelid `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `",
"+",
"`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `",
"+",
"`WHERE n.nspname = $1 AND ic.relname = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"index",
")",
"\n",
"var",
"pco",
"PgColOrder",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"schema",
",",
"index",
")",
".",
"Scan",
"(",
"&",
"pco",
".",
"Ord",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"pco",
",",
"nil",
"\n",
"}"
] |
// PgGetColOrder runs a custom query, returning results as PgColOrder.
|
[
"PgGetColOrder",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"PgColOrder",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/pgcolorder.xo.go#L12-L33
|
train
|
xo/xo
|
internal/funcs.go
|
NewTemplateFuncs
|
func (a *ArgType) NewTemplateFuncs() template.FuncMap {
return template.FuncMap{
"colcount": a.colcount,
"colnames": a.colnames,
"colnamesmulti": a.colnamesmulti,
"colnamesquery": a.colnamesquery,
"colnamesquerymulti": a.colnamesquerymulti,
"colprefixnames": a.colprefixnames,
"colvals": a.colvals,
"colvalsmulti": a.colvalsmulti,
"fieldnames": a.fieldnames,
"fieldnamesmulti": a.fieldnamesmulti,
"goparamlist": a.goparamlist,
"reniltype": a.reniltype,
"retype": a.retype,
"shortname": a.shortname,
"convext": a.convext,
"schema": a.schemafn,
"colname": a.colname,
"hascolumn": a.hascolumn,
"hasfield": a.hasfield,
"getstartcount": a.getstartcount,
}
}
|
go
|
func (a *ArgType) NewTemplateFuncs() template.FuncMap {
return template.FuncMap{
"colcount": a.colcount,
"colnames": a.colnames,
"colnamesmulti": a.colnamesmulti,
"colnamesquery": a.colnamesquery,
"colnamesquerymulti": a.colnamesquerymulti,
"colprefixnames": a.colprefixnames,
"colvals": a.colvals,
"colvalsmulti": a.colvalsmulti,
"fieldnames": a.fieldnames,
"fieldnamesmulti": a.fieldnamesmulti,
"goparamlist": a.goparamlist,
"reniltype": a.reniltype,
"retype": a.retype,
"shortname": a.shortname,
"convext": a.convext,
"schema": a.schemafn,
"colname": a.colname,
"hascolumn": a.hascolumn,
"hasfield": a.hasfield,
"getstartcount": a.getstartcount,
}
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"NewTemplateFuncs",
"(",
")",
"template",
".",
"FuncMap",
"{",
"return",
"template",
".",
"FuncMap",
"{",
"\"colcount\"",
":",
"a",
".",
"colcount",
",",
"\"colnames\"",
":",
"a",
".",
"colnames",
",",
"\"colnamesmulti\"",
":",
"a",
".",
"colnamesmulti",
",",
"\"colnamesquery\"",
":",
"a",
".",
"colnamesquery",
",",
"\"colnamesquerymulti\"",
":",
"a",
".",
"colnamesquerymulti",
",",
"\"colprefixnames\"",
":",
"a",
".",
"colprefixnames",
",",
"\"colvals\"",
":",
"a",
".",
"colvals",
",",
"\"colvalsmulti\"",
":",
"a",
".",
"colvalsmulti",
",",
"\"fieldnames\"",
":",
"a",
".",
"fieldnames",
",",
"\"fieldnamesmulti\"",
":",
"a",
".",
"fieldnamesmulti",
",",
"\"goparamlist\"",
":",
"a",
".",
"goparamlist",
",",
"\"reniltype\"",
":",
"a",
".",
"reniltype",
",",
"\"retype\"",
":",
"a",
".",
"retype",
",",
"\"shortname\"",
":",
"a",
".",
"shortname",
",",
"\"convext\"",
":",
"a",
".",
"convext",
",",
"\"schema\"",
":",
"a",
".",
"schemafn",
",",
"\"colname\"",
":",
"a",
".",
"colname",
",",
"\"hascolumn\"",
":",
"a",
".",
"hascolumn",
",",
"\"hasfield\"",
":",
"a",
".",
"hasfield",
",",
"\"getstartcount\"",
":",
"a",
".",
"getstartcount",
",",
"}",
"\n",
"}"
] |
// NewTemplateFuncs returns a set of template funcs bound to the supplied args.
|
[
"NewTemplateFuncs",
"returns",
"a",
"set",
"of",
"template",
"funcs",
"bound",
"to",
"the",
"supplied",
"args",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L14-L37
|
train
|
xo/xo
|
internal/funcs.go
|
colcount
|
func (a *ArgType) colcount(fields []*Field, ignoreNames ...string) int {
ignore := map[string]bool{}
for _, n := range ignoreNames {
ignore[n] = true
}
i := 1
for _, f := range fields {
if ignore[f.Name] {
continue
}
i++
}
return i
}
|
go
|
func (a *ArgType) colcount(fields []*Field, ignoreNames ...string) int {
ignore := map[string]bool{}
for _, n := range ignoreNames {
ignore[n] = true
}
i := 1
for _, f := range fields {
if ignore[f.Name] {
continue
}
i++
}
return i
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"colcount",
"(",
"fields",
"[",
"]",
"*",
"Field",
",",
"ignoreNames",
"...",
"string",
")",
"int",
"{",
"ignore",
":=",
"map",
"[",
"string",
"]",
"bool",
"{",
"}",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"ignoreNames",
"{",
"ignore",
"[",
"n",
"]",
"=",
"true",
"\n",
"}",
"\n",
"i",
":=",
"1",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"fields",
"{",
"if",
"ignore",
"[",
"f",
".",
"Name",
"]",
"{",
"continue",
"\n",
"}",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"return",
"i",
"\n",
"}"
] |
// colcount returns the 1-based count of fields, excluding any Field with Name
// contained in ignoreNames.
//
// Used to get the count of fields, and useful for specifying the last SQL
// parameter.
|
[
"colcount",
"returns",
"the",
"1",
"-",
"based",
"count",
"of",
"fields",
"excluding",
"any",
"Field",
"with",
"Name",
"contained",
"in",
"ignoreNames",
".",
"Used",
"to",
"get",
"the",
"count",
"of",
"fields",
"and",
"useful",
"for",
"specifying",
"the",
"last",
"SQL",
"parameter",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L429-L444
|
train
|
xo/xo
|
internal/funcs.go
|
schemafn
|
func (a *ArgType) schemafn(s string, names ...string) string {
// escape table names
if a.EscapeTableNames {
for i, t := range names {
names[i] = a.Loader.Escape(TableEsc, t)
}
}
n := strings.Join(names, ".")
if s == "" && n == "" {
return ""
}
if s != "" && n != "" {
if a.EscapeSchemaName {
s = a.Loader.Escape(SchemaEsc, s)
}
s = s + "."
}
return s + n
}
|
go
|
func (a *ArgType) schemafn(s string, names ...string) string {
// escape table names
if a.EscapeTableNames {
for i, t := range names {
names[i] = a.Loader.Escape(TableEsc, t)
}
}
n := strings.Join(names, ".")
if s == "" && n == "" {
return ""
}
if s != "" && n != "" {
if a.EscapeSchemaName {
s = a.Loader.Escape(SchemaEsc, s)
}
s = s + "."
}
return s + n
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"schemafn",
"(",
"s",
"string",
",",
"names",
"...",
"string",
")",
"string",
"{",
"if",
"a",
".",
"EscapeTableNames",
"{",
"for",
"i",
",",
"t",
":=",
"range",
"names",
"{",
"names",
"[",
"i",
"]",
"=",
"a",
".",
"Loader",
".",
"Escape",
"(",
"TableEsc",
",",
"t",
")",
"\n",
"}",
"\n",
"}",
"\n",
"n",
":=",
"strings",
".",
"Join",
"(",
"names",
",",
"\".\"",
")",
"\n",
"if",
"s",
"==",
"\"\"",
"&&",
"n",
"==",
"\"\"",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"if",
"s",
"!=",
"\"\"",
"&&",
"n",
"!=",
"\"\"",
"{",
"if",
"a",
".",
"EscapeSchemaName",
"{",
"s",
"=",
"a",
".",
"Loader",
".",
"Escape",
"(",
"SchemaEsc",
",",
"s",
")",
"\n",
"}",
"\n",
"s",
"=",
"s",
"+",
"\".\"",
"\n",
"}",
"\n",
"return",
"s",
"+",
"n",
"\n",
"}"
] |
// schemafn takes a series of names and joins them with the schema name.
|
[
"schemafn",
"takes",
"a",
"series",
"of",
"names",
"and",
"joins",
"them",
"with",
"the",
"schema",
"name",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L577-L599
|
train
|
xo/xo
|
internal/funcs.go
|
colname
|
func (a *ArgType) colname(col *models.Column) string {
if a.EscapeColumnNames {
return a.Loader.Escape(ColumnEsc, col.ColumnName)
}
return col.ColumnName
}
|
go
|
func (a *ArgType) colname(col *models.Column) string {
if a.EscapeColumnNames {
return a.Loader.Escape(ColumnEsc, col.ColumnName)
}
return col.ColumnName
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"colname",
"(",
"col",
"*",
"models",
".",
"Column",
")",
"string",
"{",
"if",
"a",
".",
"EscapeColumnNames",
"{",
"return",
"a",
".",
"Loader",
".",
"Escape",
"(",
"ColumnEsc",
",",
"col",
".",
"ColumnName",
")",
"\n",
"}",
"\n",
"return",
"col",
".",
"ColumnName",
"\n",
"}"
] |
// colname returns the ColumnName of col, optionally escaping it if
// ArgType.EscapeColumnNames is toggled.
|
[
"colname",
"returns",
"the",
"ColumnName",
"of",
"col",
"optionally",
"escaping",
"it",
"if",
"ArgType",
".",
"EscapeColumnNames",
"is",
"toggled",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L603-L609
|
train
|
xo/xo
|
internal/funcs.go
|
hascolumn
|
func (a *ArgType) hascolumn(fields []*Field, name string) bool {
for _, f := range fields {
if f.Col.ColumnName == name {
return true
}
}
return false
}
|
go
|
func (a *ArgType) hascolumn(fields []*Field, name string) bool {
for _, f := range fields {
if f.Col.ColumnName == name {
return true
}
}
return false
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"hascolumn",
"(",
"fields",
"[",
"]",
"*",
"Field",
",",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hascolumn takes a list of fields and determines if field with the specified
// column name is in the list.
|
[
"hascolumn",
"takes",
"a",
"list",
"of",
"fields",
"and",
"determines",
"if",
"field",
"with",
"the",
"specified",
"column",
"name",
"is",
"in",
"the",
"list",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L613-L621
|
train
|
xo/xo
|
internal/funcs.go
|
hasfield
|
func (a *ArgType) hasfield(fields []*Field, name string) bool {
for _, f := range fields {
if f.Name == name {
return true
}
}
return false
}
|
go
|
func (a *ArgType) hasfield(fields []*Field, name string) bool {
for _, f := range fields {
if f.Name == name {
return true
}
}
return false
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"hasfield",
"(",
"fields",
"[",
"]",
"*",
"Field",
",",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"fields",
"{",
"if",
"f",
".",
"Name",
"==",
"name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// hasfield takes a list of fields and determines if field with the specified
// field name is in the list.
|
[
"hasfield",
"takes",
"a",
"list",
"of",
"fields",
"and",
"determines",
"if",
"field",
"with",
"the",
"specified",
"field",
"name",
"is",
"in",
"the",
"list",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L625-L633
|
train
|
xo/xo
|
internal/funcs.go
|
getstartcount
|
func (a *ArgType) getstartcount(fields []*Field, pkFields []*Field) int {
return len(fields) - len(pkFields)
}
|
go
|
func (a *ArgType) getstartcount(fields []*Field, pkFields []*Field) int {
return len(fields) - len(pkFields)
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"getstartcount",
"(",
"fields",
"[",
"]",
"*",
"Field",
",",
"pkFields",
"[",
"]",
"*",
"Field",
")",
"int",
"{",
"return",
"len",
"(",
"fields",
")",
"-",
"len",
"(",
"pkFields",
")",
"\n",
"}"
] |
// getstartcount returns a starting count for numbering columsn in queries
|
[
"getstartcount",
"returns",
"a",
"starting",
"count",
"for",
"numbering",
"columsn",
"in",
"queries"
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/funcs.go#L636-L638
|
train
|
xo/xo
|
models/enum.xo.go
|
PgEnums
|
func PgEnums(db XODB, schema string) ([]*Enum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.typname ` + // ::varchar AS enum_name
`FROM pg_type t ` +
`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace ` +
`JOIN ONLY pg_enum e ON t.oid = e.enumtypid ` +
`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 := []*Enum{}
for q.Next() {
e := Enum{}
// scan
err = q.Scan(&e.EnumName)
if err != nil {
return nil, err
}
res = append(res, &e)
}
return res, nil
}
|
go
|
func PgEnums(db XODB, schema string) ([]*Enum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.typname ` + // ::varchar AS enum_name
`FROM pg_type t ` +
`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace ` +
`JOIN ONLY pg_enum e ON t.oid = e.enumtypid ` +
`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 := []*Enum{}
for q.Next() {
e := Enum{}
// scan
err = q.Scan(&e.EnumName)
if err != nil {
return nil, err
}
res = append(res, &e)
}
return res, nil
}
|
[
"func",
"PgEnums",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"Enum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`t.typname `",
"+",
"`FROM pg_type t `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace `",
"+",
"`JOIN ONLY pg_enum e ON t.oid = e.enumtypid `",
"+",
"`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",
":=",
"[",
"]",
"*",
"Enum",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"e",
":=",
"Enum",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"e",
".",
"EnumName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"e",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgEnums runs a custom query, returning results as Enum.
|
[
"PgEnums",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Enum",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/enum.xo.go#L12-L46
|
train
|
xo/xo
|
internal/types.go
|
String
|
func (tt TemplateType) String() string {
var s string
switch tt {
case XOTemplate:
s = "xo_db"
case EnumTemplate:
s = "enum"
case ProcTemplate:
s = "proc"
case TypeTemplate:
s = "type"
case ForeignKeyTemplate:
s = "foreignkey"
case IndexTemplate:
s = "index"
case QueryTypeTemplate:
s = "querytype"
case QueryTemplate:
s = "query"
default:
panic("unknown TemplateType")
}
return s
}
|
go
|
func (tt TemplateType) String() string {
var s string
switch tt {
case XOTemplate:
s = "xo_db"
case EnumTemplate:
s = "enum"
case ProcTemplate:
s = "proc"
case TypeTemplate:
s = "type"
case ForeignKeyTemplate:
s = "foreignkey"
case IndexTemplate:
s = "index"
case QueryTypeTemplate:
s = "querytype"
case QueryTemplate:
s = "query"
default:
panic("unknown TemplateType")
}
return s
}
|
[
"func",
"(",
"tt",
"TemplateType",
")",
"String",
"(",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"switch",
"tt",
"{",
"case",
"XOTemplate",
":",
"s",
"=",
"\"xo_db\"",
"\n",
"case",
"EnumTemplate",
":",
"s",
"=",
"\"enum\"",
"\n",
"case",
"ProcTemplate",
":",
"s",
"=",
"\"proc\"",
"\n",
"case",
"TypeTemplate",
":",
"s",
"=",
"\"type\"",
"\n",
"case",
"ForeignKeyTemplate",
":",
"s",
"=",
"\"foreignkey\"",
"\n",
"case",
"IndexTemplate",
":",
"s",
"=",
"\"index\"",
"\n",
"case",
"QueryTypeTemplate",
":",
"s",
"=",
"\"querytype\"",
"\n",
"case",
"QueryTemplate",
":",
"s",
"=",
"\"query\"",
"\n",
"default",
":",
"panic",
"(",
"\"unknown TemplateType\"",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// String returns the name for the associated template type.
|
[
"String",
"returns",
"the",
"name",
"for",
"the",
"associated",
"template",
"type",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/types.go#L23-L46
|
train
|
xo/xo
|
internal/types.go
|
String
|
func (rt RelType) String() string {
var s string
switch rt {
case Table:
s = "TABLE"
case View:
s = "VIEW"
default:
panic("unknown RelType")
}
return s
}
|
go
|
func (rt RelType) String() string {
var s string
switch rt {
case Table:
s = "TABLE"
case View:
s = "VIEW"
default:
panic("unknown RelType")
}
return s
}
|
[
"func",
"(",
"rt",
"RelType",
")",
"String",
"(",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"switch",
"rt",
"{",
"case",
"Table",
":",
"s",
"=",
"\"TABLE\"",
"\n",
"case",
"View",
":",
"s",
"=",
"\"VIEW\"",
"\n",
"default",
":",
"panic",
"(",
"\"unknown RelType\"",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] |
// String provides the string representation of RelType.
|
[
"String",
"provides",
"the",
"string",
"representation",
"of",
"RelType",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/types.go#L69-L80
|
train
|
xo/xo
|
examples/django/oracle/djangoadminlog.xo.go
|
Save
|
func (dal *DjangoAdminLog) Save(db XODB) error {
if dal.Exists() {
return dal.Update(db)
}
return dal.Insert(db)
}
|
go
|
func (dal *DjangoAdminLog) Save(db XODB) error {
if dal.Exists() {
return dal.Update(db)
}
return dal.Insert(db)
}
|
[
"func",
"(",
"dal",
"*",
"DjangoAdminLog",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"dal",
".",
"Exists",
"(",
")",
"{",
"return",
"dal",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"dal",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the DjangoAdminLog to the database.
|
[
"Save",
"saves",
"the",
"DjangoAdminLog",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangoadminlog.xo.go#L99-L105
|
train
|
xo/xo
|
examples/django/oracle/djangoadminlog.xo.go
|
DjangoAdminLogsByUserID
|
func DjangoAdminLogsByUserID(db XODB, userID float64) ([]*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 django.django_admin_log ` +
`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 := []*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 DjangoAdminLogsByUserID(db XODB, userID float64) ([]*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 django.django_admin_log ` +
`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 := []*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",
"DjangoAdminLogsByUserID",
"(",
"db",
"XODB",
",",
"userID",
"float64",
")",
"(",
"[",
"]",
"*",
"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 django.django_admin_log `",
"+",
"`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",
":=",
"[",
"]",
"*",
"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",
"}"
] |
// DjangoAdminLogsByUserID retrieves a row from 'django.django_admin_log' as a DjangoAdminLog.
//
// Generated from index 'django_admin_log_e8701ad4'.
|
[
"DjangoAdminLogsByUserID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_admin_log",
"as",
"a",
"DjangoAdminLog",
".",
"Generated",
"from",
"index",
"django_admin_log_e8701ad4",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangoadminlog.xo.go#L193-L227
|
train
|
xo/xo
|
examples/django/sqlite3/authuser.xo.go
|
Save
|
func (au *AuthUser) Save(db XODB) error {
if au.Exists() {
return au.Update(db)
}
return au.Insert(db)
}
|
go
|
func (au *AuthUser) Save(db XODB) error {
if au.Exists() {
return au.Update(db)
}
return au.Insert(db)
}
|
[
"func",
"(",
"au",
"*",
"AuthUser",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"au",
".",
"Exists",
"(",
")",
"{",
"return",
"au",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"au",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthUser to the database.
|
[
"Save",
"saves",
"the",
"AuthUser",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authuser.xo.go#L101-L107
|
train
|
xo/xo
|
examples/django/sqlite3/djangoadminlog.xo.go
|
DjangoAdminLogByID
|
func DjangoAdminLogByID(db XODB, id int) (*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, object_id, object_repr, action_flag, change_message, content_type_id, user_id, action_time ` +
`FROM django_admin_log ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dal := DjangoAdminLog{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dal.ID, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID, &dal.ActionTime)
if err != nil {
return nil, err
}
return &dal, nil
}
|
go
|
func DjangoAdminLogByID(db XODB, id int) (*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, object_id, object_repr, action_flag, change_message, content_type_id, user_id, action_time ` +
`FROM django_admin_log ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dal := DjangoAdminLog{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dal.ID, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID, &dal.ActionTime)
if err != nil {
return nil, err
}
return &dal, nil
}
|
[
"func",
"DjangoAdminLogByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"DjangoAdminLog",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, object_id, object_repr, action_flag, change_message, content_type_id, user_id, action_time `",
"+",
"`FROM django_admin_log `",
"+",
"`WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"dal",
":=",
"DjangoAdminLog",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"dal",
".",
"ID",
",",
"&",
"dal",
".",
"ObjectID",
",",
"&",
"dal",
".",
"ObjectRepr",
",",
"&",
"dal",
".",
"ActionFlag",
",",
"&",
"dal",
".",
"ChangeMessage",
",",
"&",
"dal",
".",
"ContentTypeID",
",",
"&",
"dal",
".",
"UserID",
",",
"&",
"dal",
".",
"ActionTime",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"dal",
",",
"nil",
"\n",
"}"
] |
// DjangoAdminLogByID retrieves a row from 'django_admin_log' as a DjangoAdminLog.
//
// Generated from index 'django_admin_log_id_pkey'.
|
[
"DjangoAdminLogByID",
"retrieves",
"a",
"row",
"from",
"django_admin_log",
"as",
"a",
"DjangoAdminLog",
".",
"Generated",
"from",
"index",
"django_admin_log_id_pkey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/djangoadminlog.xo.go#L232-L253
|
train
|
xo/xo
|
examples/django/postgres/authgroup.xo.go
|
AuthGroupsByName
|
func AuthGroupsByName(db XODB, name string) ([]*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM public.auth_group ` +
`WHERE name = $1`
// run query
XOLog(sqlstr, name)
q, err := db.Query(sqlstr, name)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthGroup{}
for q.Next() {
ag := AuthGroup{
_exists: true,
}
// scan
err = q.Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
res = append(res, &ag)
}
return res, nil
}
|
go
|
func AuthGroupsByName(db XODB, name string) ([]*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM public.auth_group ` +
`WHERE name = $1`
// run query
XOLog(sqlstr, name)
q, err := db.Query(sqlstr, name)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthGroup{}
for q.Next() {
ag := AuthGroup{
_exists: true,
}
// scan
err = q.Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
res = append(res, &ag)
}
return res, nil
}
|
[
"func",
"AuthGroupsByName",
"(",
"db",
"XODB",
",",
"name",
"string",
")",
"(",
"[",
"]",
"*",
"AuthGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name `",
"+",
"`FROM public.auth_group `",
"+",
"`WHERE name = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"name",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"AuthGroup",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ag",
":=",
"AuthGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ag",
".",
"ID",
",",
"&",
"ag",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ag",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthGroupsByName retrieves a row from 'public.auth_group' as a AuthGroup.
//
// Generated from index 'auth_group_name_a6ea08ec_like'.
|
[
"AuthGroupsByName",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_group",
"as",
"a",
"AuthGroup",
".",
"Generated",
"from",
"index",
"auth_group_name_a6ea08ec_like",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authgroup.xo.go#L162-L196
|
train
|
xo/xo
|
examples/django/postgres/authgroup.xo.go
|
AuthGroupByName
|
func AuthGroupByName(db XODB, name string) (*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM public.auth_group ` +
`WHERE name = $1`
// run query
XOLog(sqlstr, name)
ag := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, name).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
}
|
go
|
func AuthGroupByName(db XODB, name string) (*AuthGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name ` +
`FROM public.auth_group ` +
`WHERE name = $1`
// run query
XOLog(sqlstr, name)
ag := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, name).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
}
|
[
"func",
"AuthGroupByName",
"(",
"db",
"XODB",
",",
"name",
"string",
")",
"(",
"*",
"AuthGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name `",
"+",
"`FROM public.auth_group `",
"+",
"`WHERE name = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"name",
")",
"\n",
"ag",
":=",
"AuthGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"name",
")",
".",
"Scan",
"(",
"&",
"ag",
".",
"ID",
",",
"&",
"ag",
".",
"Name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"ag",
",",
"nil",
"\n",
"}"
] |
// AuthGroupByName retrieves a row from 'public.auth_group' as a AuthGroup.
//
// Generated from index 'auth_group_name_key'.
|
[
"AuthGroupByName",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_group",
"as",
"a",
"AuthGroup",
".",
"Generated",
"from",
"index",
"auth_group_name_key",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authgroup.xo.go#L201-L222
|
train
|
xo/xo
|
models/index.xo.go
|
PgTableIndexes
|
func PgTableIndexes(db XODB, schema string, table string) ([]*Index, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`DISTINCT ic.relname, ` + // ::varchar AS index_name
`i.indisunique, ` + // ::boolean AS is_unique
`i.indisprimary, ` + // ::boolean AS is_primary
`0, ` + // ::integer AS seq_no
`'', ` + // ::varchar AS origin
`false ` + // ::boolean AS is_partial
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`WHERE i.indkey <> '0' AND n.nspname = $1 AND c.relname = $2`
// 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 := []*Index{}
for q.Next() {
i := Index{}
// scan
err = q.Scan(&i.IndexName, &i.IsUnique, &i.IsPrimary, &i.SeqNo, &i.Origin, &i.IsPartial)
if err != nil {
return nil, err
}
res = append(res, &i)
}
return res, nil
}
|
go
|
func PgTableIndexes(db XODB, schema string, table string) ([]*Index, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`DISTINCT ic.relname, ` + // ::varchar AS index_name
`i.indisunique, ` + // ::boolean AS is_unique
`i.indisprimary, ` + // ::boolean AS is_primary
`0, ` + // ::integer AS seq_no
`'', ` + // ::varchar AS origin
`false ` + // ::boolean AS is_partial
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`WHERE i.indkey <> '0' AND n.nspname = $1 AND c.relname = $2`
// 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 := []*Index{}
for q.Next() {
i := Index{}
// scan
err = q.Scan(&i.IndexName, &i.IsUnique, &i.IsPrimary, &i.SeqNo, &i.Origin, &i.IsPartial)
if err != nil {
return nil, err
}
res = append(res, &i)
}
return res, nil
}
|
[
"func",
"PgTableIndexes",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`DISTINCT ic.relname, `",
"+",
"`i.indisunique, `",
"+",
"`i.indisprimary, `",
"+",
"`0, `",
"+",
"`'', `",
"+",
"`false `",
"+",
"`FROM pg_index i `",
"+",
"`JOIN ONLY pg_class c ON c.oid = i.indrelid `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `",
"+",
"`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `",
"+",
"`WHERE i.indkey <> '0' AND n.nspname = $1 AND c.relname = $2`",
"\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",
":=",
"[",
"]",
"*",
"Index",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"i",
":=",
"Index",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"i",
".",
"IndexName",
",",
"&",
"i",
".",
"IsUnique",
",",
"&",
"i",
".",
"IsPrimary",
",",
"&",
"i",
".",
"SeqNo",
",",
"&",
"i",
".",
"Origin",
",",
"&",
"i",
".",
"IsPartial",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"i",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgTableIndexes runs a custom query, returning results as Index.
|
[
"PgTableIndexes",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/index.xo.go#L17-L57
|
train
|
xo/xo
|
models/table.xo.go
|
MsTables
|
func MsTables(db XODB, schema string, relkind string) ([]*Table, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`xtype AS type, ` +
`name AS table_name ` +
`FROM sysobjects ` +
`WHERE SCHEMA_NAME(uid) = $1 AND xtype = $2`
// run query
XOLog(sqlstr, schema, relkind)
q, err := db.Query(sqlstr, schema, relkind)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Table{}
for q.Next() {
t := Table{}
// scan
err = q.Scan(&t.Type, &t.TableName)
if err != nil {
return nil, err
}
res = append(res, &t)
}
return res, nil
}
|
go
|
func MsTables(db XODB, schema string, relkind string) ([]*Table, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`xtype AS type, ` +
`name AS table_name ` +
`FROM sysobjects ` +
`WHERE SCHEMA_NAME(uid) = $1 AND xtype = $2`
// run query
XOLog(sqlstr, schema, relkind)
q, err := db.Query(sqlstr, schema, relkind)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Table{}
for q.Next() {
t := Table{}
// scan
err = q.Scan(&t.Type, &t.TableName)
if err != nil {
return nil, err
}
res = append(res, &t)
}
return res, nil
}
|
[
"func",
"MsTables",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`xtype AS type, `",
"+",
"`name AS table_name `",
"+",
"`FROM sysobjects `",
"+",
"`WHERE SCHEMA_NAME(uid) = $1 AND xtype = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"relkind",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"Table",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"t",
":=",
"Table",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"t",
".",
"Type",
",",
"&",
"t",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"t",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// MsTables runs a custom query, returning results as Table.
|
[
"MsTables",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Table",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/table.xo.go#L122-L155
|
train
|
xo/xo
|
models/enumvalue.xo.go
|
PgEnumValues
|
func PgEnumValues(db XODB, schema string, enum string) ([]*EnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`e.enumlabel, ` + // ::varchar AS enum_value
`e.enumsortorder ` + // ::integer AS const_value
`FROM pg_type t ` +
`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace ` +
`LEFT JOIN pg_enum e ON t.oid = e.enumtypid ` +
`WHERE n.nspname = $1 AND t.typname = $2`
// run query
XOLog(sqlstr, schema, enum)
q, err := db.Query(sqlstr, schema, enum)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*EnumValue{}
for q.Next() {
ev := EnumValue{}
// scan
err = q.Scan(&ev.EnumValue, &ev.ConstValue)
if err != nil {
return nil, err
}
res = append(res, &ev)
}
return res, nil
}
|
go
|
func PgEnumValues(db XODB, schema string, enum string) ([]*EnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`e.enumlabel, ` + // ::varchar AS enum_value
`e.enumsortorder ` + // ::integer AS const_value
`FROM pg_type t ` +
`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace ` +
`LEFT JOIN pg_enum e ON t.oid = e.enumtypid ` +
`WHERE n.nspname = $1 AND t.typname = $2`
// run query
XOLog(sqlstr, schema, enum)
q, err := db.Query(sqlstr, schema, enum)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*EnumValue{}
for q.Next() {
ev := EnumValue{}
// scan
err = q.Scan(&ev.EnumValue, &ev.ConstValue)
if err != nil {
return nil, err
}
res = append(res, &ev)
}
return res, nil
}
|
[
"func",
"PgEnumValues",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"enum",
"string",
")",
"(",
"[",
"]",
"*",
"EnumValue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`e.enumlabel, `",
"+",
"`e.enumsortorder `",
"+",
"`FROM pg_type t `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace `",
"+",
"`LEFT JOIN pg_enum e ON t.oid = e.enumtypid `",
"+",
"`WHERE n.nspname = $1 AND t.typname = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"EnumValue",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ev",
":=",
"EnumValue",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ev",
".",
"EnumValue",
",",
"&",
"ev",
".",
"ConstValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ev",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgEnumValues runs a custom query, returning results as EnumValue.
|
[
"PgEnumValues",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"EnumValue",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/enumvalue.xo.go#L13-L48
|
train
|
xo/xo
|
loaders/oracle.go
|
OrParseType
|
func OrParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
nilVal := "nil"
dt = strings.ToLower(dt)
// extract precision
dt, precision, scale := args.ParsePrecision(dt)
var typ string
// strip remaining length (on things like timestamp)
switch OrLenRE.ReplaceAllString(dt, "") {
case "char", "nchar", "varchar", "varchar2", "nvarchar2",
"long",
"clob", "nclob",
"rowid":
nilVal = `""`
typ = "string"
case "shortint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "integer":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "longinteger":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "float", "shortdecimal":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "number", "decimal":
nilVal = "0.0"
if 0 < precision && precision < 18 && scale > 0 {
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
} else if 0 < precision && precision <= 19 && scale == 0 {
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
} else {
nilVal = `""`
typ = "string"
}
case "blob", "long raw", "raw":
typ = "[]byte"
case "date", "timestamp", "timestamp with time zone":
typ = "time.Time"
nilVal = "time.Time{}"
default:
// bail
fmt.Fprintf(os.Stderr, "error: unknown type %q\n", dt)
os.Exit(1)
}
// special case for bool
if typ == "int" && precision == 1 {
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
}
return precision, nilVal, typ
}
|
go
|
func OrParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
nilVal := "nil"
dt = strings.ToLower(dt)
// extract precision
dt, precision, scale := args.ParsePrecision(dt)
var typ string
// strip remaining length (on things like timestamp)
switch OrLenRE.ReplaceAllString(dt, "") {
case "char", "nchar", "varchar", "varchar2", "nvarchar2",
"long",
"clob", "nclob",
"rowid":
nilVal = `""`
typ = "string"
case "shortint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "integer":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "longinteger":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "float", "shortdecimal":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "number", "decimal":
nilVal = "0.0"
if 0 < precision && precision < 18 && scale > 0 {
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
} else if 0 < precision && precision <= 19 && scale == 0 {
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
} else {
nilVal = `""`
typ = "string"
}
case "blob", "long raw", "raw":
typ = "[]byte"
case "date", "timestamp", "timestamp with time zone":
typ = "time.Time"
nilVal = "time.Time{}"
default:
// bail
fmt.Fprintf(os.Stderr, "error: unknown type %q\n", dt)
os.Exit(1)
}
// special case for bool
if typ == "int" && precision == 1 {
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
}
return precision, nilVal, typ
}
|
[
"func",
"OrParseType",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"dt",
"string",
",",
"nullable",
"bool",
")",
"(",
"int",
",",
"string",
",",
"string",
")",
"{",
"nilVal",
":=",
"\"nil\"",
"\n",
"dt",
"=",
"strings",
".",
"ToLower",
"(",
"dt",
")",
"\n",
"dt",
",",
"precision",
",",
"scale",
":=",
"args",
".",
"ParsePrecision",
"(",
"dt",
")",
"\n",
"var",
"typ",
"string",
"\n",
"switch",
"OrLenRE",
".",
"ReplaceAllString",
"(",
"dt",
",",
"\"\"",
")",
"{",
"case",
"\"char\"",
",",
"\"nchar\"",
",",
"\"varchar\"",
",",
"\"varchar2\"",
",",
"\"nvarchar2\"",
",",
"\"long\"",
",",
"\"clob\"",
",",
"\"nclob\"",
",",
"\"rowid\"",
":",
"nilVal",
"=",
"`\"\"`",
"\n",
"typ",
"=",
"\"string\"",
"\n",
"case",
"\"shortint\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"int16\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"integer\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"args",
".",
"Int32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"longinteger\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"\"int64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"float\"",
",",
"\"shortdecimal\"",
":",
"nilVal",
"=",
"\"0.0\"",
"\n",
"typ",
"=",
"\"float32\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullFloat64{}\"",
"\n",
"typ",
"=",
"\"sql.NullFloat64\"",
"\n",
"}",
"\n",
"case",
"\"number\"",
",",
"\"decimal\"",
":",
"nilVal",
"=",
"\"0.0\"",
"\n",
"if",
"0",
"<",
"precision",
"&&",
"precision",
"<",
"18",
"&&",
"scale",
">",
"0",
"{",
"typ",
"=",
"\"float64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullFloat64{}\"",
"\n",
"typ",
"=",
"\"sql.NullFloat64\"",
"\n",
"}",
"\n",
"}",
"else",
"if",
"0",
"<",
"precision",
"&&",
"precision",
"<=",
"19",
"&&",
"scale",
"==",
"0",
"{",
"typ",
"=",
"\"int64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"}",
"else",
"{",
"nilVal",
"=",
"`\"\"`",
"\n",
"typ",
"=",
"\"string\"",
"\n",
"}",
"\n",
"case",
"\"blob\"",
",",
"\"long raw\"",
",",
"\"raw\"",
":",
"typ",
"=",
"\"[]byte\"",
"\n",
"case",
"\"date\"",
",",
"\"timestamp\"",
",",
"\"timestamp with time zone\"",
":",
"typ",
"=",
"\"time.Time\"",
"\n",
"nilVal",
"=",
"\"time.Time{}\"",
"\n",
"default",
":",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"error: unknown type %q\\n\"",
",",
"\\n",
")",
"\n",
"dt",
"\n",
"}",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"if",
"typ",
"==",
"\"int\"",
"&&",
"precision",
"==",
"1",
"{",
"nilVal",
"=",
"\"false\"",
"\n",
"typ",
"=",
"\"bool\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullBool{}\"",
"\n",
"typ",
"=",
"\"sql.NullBool\"",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// OrParseType parse a oracle type into a Go type based on the column
// definition.
|
[
"OrParseType",
"parse",
"a",
"oracle",
"type",
"into",
"a",
"Go",
"type",
"based",
"on",
"the",
"column",
"definition",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/oracle.go#L75-L166
|
train
|
xo/xo
|
models/indexcolumn.xo.go
|
PgIndexColumns
|
func PgIndexColumns(db XODB, schema string, index string) ([]*IndexColumn, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`(row_number() over()), ` + // ::integer AS seq_no
`a.attnum, ` + // ::integer AS cid
`a.attname ` + // ::varchar AS column_name
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`LEFT JOIN pg_attribute a ON i.indrelid = a.attrelid AND a.attnum = ANY(i.indkey) AND a.attisdropped = false ` +
`WHERE i.indkey <> '0' AND n.nspname = $1 AND ic.relname = $2`
// run query
XOLog(sqlstr, schema, index)
q, err := db.Query(sqlstr, schema, index)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*IndexColumn{}
for q.Next() {
ic := IndexColumn{}
// scan
err = q.Scan(&ic.SeqNo, &ic.Cid, &ic.ColumnName)
if err != nil {
return nil, err
}
res = append(res, &ic)
}
return res, nil
}
|
go
|
func PgIndexColumns(db XODB, schema string, index string) ([]*IndexColumn, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`(row_number() over()), ` + // ::integer AS seq_no
`a.attnum, ` + // ::integer AS cid
`a.attname ` + // ::varchar AS column_name
`FROM pg_index i ` +
`JOIN ONLY pg_class c ON c.oid = i.indrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace ` +
`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid ` +
`LEFT JOIN pg_attribute a ON i.indrelid = a.attrelid AND a.attnum = ANY(i.indkey) AND a.attisdropped = false ` +
`WHERE i.indkey <> '0' AND n.nspname = $1 AND ic.relname = $2`
// run query
XOLog(sqlstr, schema, index)
q, err := db.Query(sqlstr, schema, index)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*IndexColumn{}
for q.Next() {
ic := IndexColumn{}
// scan
err = q.Scan(&ic.SeqNo, &ic.Cid, &ic.ColumnName)
if err != nil {
return nil, err
}
res = append(res, &ic)
}
return res, nil
}
|
[
"func",
"PgIndexColumns",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"index",
"string",
")",
"(",
"[",
"]",
"*",
"IndexColumn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`(row_number() over()), `",
"+",
"`a.attnum, `",
"+",
"`a.attname `",
"+",
"`FROM pg_index i `",
"+",
"`JOIN ONLY pg_class c ON c.oid = i.indrelid `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `",
"+",
"`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `",
"+",
"`LEFT JOIN pg_attribute a ON i.indrelid = a.attrelid AND a.attnum = ANY(i.indkey) AND a.attisdropped = false `",
"+",
"`WHERE i.indkey <> '0' AND n.nspname = $1 AND ic.relname = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"index",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"IndexColumn",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ic",
":=",
"IndexColumn",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ic",
".",
"SeqNo",
",",
"&",
"ic",
".",
"Cid",
",",
"&",
"ic",
".",
"ColumnName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ic",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgIndexColumns runs a custom query, returning results as IndexColumn.
|
[
"PgIndexColumns",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"IndexColumn",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/indexcolumn.xo.go#L14-L52
|
train
|
xo/xo
|
models/foreignkey.xo.go
|
PgTableForeignKeys
|
func PgTableForeignKeys(db XODB, schema string, table string) ([]*ForeignKey, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`r.conname, ` + // ::varchar AS foreign_key_name
`b.attname, ` + // ::varchar AS column_name
`i.relname, ` + // ::varchar AS ref_index_name
`c.relname, ` + // ::varchar AS ref_table_name
`d.attname, ` + // ::varchar AS ref_column_name
`0, ` + // ::integer AS key_id
`0, ` + // ::integer AS seq_no
`'', ` + // ::varchar AS on_update
`'', ` + // ::varchar AS on_delete
`'' ` + // ::varchar AS match
`FROM pg_constraint r ` +
`JOIN ONLY pg_class a ON a.oid = r.conrelid ` +
`JOIN ONLY pg_attribute b ON b.attisdropped = false AND b.attnum = ANY(r.conkey) AND b.attrelid = r.conrelid ` +
`JOIN ONLY pg_class i on i.oid = r.conindid ` +
`JOIN ONLY pg_class c on c.oid = r.confrelid ` +
`JOIN ONLY pg_attribute d ON d.attisdropped = false AND d.attnum = ANY(r.confkey) AND d.attrelid = r.confrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = r.connamespace ` +
`WHERE r.contype = 'f' AND n.nspname = $1 AND a.relname = $2 ` +
`ORDER BY r.conname, b.attname`
// 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 := []*ForeignKey{}
for q.Next() {
fk := ForeignKey{}
// scan
err = q.Scan(&fk.ForeignKeyName, &fk.ColumnName, &fk.RefIndexName, &fk.RefTableName, &fk.RefColumnName, &fk.KeyID, &fk.SeqNo, &fk.OnUpdate, &fk.OnDelete, &fk.Match)
if err != nil {
return nil, err
}
res = append(res, &fk)
}
return res, nil
}
|
go
|
func PgTableForeignKeys(db XODB, schema string, table string) ([]*ForeignKey, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`r.conname, ` + // ::varchar AS foreign_key_name
`b.attname, ` + // ::varchar AS column_name
`i.relname, ` + // ::varchar AS ref_index_name
`c.relname, ` + // ::varchar AS ref_table_name
`d.attname, ` + // ::varchar AS ref_column_name
`0, ` + // ::integer AS key_id
`0, ` + // ::integer AS seq_no
`'', ` + // ::varchar AS on_update
`'', ` + // ::varchar AS on_delete
`'' ` + // ::varchar AS match
`FROM pg_constraint r ` +
`JOIN ONLY pg_class a ON a.oid = r.conrelid ` +
`JOIN ONLY pg_attribute b ON b.attisdropped = false AND b.attnum = ANY(r.conkey) AND b.attrelid = r.conrelid ` +
`JOIN ONLY pg_class i on i.oid = r.conindid ` +
`JOIN ONLY pg_class c on c.oid = r.confrelid ` +
`JOIN ONLY pg_attribute d ON d.attisdropped = false AND d.attnum = ANY(r.confkey) AND d.attrelid = r.confrelid ` +
`JOIN ONLY pg_namespace n ON n.oid = r.connamespace ` +
`WHERE r.contype = 'f' AND n.nspname = $1 AND a.relname = $2 ` +
`ORDER BY r.conname, b.attname`
// 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 := []*ForeignKey{}
for q.Next() {
fk := ForeignKey{}
// scan
err = q.Scan(&fk.ForeignKeyName, &fk.ColumnName, &fk.RefIndexName, &fk.RefTableName, &fk.RefColumnName, &fk.KeyID, &fk.SeqNo, &fk.OnUpdate, &fk.OnDelete, &fk.Match)
if err != nil {
return nil, err
}
res = append(res, &fk)
}
return res, nil
}
|
[
"func",
"PgTableForeignKeys",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"ForeignKey",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`r.conname, `",
"+",
"`b.attname, `",
"+",
"`i.relname, `",
"+",
"`c.relname, `",
"+",
"`d.attname, `",
"+",
"`0, `",
"+",
"`0, `",
"+",
"`'', `",
"+",
"`'', `",
"+",
"`'' `",
"+",
"`FROM pg_constraint r `",
"+",
"`JOIN ONLY pg_class a ON a.oid = r.conrelid `",
"+",
"`JOIN ONLY pg_attribute b ON b.attisdropped = false AND b.attnum = ANY(r.conkey) AND b.attrelid = r.conrelid `",
"+",
"`JOIN ONLY pg_class i on i.oid = r.conindid `",
"+",
"`JOIN ONLY pg_class c on c.oid = r.confrelid `",
"+",
"`JOIN ONLY pg_attribute d ON d.attisdropped = false AND d.attnum = ANY(r.confkey) AND d.attrelid = r.confrelid `",
"+",
"`JOIN ONLY pg_namespace n ON n.oid = r.connamespace `",
"+",
"`WHERE r.contype = 'f' AND n.nspname = $1 AND a.relname = $2 `",
"+",
"`ORDER BY r.conname, b.attname`",
"\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",
":=",
"[",
"]",
"*",
"ForeignKey",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"fk",
":=",
"ForeignKey",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"fk",
".",
"ForeignKeyName",
",",
"&",
"fk",
".",
"ColumnName",
",",
"&",
"fk",
".",
"RefIndexName",
",",
"&",
"fk",
".",
"RefTableName",
",",
"&",
"fk",
".",
"RefColumnName",
",",
"&",
"fk",
".",
"KeyID",
",",
"&",
"fk",
".",
"SeqNo",
",",
"&",
"fk",
".",
"OnUpdate",
",",
"&",
"fk",
".",
"OnDelete",
",",
"&",
"fk",
".",
"Match",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"fk",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgTableForeignKeys runs a custom query, returning results as ForeignKey.
|
[
"PgTableForeignKeys",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"ForeignKey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/foreignkey.xo.go#L21-L69
|
train
|
xo/xo
|
models/foreignkey.xo.go
|
MsTableForeignKeys
|
func MsTableForeignKeys(db XODB, schema string, table string) ([]*ForeignKey, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`f.name AS foreign_key_name, ` +
`c.name AS column_name, ` +
`o.name AS ref_table_name, ` +
`x.name AS ref_column_name ` +
`FROM sysobjects f ` +
`INNER JOIN sysobjects t ON f.parent_obj = t.id ` +
`INNER JOIN sysreferences r ON f.id = r.constid ` +
`INNER JOIN sysobjects o ON r.rkeyid = o.id ` +
`INNER JOIN syscolumns c ON r.rkeyid = c.id AND r.rkey1 = c.colid ` +
`INNER JOIN syscolumns x ON r.fkeyid = x.id AND r.fkey1 = x.colid ` +
`WHERE f.type = 'F' AND t.type = 'U' AND SCHEMA_NAME(t.uid) = $1 AND t.name = $2`
// 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 := []*ForeignKey{}
for q.Next() {
fk := ForeignKey{}
// scan
err = q.Scan(&fk.ForeignKeyName, &fk.ColumnName, &fk.RefTableName, &fk.RefColumnName)
if err != nil {
return nil, err
}
res = append(res, &fk)
}
return res, nil
}
|
go
|
func MsTableForeignKeys(db XODB, schema string, table string) ([]*ForeignKey, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`f.name AS foreign_key_name, ` +
`c.name AS column_name, ` +
`o.name AS ref_table_name, ` +
`x.name AS ref_column_name ` +
`FROM sysobjects f ` +
`INNER JOIN sysobjects t ON f.parent_obj = t.id ` +
`INNER JOIN sysreferences r ON f.id = r.constid ` +
`INNER JOIN sysobjects o ON r.rkeyid = o.id ` +
`INNER JOIN syscolumns c ON r.rkeyid = c.id AND r.rkey1 = c.colid ` +
`INNER JOIN syscolumns x ON r.fkeyid = x.id AND r.fkey1 = x.colid ` +
`WHERE f.type = 'F' AND t.type = 'U' AND SCHEMA_NAME(t.uid) = $1 AND t.name = $2`
// 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 := []*ForeignKey{}
for q.Next() {
fk := ForeignKey{}
// scan
err = q.Scan(&fk.ForeignKeyName, &fk.ColumnName, &fk.RefTableName, &fk.RefColumnName)
if err != nil {
return nil, err
}
res = append(res, &fk)
}
return res, nil
}
|
[
"func",
"MsTableForeignKeys",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"ForeignKey",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`f.name AS foreign_key_name, `",
"+",
"`c.name AS column_name, `",
"+",
"`o.name AS ref_table_name, `",
"+",
"`x.name AS ref_column_name `",
"+",
"`FROM sysobjects f `",
"+",
"`INNER JOIN sysobjects t ON f.parent_obj = t.id `",
"+",
"`INNER JOIN sysreferences r ON f.id = r.constid `",
"+",
"`INNER JOIN sysobjects o ON r.rkeyid = o.id `",
"+",
"`INNER JOIN syscolumns c ON r.rkeyid = c.id AND r.rkey1 = c.colid `",
"+",
"`INNER JOIN syscolumns x ON r.fkeyid = x.id AND r.fkey1 = x.colid `",
"+",
"`WHERE f.type = 'F' AND t.type = 'U' AND SCHEMA_NAME(t.uid) = $1 AND t.name = $2`",
"\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",
":=",
"[",
"]",
"*",
"ForeignKey",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"fk",
":=",
"ForeignKey",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"fk",
".",
"ForeignKeyName",
",",
"&",
"fk",
".",
"ColumnName",
",",
"&",
"fk",
".",
"RefTableName",
",",
"&",
"fk",
".",
"RefColumnName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"fk",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// MsTableForeignKeys runs a custom query, returning results as ForeignKey.
|
[
"MsTableForeignKeys",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"ForeignKey",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/foreignkey.xo.go#L142-L182
|
train
|
xo/xo
|
examples/django/sqlite3/authpermission.xo.go
|
Update
|
func (ap *AuthPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ap._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ap._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_permission SET ` +
`content_type_id = ?, codename = ?, name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ap.ContentTypeID, ap.Codename, ap.Name, ap.ID)
_, err = db.Exec(sqlstr, ap.ContentTypeID, ap.Codename, ap.Name, ap.ID)
return err
}
|
go
|
func (ap *AuthPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ap._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ap._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_permission SET ` +
`content_type_id = ?, codename = ?, name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ap.ContentTypeID, ap.Codename, ap.Name, ap.ID)
_, err = db.Exec(sqlstr, ap.ContentTypeID, ap.Codename, ap.Name, ap.ID)
return err
}
|
[
"func",
"(",
"ap",
"*",
"AuthPermission",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ap",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: does not exist\"",
")",
"\n",
"}",
"\n",
"if",
"ap",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"update failed: marked for deletion\"",
")",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`UPDATE auth_permission SET `",
"+",
"`content_type_id = ?, codename = ?, name = ?`",
"+",
"` WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ap",
".",
"ContentTypeID",
",",
"ap",
".",
"Codename",
",",
"ap",
".",
"Name",
",",
"ap",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ap",
".",
"ContentTypeID",
",",
"ap",
".",
"Codename",
",",
"ap",
".",
"Name",
",",
"ap",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Update updates the AuthPermission in the database.
|
[
"Update",
"updates",
"the",
"AuthPermission",
"in",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authpermission.xo.go#L68-L90
|
train
|
xo/xo
|
examples/django/sqlite3/authpermission.xo.go
|
Delete
|
func (ap *AuthPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ap._exists {
return nil
}
// if deleted, bail
if ap._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM auth_permission WHERE id = ?`
// run query
XOLog(sqlstr, ap.ID)
_, err = db.Exec(sqlstr, ap.ID)
if err != nil {
return err
}
// set deleted
ap._deleted = true
return nil
}
|
go
|
func (ap *AuthPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ap._exists {
return nil
}
// if deleted, bail
if ap._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM auth_permission WHERE id = ?`
// run query
XOLog(sqlstr, ap.ID)
_, err = db.Exec(sqlstr, ap.ID)
if err != nil {
return err
}
// set deleted
ap._deleted = true
return nil
}
|
[
"func",
"(",
"ap",
"*",
"AuthPermission",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"if",
"!",
"ap",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"ap",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"const",
"sqlstr",
"=",
"`DELETE FROM auth_permission WHERE id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ap",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ap",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"ap",
".",
"_deleted",
"=",
"true",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Delete deletes the AuthPermission from the database.
|
[
"Delete",
"deletes",
"the",
"AuthPermission",
"from",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authpermission.xo.go#L102-L129
|
train
|
xo/xo
|
examples/django/mysql/authgrouppermission.xo.go
|
Save
|
func (agp *AuthGroupPermission) Save(db XODB) error {
if agp.Exists() {
return agp.Update(db)
}
return agp.Insert(db)
}
|
go
|
func (agp *AuthGroupPermission) Save(db XODB) error {
if agp.Exists() {
return agp.Update(db)
}
return agp.Insert(db)
}
|
[
"func",
"(",
"agp",
"*",
"AuthGroupPermission",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"agp",
".",
"Exists",
"(",
")",
"{",
"return",
"agp",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n",
"return",
"agp",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] |
// Save saves the AuthGroupPermission to the database.
|
[
"Save",
"saves",
"the",
"AuthGroupPermission",
"to",
"the",
"database",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authgrouppermission.xo.go#L92-L98
|
train
|
xo/xo
|
examples/django/mysql/authgrouppermission.xo.go
|
AuthGroupPermissionsByPermissionID
|
func AuthGroupPermissionsByPermissionID(db XODB, permissionID int) ([]*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE permission_id = ?`
// run query
XOLog(sqlstr, permissionID)
q, err := db.Query(sqlstr, permissionID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthGroupPermission{}
for q.Next() {
agp := AuthGroupPermission{
_exists: true,
}
// scan
err = q.Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &agp)
}
return res, nil
}
|
go
|
func AuthGroupPermissionsByPermissionID(db XODB, permissionID int) ([]*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE permission_id = ?`
// run query
XOLog(sqlstr, permissionID)
q, err := db.Query(sqlstr, permissionID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthGroupPermission{}
for q.Next() {
agp := AuthGroupPermission{
_exists: true,
}
// scan
err = q.Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &agp)
}
return res, nil
}
|
[
"func",
"AuthGroupPermissionsByPermissionID",
"(",
"db",
"XODB",
",",
"permissionID",
"int",
")",
"(",
"[",
"]",
"*",
"AuthGroupPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, group_id, permission_id `",
"+",
"`FROM django.auth_group_permissions `",
"+",
"`WHERE permission_id = ?`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"permissionID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"permissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"AuthGroupPermission",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"agp",
":=",
"AuthGroupPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"agp",
".",
"ID",
",",
"&",
"agp",
".",
"GroupID",
",",
"&",
"agp",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"agp",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// AuthGroupPermissionsByPermissionID retrieves a row from 'django.auth_group_permissions' as a AuthGroupPermission.
//
// Generated from index 'auth_group_permissi_permission_id_84c5c92e_fk_auth_permission_id'.
|
[
"AuthGroupPermissionsByPermissionID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_group_permissions",
"as",
"a",
"AuthGroupPermission",
".",
"Generated",
"from",
"index",
"auth_group_permissi_permission_id_84c5c92e_fk_auth_permission_id",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authgrouppermission.xo.go#L147-L181
|
train
|
xo/xo
|
main.go
|
processArgs
|
func processArgs(args *internal.ArgType) error {
var err error
// get working directory
cwd, err := os.Getwd()
if err != nil {
return err
}
// determine out path
if args.Out == "" {
args.Path = cwd
} else {
// determine what to do with Out
fi, err := os.Stat(args.Out)
if err == nil && fi.IsDir() {
// out is directory
args.Path = args.Out
} else if err == nil && !fi.IsDir() {
// file exists (will truncate later)
args.Path = path.Dir(args.Out)
args.Filename = path.Base(args.Out)
// error if not split was set, but destination is not a directory
if !args.SingleFile {
return errors.New("output path is not directory")
}
} else if _, ok := err.(*os.PathError); ok {
// path error (ie, file doesn't exist yet)
args.Path = path.Dir(args.Out)
args.Filename = path.Base(args.Out)
// error if split was set, but dest doesn't exist
if !args.SingleFile {
return errors.New("output path must be a directory and already exist when not writing to a single file")
}
} else {
return err
}
}
// check user template path
if args.TemplatePath != "" {
fi, err := os.Stat(args.TemplatePath)
if err == nil && !fi.IsDir() {
return errors.New("template path is not directory")
} else if err != nil {
return errors.New("template path must exist")
}
}
// fix path
if args.Path == "." {
args.Path = cwd
}
// determine package name
if args.Package == "" {
args.Package = path.Base(args.Path)
}
// determine filename if not previously set
if args.Filename == "" {
args.Filename = args.Package + args.Suffix
}
// if query mode toggled, but no query, read Stdin.
if args.QueryMode && args.Query == "" {
buf, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return err
}
args.Query = string(buf)
}
// query mode parsing
if args.Query != "" {
args.QueryMode = true
}
// check that query type was specified
if args.QueryMode && args.QueryType == "" {
return errors.New("query type must be supplied for query parsing mode")
}
// query trim
if args.QueryMode && args.QueryTrim {
args.Query = strings.TrimSpace(args.Query)
}
// escape all
if args.EscapeAll {
args.EscapeSchemaName = true
args.EscapeTableNames = true
args.EscapeColumnNames = true
}
// if verbose
if args.Verbose {
models.XOLog = func(s string, p ...interface{}) {
fmt.Printf("SQL:\n%s\nPARAMS:\n%v\n\n", s, p)
}
}
return nil
}
|
go
|
func processArgs(args *internal.ArgType) error {
var err error
// get working directory
cwd, err := os.Getwd()
if err != nil {
return err
}
// determine out path
if args.Out == "" {
args.Path = cwd
} else {
// determine what to do with Out
fi, err := os.Stat(args.Out)
if err == nil && fi.IsDir() {
// out is directory
args.Path = args.Out
} else if err == nil && !fi.IsDir() {
// file exists (will truncate later)
args.Path = path.Dir(args.Out)
args.Filename = path.Base(args.Out)
// error if not split was set, but destination is not a directory
if !args.SingleFile {
return errors.New("output path is not directory")
}
} else if _, ok := err.(*os.PathError); ok {
// path error (ie, file doesn't exist yet)
args.Path = path.Dir(args.Out)
args.Filename = path.Base(args.Out)
// error if split was set, but dest doesn't exist
if !args.SingleFile {
return errors.New("output path must be a directory and already exist when not writing to a single file")
}
} else {
return err
}
}
// check user template path
if args.TemplatePath != "" {
fi, err := os.Stat(args.TemplatePath)
if err == nil && !fi.IsDir() {
return errors.New("template path is not directory")
} else if err != nil {
return errors.New("template path must exist")
}
}
// fix path
if args.Path == "." {
args.Path = cwd
}
// determine package name
if args.Package == "" {
args.Package = path.Base(args.Path)
}
// determine filename if not previously set
if args.Filename == "" {
args.Filename = args.Package + args.Suffix
}
// if query mode toggled, but no query, read Stdin.
if args.QueryMode && args.Query == "" {
buf, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return err
}
args.Query = string(buf)
}
// query mode parsing
if args.Query != "" {
args.QueryMode = true
}
// check that query type was specified
if args.QueryMode && args.QueryType == "" {
return errors.New("query type must be supplied for query parsing mode")
}
// query trim
if args.QueryMode && args.QueryTrim {
args.Query = strings.TrimSpace(args.Query)
}
// escape all
if args.EscapeAll {
args.EscapeSchemaName = true
args.EscapeTableNames = true
args.EscapeColumnNames = true
}
// if verbose
if args.Verbose {
models.XOLog = func(s string, p ...interface{}) {
fmt.Printf("SQL:\n%s\nPARAMS:\n%v\n\n", s, p)
}
}
return nil
}
|
[
"func",
"processArgs",
"(",
"args",
"*",
"internal",
".",
"ArgType",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"cwd",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"args",
".",
"Out",
"==",
"\"\"",
"{",
"args",
".",
"Path",
"=",
"cwd",
"\n",
"}",
"else",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"args",
".",
"Out",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"fi",
".",
"IsDir",
"(",
")",
"{",
"args",
".",
"Path",
"=",
"args",
".",
"Out",
"\n",
"}",
"else",
"if",
"err",
"==",
"nil",
"&&",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"args",
".",
"Path",
"=",
"path",
".",
"Dir",
"(",
"args",
".",
"Out",
")",
"\n",
"args",
".",
"Filename",
"=",
"path",
".",
"Base",
"(",
"args",
".",
"Out",
")",
"\n",
"if",
"!",
"args",
".",
"SingleFile",
"{",
"return",
"errors",
".",
"New",
"(",
"\"output path is not directory\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"ok",
"{",
"args",
".",
"Path",
"=",
"path",
".",
"Dir",
"(",
"args",
".",
"Out",
")",
"\n",
"args",
".",
"Filename",
"=",
"path",
".",
"Base",
"(",
"args",
".",
"Out",
")",
"\n",
"if",
"!",
"args",
".",
"SingleFile",
"{",
"return",
"errors",
".",
"New",
"(",
"\"output path must be a directory and already exist when not writing to a single file\"",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"args",
".",
"TemplatePath",
"!=",
"\"\"",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"args",
".",
"TemplatePath",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"template path is not directory\"",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"template path must exist\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"args",
".",
"Path",
"==",
"\".\"",
"{",
"args",
".",
"Path",
"=",
"cwd",
"\n",
"}",
"\n",
"if",
"args",
".",
"Package",
"==",
"\"\"",
"{",
"args",
".",
"Package",
"=",
"path",
".",
"Base",
"(",
"args",
".",
"Path",
")",
"\n",
"}",
"\n",
"if",
"args",
".",
"Filename",
"==",
"\"\"",
"{",
"args",
".",
"Filename",
"=",
"args",
".",
"Package",
"+",
"args",
".",
"Suffix",
"\n",
"}",
"\n",
"if",
"args",
".",
"QueryMode",
"&&",
"args",
".",
"Query",
"==",
"\"\"",
"{",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"os",
".",
"Stdin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"args",
".",
"Query",
"=",
"string",
"(",
"buf",
")",
"\n",
"}",
"\n",
"if",
"args",
".",
"Query",
"!=",
"\"\"",
"{",
"args",
".",
"QueryMode",
"=",
"true",
"\n",
"}",
"\n",
"if",
"args",
".",
"QueryMode",
"&&",
"args",
".",
"QueryType",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"query type must be supplied for query parsing mode\"",
")",
"\n",
"}",
"\n",
"if",
"args",
".",
"QueryMode",
"&&",
"args",
".",
"QueryTrim",
"{",
"args",
".",
"Query",
"=",
"strings",
".",
"TrimSpace",
"(",
"args",
".",
"Query",
")",
"\n",
"}",
"\n",
"if",
"args",
".",
"EscapeAll",
"{",
"args",
".",
"EscapeSchemaName",
"=",
"true",
"\n",
"args",
".",
"EscapeTableNames",
"=",
"true",
"\n",
"args",
".",
"EscapeColumnNames",
"=",
"true",
"\n",
"}",
"\n",
"if",
"args",
".",
"Verbose",
"{",
"models",
".",
"XOLog",
"=",
"func",
"(",
"s",
"string",
",",
"p",
"...",
"interface",
"{",
"}",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"SQL:\\n%s\\nPARAMS:\\n%v\\n\\n\"",
",",
"\\n",
",",
"\\n",
")",
"\n",
"}",
"\n",
"}",
"\n",
"\\n",
"\n",
"}"
] |
// processArgs processs cli args.
|
[
"processArgs",
"processs",
"cli",
"args",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/main.go#L100-L205
|
train
|
xo/xo
|
main.go
|
openDB
|
func openDB(args *internal.ArgType) error {
var err error
// parse dsn
u, err := dburl.Parse(args.DSN)
if err != nil {
return err
}
// save driver type
args.LoaderType = u.Driver
// grab loader
var ok bool
args.Loader, ok = internal.SchemaLoaders[u.Driver]
if !ok {
return errors.New("unsupported database type")
}
// open database connection
args.DB, err = sql.Open(u.Driver, u.DSN)
if err != nil {
return err
}
return nil
}
|
go
|
func openDB(args *internal.ArgType) error {
var err error
// parse dsn
u, err := dburl.Parse(args.DSN)
if err != nil {
return err
}
// save driver type
args.LoaderType = u.Driver
// grab loader
var ok bool
args.Loader, ok = internal.SchemaLoaders[u.Driver]
if !ok {
return errors.New("unsupported database type")
}
// open database connection
args.DB, err = sql.Open(u.Driver, u.DSN)
if err != nil {
return err
}
return nil
}
|
[
"func",
"openDB",
"(",
"args",
"*",
"internal",
".",
"ArgType",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"u",
",",
"err",
":=",
"dburl",
".",
"Parse",
"(",
"args",
".",
"DSN",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"args",
".",
"LoaderType",
"=",
"u",
".",
"Driver",
"\n",
"var",
"ok",
"bool",
"\n",
"args",
".",
"Loader",
",",
"ok",
"=",
"internal",
".",
"SchemaLoaders",
"[",
"u",
".",
"Driver",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"unsupported database type\"",
")",
"\n",
"}",
"\n",
"args",
".",
"DB",
",",
"err",
"=",
"sql",
".",
"Open",
"(",
"u",
".",
"Driver",
",",
"u",
".",
"DSN",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// openDB attempts to open a database connection.
|
[
"openDB",
"attempts",
"to",
"open",
"a",
"database",
"connection",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/main.go#L208-L234
|
train
|
xo/xo
|
main.go
|
getFile
|
func getFile(args *internal.ArgType, t *internal.TBuf) (*os.File, error) {
var f *os.File
var err error
// determine filename
var filename = strings.ToLower(t.Name) + args.Suffix
if args.SingleFile {
filename = args.Filename
}
filename = path.Join(args.Path, filename)
// lookup file
f, ok := files[filename]
if ok {
return f, nil
}
// default open mode
mode := os.O_RDWR | os.O_CREATE | os.O_TRUNC
// stat file to determine if file already exists
fi, err := os.Stat(filename)
if err == nil && fi.IsDir() {
return nil, errors.New("filename cannot be directory")
} else if _, ok = err.(*os.PathError); !ok && args.Append && t.TemplateType != internal.XOTemplate {
// file exists so append if append is set and not XO type
mode = os.O_APPEND | os.O_WRONLY
}
// skip
if t.TemplateType == internal.XOTemplate && fi != nil {
return nil, nil
}
// open file
f, err = os.OpenFile(filename, mode, 0666)
if err != nil {
return nil, err
}
// file didn't originally exist, so add package header
if fi == nil || !args.Append {
// add build tags
if args.Tags != "" {
f.WriteString(`// +build ` + args.Tags + "\n\n")
}
// execute
err = args.TemplateSet().Execute(f, "xo_package.go.tpl", args)
if err != nil {
return nil, err
}
}
// store file
files[filename] = f
return f, nil
}
|
go
|
func getFile(args *internal.ArgType, t *internal.TBuf) (*os.File, error) {
var f *os.File
var err error
// determine filename
var filename = strings.ToLower(t.Name) + args.Suffix
if args.SingleFile {
filename = args.Filename
}
filename = path.Join(args.Path, filename)
// lookup file
f, ok := files[filename]
if ok {
return f, nil
}
// default open mode
mode := os.O_RDWR | os.O_CREATE | os.O_TRUNC
// stat file to determine if file already exists
fi, err := os.Stat(filename)
if err == nil && fi.IsDir() {
return nil, errors.New("filename cannot be directory")
} else if _, ok = err.(*os.PathError); !ok && args.Append && t.TemplateType != internal.XOTemplate {
// file exists so append if append is set and not XO type
mode = os.O_APPEND | os.O_WRONLY
}
// skip
if t.TemplateType == internal.XOTemplate && fi != nil {
return nil, nil
}
// open file
f, err = os.OpenFile(filename, mode, 0666)
if err != nil {
return nil, err
}
// file didn't originally exist, so add package header
if fi == nil || !args.Append {
// add build tags
if args.Tags != "" {
f.WriteString(`// +build ` + args.Tags + "\n\n")
}
// execute
err = args.TemplateSet().Execute(f, "xo_package.go.tpl", args)
if err != nil {
return nil, err
}
}
// store file
files[filename] = f
return f, nil
}
|
[
"func",
"getFile",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"t",
"*",
"internal",
".",
"TBuf",
")",
"(",
"*",
"os",
".",
"File",
",",
"error",
")",
"{",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"var",
"err",
"error",
"\n",
"var",
"filename",
"=",
"strings",
".",
"ToLower",
"(",
"t",
".",
"Name",
")",
"+",
"args",
".",
"Suffix",
"\n",
"if",
"args",
".",
"SingleFile",
"{",
"filename",
"=",
"args",
".",
"Filename",
"\n",
"}",
"\n",
"filename",
"=",
"path",
".",
"Join",
"(",
"args",
".",
"Path",
",",
"filename",
")",
"\n",
"f",
",",
"ok",
":=",
"files",
"[",
"filename",
"]",
"\n",
"if",
"ok",
"{",
"return",
"f",
",",
"nil",
"\n",
"}",
"\n",
"mode",
":=",
"os",
".",
"O_RDWR",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
"\n",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filename",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"filename cannot be directory\"",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
"=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"!",
"ok",
"&&",
"args",
".",
"Append",
"&&",
"t",
".",
"TemplateType",
"!=",
"internal",
".",
"XOTemplate",
"{",
"mode",
"=",
"os",
".",
"O_APPEND",
"|",
"os",
".",
"O_WRONLY",
"\n",
"}",
"\n",
"if",
"t",
".",
"TemplateType",
"==",
"internal",
".",
"XOTemplate",
"&&",
"fi",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"f",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"filename",
",",
"mode",
",",
"0666",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"fi",
"==",
"nil",
"||",
"!",
"args",
".",
"Append",
"{",
"if",
"args",
".",
"Tags",
"!=",
"\"\"",
"{",
"f",
".",
"WriteString",
"(",
"`// +build `",
"+",
"args",
".",
"Tags",
"+",
"\"\\n\\n\"",
")",
"\n",
"}",
"\n",
"\\n",
"\n",
"\\n",
"\n",
"}",
"\n",
"err",
"=",
"args",
".",
"TemplateSet",
"(",
")",
".",
"Execute",
"(",
"f",
",",
"\"xo_package.go.tpl\"",
",",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] |
// getFile builds the filepath from the TBuf information, and retrieves the
// file from files. If the built filename is not already defined, then it calls
// the os.OpenFile with the correct parameters depending on the state of args.
|
[
"getFile",
"builds",
"the",
"filepath",
"from",
"the",
"TBuf",
"information",
"and",
"retrieves",
"the",
"file",
"from",
"files",
".",
"If",
"the",
"built",
"filename",
"is",
"not",
"already",
"defined",
"then",
"it",
"calls",
"the",
"os",
".",
"OpenFile",
"with",
"the",
"correct",
"parameters",
"depending",
"on",
"the",
"state",
"of",
"args",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/main.go#L242-L300
|
train
|
xo/xo
|
main.go
|
writeTypes
|
func writeTypes(args *internal.ArgType) error {
var err error
out := internal.TBufSlice(args.Generated)
// sort segments
sort.Sort(out)
// loop, writing in order
for _, t := range out {
var f *os.File
// skip when in append and type is XO
if args.Append && t.TemplateType == internal.XOTemplate {
continue
}
// check if generated template is only whitespace/empty
bufStr := strings.TrimSpace(t.Buf.String())
if len(bufStr) == 0 {
continue
}
// get file and filename
f, err = getFile(args, &t)
if err != nil {
return err
}
// should only be nil when type == xo
if f == nil {
continue
}
// write segment
if !args.Append || (t.TemplateType != internal.TypeTemplate && t.TemplateType != internal.QueryTypeTemplate) {
_, err = t.Buf.WriteTo(f)
if err != nil {
return err
}
}
}
// build goimports parameters, closing files
params := []string{"-w"}
for k, f := range files {
params = append(params, k)
// close
err = f.Close()
if err != nil {
return err
}
}
// process written files with goimports
output, err := exec.Command("goimports", params...).CombinedOutput()
if err != nil {
return errors.New(string(output))
}
return nil
}
|
go
|
func writeTypes(args *internal.ArgType) error {
var err error
out := internal.TBufSlice(args.Generated)
// sort segments
sort.Sort(out)
// loop, writing in order
for _, t := range out {
var f *os.File
// skip when in append and type is XO
if args.Append && t.TemplateType == internal.XOTemplate {
continue
}
// check if generated template is only whitespace/empty
bufStr := strings.TrimSpace(t.Buf.String())
if len(bufStr) == 0 {
continue
}
// get file and filename
f, err = getFile(args, &t)
if err != nil {
return err
}
// should only be nil when type == xo
if f == nil {
continue
}
// write segment
if !args.Append || (t.TemplateType != internal.TypeTemplate && t.TemplateType != internal.QueryTypeTemplate) {
_, err = t.Buf.WriteTo(f)
if err != nil {
return err
}
}
}
// build goimports parameters, closing files
params := []string{"-w"}
for k, f := range files {
params = append(params, k)
// close
err = f.Close()
if err != nil {
return err
}
}
// process written files with goimports
output, err := exec.Command("goimports", params...).CombinedOutput()
if err != nil {
return errors.New(string(output))
}
return nil
}
|
[
"func",
"writeTypes",
"(",
"args",
"*",
"internal",
".",
"ArgType",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"out",
":=",
"internal",
".",
"TBufSlice",
"(",
"args",
".",
"Generated",
")",
"\n",
"sort",
".",
"Sort",
"(",
"out",
")",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"out",
"{",
"var",
"f",
"*",
"os",
".",
"File",
"\n",
"if",
"args",
".",
"Append",
"&&",
"t",
".",
"TemplateType",
"==",
"internal",
".",
"XOTemplate",
"{",
"continue",
"\n",
"}",
"\n",
"bufStr",
":=",
"strings",
".",
"TrimSpace",
"(",
"t",
".",
"Buf",
".",
"String",
"(",
")",
")",
"\n",
"if",
"len",
"(",
"bufStr",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"f",
",",
"err",
"=",
"getFile",
"(",
"args",
",",
"&",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"f",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"args",
".",
"Append",
"||",
"(",
"t",
".",
"TemplateType",
"!=",
"internal",
".",
"TypeTemplate",
"&&",
"t",
".",
"TemplateType",
"!=",
"internal",
".",
"QueryTypeTemplate",
")",
"{",
"_",
",",
"err",
"=",
"t",
".",
"Buf",
".",
"WriteTo",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"params",
":=",
"[",
"]",
"string",
"{",
"\"-w\"",
"}",
"\n",
"for",
"k",
",",
"f",
":=",
"range",
"files",
"{",
"params",
"=",
"append",
"(",
"params",
",",
"k",
")",
"\n",
"err",
"=",
"f",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"output",
",",
"err",
":=",
"exec",
".",
"Command",
"(",
"\"goimports\"",
",",
"params",
"...",
")",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"string",
"(",
"output",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// writeTypes writes the generated definitions.
|
[
"writeTypes",
"writes",
"the",
"generated",
"definitions",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/main.go#L303-L365
|
train
|
xo/xo
|
models/myautoincrement.xo.go
|
MyAutoIncrements
|
func MyAutoIncrements(db XODB, schema string) ([]*MyAutoIncrement, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`table_name ` +
`FROM information_schema.tables ` +
`WHERE auto_increment IS NOT null AND table_schema = ?`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MyAutoIncrement{}
for q.Next() {
mai := MyAutoIncrement{}
// scan
err = q.Scan(&mai.TableName)
if err != nil {
return nil, err
}
res = append(res, &mai)
}
return res, nil
}
|
go
|
func MyAutoIncrements(db XODB, schema string) ([]*MyAutoIncrement, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`table_name ` +
`FROM information_schema.tables ` +
`WHERE auto_increment IS NOT null AND table_schema = ?`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MyAutoIncrement{}
for q.Next() {
mai := MyAutoIncrement{}
// scan
err = q.Scan(&mai.TableName)
if err != nil {
return nil, err
}
res = append(res, &mai)
}
return res, nil
}
|
[
"func",
"MyAutoIncrements",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"MyAutoIncrement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`table_name `",
"+",
"`FROM information_schema.tables `",
"+",
"`WHERE auto_increment IS NOT null AND table_schema = ?`",
"\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",
":=",
"[",
"]",
"*",
"MyAutoIncrement",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"mai",
":=",
"MyAutoIncrement",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"mai",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"mai",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// MyAutoIncrements runs a custom query, returning results as MyAutoIncrement.
|
[
"MyAutoIncrements",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"MyAutoIncrement",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/myautoincrement.xo.go#L12-L44
|
train
|
xo/xo
|
models/sqautoincrement.xo.go
|
SqAutoIncrements
|
func SqAutoIncrements(db XODB) ([]*SqAutoIncrement, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`name as table_name, sql ` +
`FROM sqlite_master ` +
`WHERE type='table' ` +
`ORDER BY name`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqAutoIncrement{}
for q.Next() {
sai := SqAutoIncrement{}
// scan
err = q.Scan(&sai.TableName, &sai.SQL)
if err != nil {
return nil, err
}
res = append(res, &sai)
}
return res, nil
}
|
go
|
func SqAutoIncrements(db XODB) ([]*SqAutoIncrement, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`name as table_name, sql ` +
`FROM sqlite_master ` +
`WHERE type='table' ` +
`ORDER BY name`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqAutoIncrement{}
for q.Next() {
sai := SqAutoIncrement{}
// scan
err = q.Scan(&sai.TableName, &sai.SQL)
if err != nil {
return nil, err
}
res = append(res, &sai)
}
return res, nil
}
|
[
"func",
"SqAutoIncrements",
"(",
"db",
"XODB",
")",
"(",
"[",
"]",
"*",
"SqAutoIncrement",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`name as table_name, sql `",
"+",
"`FROM sqlite_master `",
"+",
"`WHERE type='table' `",
"+",
"`ORDER BY name`",
"\n",
"XOLog",
"(",
"sqlstr",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"SqAutoIncrement",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"sai",
":=",
"SqAutoIncrement",
"{",
"}",
"\n",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"sai",
".",
"TableName",
",",
"&",
"sai",
".",
"SQL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"sai",
")",
"\n",
"}",
"\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// SqAutoIncrements runs a custom query, returning results as SqAutoIncrement.
|
[
"SqAutoIncrements",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"SqAutoIncrement",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/sqautoincrement.xo.go#L13-L46
|
train
|
xo/xo
|
internal/util.go
|
fmtIndexName
|
func fmtIndexName(ixName string, tableName string) string {
// chop off _ix, _idx, _index, _pkey, or _key
m := IndexChopSuffixRE.FindStringIndex(ixName)
if m != nil {
ixName = ixName[:m[0]]
}
// check tableName
if ixName == tableName {
return ""
}
// chop off tablename_
if strings.HasPrefix(ixName, tableName+"_") {
ixName = ixName[len(tableName)+1:]
}
// camel case name
return snaker.SnakeToCamelIdentifier(ixName)
}
|
go
|
func fmtIndexName(ixName string, tableName string) string {
// chop off _ix, _idx, _index, _pkey, or _key
m := IndexChopSuffixRE.FindStringIndex(ixName)
if m != nil {
ixName = ixName[:m[0]]
}
// check tableName
if ixName == tableName {
return ""
}
// chop off tablename_
if strings.HasPrefix(ixName, tableName+"_") {
ixName = ixName[len(tableName)+1:]
}
// camel case name
return snaker.SnakeToCamelIdentifier(ixName)
}
|
[
"func",
"fmtIndexName",
"(",
"ixName",
"string",
",",
"tableName",
"string",
")",
"string",
"{",
"m",
":=",
"IndexChopSuffixRE",
".",
"FindStringIndex",
"(",
"ixName",
")",
"\n",
"if",
"m",
"!=",
"nil",
"{",
"ixName",
"=",
"ixName",
"[",
":",
"m",
"[",
"0",
"]",
"]",
"\n",
"}",
"\n",
"if",
"ixName",
"==",
"tableName",
"{",
"return",
"\"\"",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"ixName",
",",
"tableName",
"+",
"\"_\"",
")",
"{",
"ixName",
"=",
"ixName",
"[",
"len",
"(",
"tableName",
")",
"+",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"ixName",
")",
"\n",
"}"
] |
// fmtIndexName formats the index name.
|
[
"fmtIndexName",
"formats",
"the",
"index",
"name",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/util.go#L137-L156
|
train
|
xo/xo
|
internal/util.go
|
BuildIndexFuncName
|
func (a *ArgType) BuildIndexFuncName(ixTpl *Index) {
// build func name
funcName := ixTpl.Type.Name
if !ixTpl.Index.IsUnique {
funcName = inflector.Pluralize(ixTpl.Type.Name)
}
funcName = funcName + "By"
// add param names
paramNames := []string{}
ixName := fmtIndexName(ixTpl.Index.IndexName, ixTpl.Type.Table.TableName)
if a.UseIndexNames && ixName != "" {
paramNames = append(paramNames, ixName)
} else {
for _, f := range ixTpl.Fields {
paramNames = append(paramNames, f.Name)
}
}
// store resulting name back
ixTpl.FuncName = funcName + strings.Join(paramNames, "")
}
|
go
|
func (a *ArgType) BuildIndexFuncName(ixTpl *Index) {
// build func name
funcName := ixTpl.Type.Name
if !ixTpl.Index.IsUnique {
funcName = inflector.Pluralize(ixTpl.Type.Name)
}
funcName = funcName + "By"
// add param names
paramNames := []string{}
ixName := fmtIndexName(ixTpl.Index.IndexName, ixTpl.Type.Table.TableName)
if a.UseIndexNames && ixName != "" {
paramNames = append(paramNames, ixName)
} else {
for _, f := range ixTpl.Fields {
paramNames = append(paramNames, f.Name)
}
}
// store resulting name back
ixTpl.FuncName = funcName + strings.Join(paramNames, "")
}
|
[
"func",
"(",
"a",
"*",
"ArgType",
")",
"BuildIndexFuncName",
"(",
"ixTpl",
"*",
"Index",
")",
"{",
"funcName",
":=",
"ixTpl",
".",
"Type",
".",
"Name",
"\n",
"if",
"!",
"ixTpl",
".",
"Index",
".",
"IsUnique",
"{",
"funcName",
"=",
"inflector",
".",
"Pluralize",
"(",
"ixTpl",
".",
"Type",
".",
"Name",
")",
"\n",
"}",
"\n",
"funcName",
"=",
"funcName",
"+",
"\"By\"",
"\n",
"paramNames",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"ixName",
":=",
"fmtIndexName",
"(",
"ixTpl",
".",
"Index",
".",
"IndexName",
",",
"ixTpl",
".",
"Type",
".",
"Table",
".",
"TableName",
")",
"\n",
"if",
"a",
".",
"UseIndexNames",
"&&",
"ixName",
"!=",
"\"\"",
"{",
"paramNames",
"=",
"append",
"(",
"paramNames",
",",
"ixName",
")",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"ixTpl",
".",
"Fields",
"{",
"paramNames",
"=",
"append",
"(",
"paramNames",
",",
"f",
".",
"Name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"ixTpl",
".",
"FuncName",
"=",
"funcName",
"+",
"strings",
".",
"Join",
"(",
"paramNames",
",",
"\"\"",
")",
"\n",
"}"
] |
// BuildIndexFuncName builds the index func name for an index and its supplied
// fields.
|
[
"BuildIndexFuncName",
"builds",
"the",
"index",
"func",
"name",
"for",
"an",
"index",
"and",
"its",
"supplied",
"fields",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/util.go#L160-L182
|
train
|
xo/xo
|
internal/util.go
|
reverseIndexRune
|
func reverseIndexRune(s string, r rune) int {
if s == "" {
return -1
}
rs := []rune(s)
for i := len(rs) - 1; i >= 0; i-- {
if rs[i] == r {
return i
}
}
return -1
}
|
go
|
func reverseIndexRune(s string, r rune) int {
if s == "" {
return -1
}
rs := []rune(s)
for i := len(rs) - 1; i >= 0; i-- {
if rs[i] == r {
return i
}
}
return -1
}
|
[
"func",
"reverseIndexRune",
"(",
"s",
"string",
",",
"r",
"rune",
")",
"int",
"{",
"if",
"s",
"==",
"\"\"",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"rs",
":=",
"[",
"]",
"rune",
"(",
"s",
")",
"\n",
"for",
"i",
":=",
"len",
"(",
"rs",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"if",
"rs",
"[",
"i",
"]",
"==",
"r",
"{",
"return",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"-",
"1",
"\n",
"}"
] |
// reverseIndexRune finds the last rune r in s, returning -1 if not present.
|
[
"reverseIndexRune",
"finds",
"the",
"last",
"rune",
"r",
"in",
"s",
"returning",
"-",
"1",
"if",
"not",
"present",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/util.go#L198-L211
|
train
|
xo/xo
|
internal/util.go
|
SingularizeIdentifier
|
func SingularizeIdentifier(s string) string {
if i := reverseIndexRune(s, '_'); i != -1 {
s = s[:i] + "_" + inflector.Singularize(s[i+1:])
} else {
s = inflector.Singularize(s)
}
return snaker.SnakeToCamelIdentifier(s)
}
|
go
|
func SingularizeIdentifier(s string) string {
if i := reverseIndexRune(s, '_'); i != -1 {
s = s[:i] + "_" + inflector.Singularize(s[i+1:])
} else {
s = inflector.Singularize(s)
}
return snaker.SnakeToCamelIdentifier(s)
}
|
[
"func",
"SingularizeIdentifier",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"i",
":=",
"reverseIndexRune",
"(",
"s",
",",
"'_'",
")",
";",
"i",
"!=",
"-",
"1",
"{",
"s",
"=",
"s",
"[",
":",
"i",
"]",
"+",
"\"_\"",
"+",
"inflector",
".",
"Singularize",
"(",
"s",
"[",
"i",
"+",
"1",
":",
"]",
")",
"\n",
"}",
"else",
"{",
"s",
"=",
"inflector",
".",
"Singularize",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"s",
")",
"\n",
"}"
] |
// SinguralizeIdentifier will singularize a identifier, returning it in
// CamelCase.
|
[
"SinguralizeIdentifier",
"will",
"singularize",
"a",
"identifier",
"returning",
"it",
"in",
"CamelCase",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/util.go#L215-L223
|
train
|
xo/xo
|
loaders/sqlite.go
|
SqParseType
|
func SqParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
unsigned := false
dt = strings.ToLower(dt)
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
if uRE.MatchString(dt) {
unsigned = true
uRE.ReplaceAllString(dt, "")
}
var typ string
switch dt {
case "bool", "boolean":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "int", "integer", "tinyint", "smallint", "mediumint", "bigint":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "numeric", "real", "double", "float", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "blob":
typ = "[]byte"
case "timestamp", "datetime", "date", "timestamp with time zone", "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "xoutil.SqTime{}"
typ = "xoutil.SqTime"
default:
// case "varchar", "character", "varying character", "nchar", "native character", "nvarchar", "text", "clob", "datetime", "date", "time":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
}
// if unsigned ...
if internal.IntRE.MatchString(typ) && unsigned {
typ = "u" + typ
}
return precision, nilVal, typ
}
|
go
|
func SqParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
unsigned := false
dt = strings.ToLower(dt)
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
if uRE.MatchString(dt) {
unsigned = true
uRE.ReplaceAllString(dt, "")
}
var typ string
switch dt {
case "bool", "boolean":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "int", "integer", "tinyint", "smallint", "mediumint", "bigint":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "numeric", "real", "double", "float", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "blob":
typ = "[]byte"
case "timestamp", "datetime", "date", "timestamp with time zone", "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "xoutil.SqTime{}"
typ = "xoutil.SqTime"
default:
// case "varchar", "character", "varying character", "nchar", "native character", "nvarchar", "text", "clob", "datetime", "date", "time":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
}
// if unsigned ...
if internal.IntRE.MatchString(typ) && unsigned {
typ = "u" + typ
}
return precision, nilVal, typ
}
|
[
"func",
"SqParseType",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"dt",
"string",
",",
"nullable",
"bool",
")",
"(",
"int",
",",
"string",
",",
"string",
")",
"{",
"precision",
":=",
"0",
"\n",
"nilVal",
":=",
"\"nil\"",
"\n",
"unsigned",
":=",
"false",
"\n",
"dt",
"=",
"strings",
".",
"ToLower",
"(",
"dt",
")",
"\n",
"dt",
",",
"precision",
",",
"_",
"=",
"args",
".",
"ParsePrecision",
"(",
"dt",
")",
"\n",
"if",
"uRE",
".",
"MatchString",
"(",
"dt",
")",
"{",
"unsigned",
"=",
"true",
"\n",
"uRE",
".",
"ReplaceAllString",
"(",
"dt",
",",
"\"\"",
")",
"\n",
"}",
"\n",
"var",
"typ",
"string",
"\n",
"switch",
"dt",
"{",
"case",
"\"bool\"",
",",
"\"boolean\"",
":",
"nilVal",
"=",
"\"false\"",
"\n",
"typ",
"=",
"\"bool\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullBool{}\"",
"\n",
"typ",
"=",
"\"sql.NullBool\"",
"\n",
"}",
"\n",
"case",
"\"int\"",
",",
"\"integer\"",
",",
"\"tinyint\"",
",",
"\"smallint\"",
",",
"\"mediumint\"",
",",
"\"bigint\"",
":",
"nilVal",
"=",
"\"0\"",
"\n",
"typ",
"=",
"args",
".",
"Int32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullInt64{}\"",
"\n",
"typ",
"=",
"\"sql.NullInt64\"",
"\n",
"}",
"\n",
"case",
"\"numeric\"",
",",
"\"real\"",
",",
"\"double\"",
",",
"\"float\"",
",",
"\"decimal\"",
":",
"nilVal",
"=",
"\"0.0\"",
"\n",
"typ",
"=",
"\"float64\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullFloat64{}\"",
"\n",
"typ",
"=",
"\"sql.NullFloat64\"",
"\n",
"}",
"\n",
"case",
"\"blob\"",
":",
"typ",
"=",
"\"[]byte\"",
"\n",
"case",
"\"timestamp\"",
",",
"\"datetime\"",
",",
"\"date\"",
",",
"\"timestamp with time zone\"",
",",
"\"time with time zone\"",
",",
"\"time without time zone\"",
",",
"\"timestamp without time zone\"",
":",
"nilVal",
"=",
"\"xoutil.SqTime{}\"",
"\n",
"typ",
"=",
"\"xoutil.SqTime\"",
"\n",
"default",
":",
"nilVal",
"=",
"`\"\"`",
"\n",
"typ",
"=",
"\"string\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"sql.NullString{}\"",
"\n",
"typ",
"=",
"\"sql.NullString\"",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"internal",
".",
"IntRE",
".",
"MatchString",
"(",
"typ",
")",
"&&",
"unsigned",
"{",
"typ",
"=",
"\"u\"",
"+",
"typ",
"\n",
"}",
"\n",
"return",
"precision",
",",
"nilVal",
",",
"typ",
"\n",
"}"
] |
// SqParseType parse a sqlite type into a Go type based on the column
// definition.
|
[
"SqParseType",
"parse",
"a",
"sqlite",
"type",
"into",
"a",
"Go",
"type",
"based",
"on",
"the",
"column",
"definition",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/sqlite.go#L52-L116
|
train
|
xo/xo
|
loaders/sqlite.go
|
SqTables
|
func SqTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.SqTables(db, relkind)
if err != nil {
return nil, err
}
// get the SQL for the Autoincrement detection
autoIncrements, err := models.SqAutoIncrements(db)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.SqAutoIncrement{}
}
// 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
// keyword for the given table in the SQL.
for _, autoInc := range autoIncrements {
lSQL := strings.ToLower(autoInc.SQL)
if autoInc.TableName == row.TableName && strings.Contains(lSQL, "autoincrement") {
manualPk = false
} else {
cols, err := SqTableColumns(db, schema, row.TableName)
if err != nil {
return nil, err
}
for _, col := range cols {
if col.IsPrimaryKey == true {
dt := strings.ToUpper(col.DataType)
if dt == "INTEGER" {
manualPk = false
}
break
}
}
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
go
|
func SqTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.SqTables(db, relkind)
if err != nil {
return nil, err
}
// get the SQL for the Autoincrement detection
autoIncrements, err := models.SqAutoIncrements(db)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.SqAutoIncrement{}
}
// 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
// keyword for the given table in the SQL.
for _, autoInc := range autoIncrements {
lSQL := strings.ToLower(autoInc.SQL)
if autoInc.TableName == row.TableName && strings.Contains(lSQL, "autoincrement") {
manualPk = false
} else {
cols, err := SqTableColumns(db, schema, row.TableName)
if err != nil {
return nil, err
}
for _, col := range cols {
if col.IsPrimaryKey == true {
dt := strings.ToUpper(col.DataType)
if dt == "INTEGER" {
manualPk = false
}
break
}
}
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
}
|
[
"func",
"SqTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"rows",
",",
"err",
":=",
"models",
".",
"SqTables",
"(",
"db",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"autoIncrements",
",",
"err",
":=",
"models",
".",
"SqAutoIncrements",
"(",
"db",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"autoIncrements",
"=",
"[",
"]",
"*",
"models",
".",
"SqAutoIncrement",
"{",
"}",
"\n",
"}",
"\n",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"for",
"_",
",",
"autoInc",
":=",
"range",
"autoIncrements",
"{",
"lSQL",
":=",
"strings",
".",
"ToLower",
"(",
"autoInc",
".",
"SQL",
")",
"\n",
"if",
"autoInc",
".",
"TableName",
"==",
"row",
".",
"TableName",
"&&",
"strings",
".",
"Contains",
"(",
"lSQL",
",",
"\"autoincrement\"",
")",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"else",
"{",
"cols",
",",
"err",
":=",
"SqTableColumns",
"(",
"db",
",",
"schema",
",",
"row",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"col",
":=",
"range",
"cols",
"{",
"if",
"col",
".",
"IsPrimaryKey",
"==",
"true",
"{",
"dt",
":=",
"strings",
".",
"ToUpper",
"(",
"col",
".",
"DataType",
")",
"\n",
"if",
"dt",
"==",
"\"INTEGER\"",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] |
// SqTables returns the sqlite tables with the manual PK information added.
// ManualPk is true when the table's primary key is not autoincrement.
|
[
"SqTables",
"returns",
"the",
"sqlite",
"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/sqlite.go#L120-L170
|
train
|
xo/xo
|
loaders/sqlite.go
|
SqTableColumns
|
func SqTableColumns(db models.XODB, schema string, table string) ([]*models.Column, error) {
var err error
// grab
rows, err := models.SqTableColumns(db, table)
if err != nil {
return nil, err
}
// fix columns
var cols []*models.Column
for _, row := range rows {
cols = append(cols, &models.Column{
FieldOrdinal: row.FieldOrdinal,
ColumnName: row.ColumnName,
DataType: row.DataType,
NotNull: row.NotNull,
DefaultValue: row.DefaultValue,
IsPrimaryKey: row.PkColIndex != 0,
})
}
return cols, nil
}
|
go
|
func SqTableColumns(db models.XODB, schema string, table string) ([]*models.Column, error) {
var err error
// grab
rows, err := models.SqTableColumns(db, table)
if err != nil {
return nil, err
}
// fix columns
var cols []*models.Column
for _, row := range rows {
cols = append(cols, &models.Column{
FieldOrdinal: row.FieldOrdinal,
ColumnName: row.ColumnName,
DataType: row.DataType,
NotNull: row.NotNull,
DefaultValue: row.DefaultValue,
IsPrimaryKey: row.PkColIndex != 0,
})
}
return cols, nil
}
|
[
"func",
"SqTableColumns",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"rows",
",",
"err",
":=",
"models",
".",
"SqTableColumns",
"(",
"db",
",",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"cols",
"[",
"]",
"*",
"models",
".",
"Column",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"cols",
"=",
"append",
"(",
"cols",
",",
"&",
"models",
".",
"Column",
"{",
"FieldOrdinal",
":",
"row",
".",
"FieldOrdinal",
",",
"ColumnName",
":",
"row",
".",
"ColumnName",
",",
"DataType",
":",
"row",
".",
"DataType",
",",
"NotNull",
":",
"row",
".",
"NotNull",
",",
"DefaultValue",
":",
"row",
".",
"DefaultValue",
",",
"IsPrimaryKey",
":",
"row",
".",
"PkColIndex",
"!=",
"0",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"cols",
",",
"nil",
"\n",
"}"
] |
// SqTableColumns returns the sqlite table column info.
|
[
"SqTableColumns",
"returns",
"the",
"sqlite",
"table",
"column",
"info",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/sqlite.go#L173-L196
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.