_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q22800 | PgTsTemplateByTmplnameTmplnamespace | train | 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 ` +
... | go | {
"resource": ""
} |
q22801 | PgTypeByOid | train | 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, ... | go | {
"resource": ""
} |
q22802 | PgUserMappingByOid | train | 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 := PgUse... | go | {
"resource": ""
} |
q22803 | Scan | train | 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(s... | go | {
"resource": ""
} |
q22804 | Value | train | 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 | {
"resource": ""
} |
q22805 | Save | train | func (dct *DjangoContentType) Save(db XODB) error {
if dct.Exists() {
return dct.Update(db)
}
return dct.Insert(db)
} | go | {
"resource": ""
} |
q22806 | DjangoContentTypeByAppLabelModel | train | 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)
d... | go | {
"resource": ""
} |
q22807 | Save | train | func (ag *AuthGroup) Save(db XODB) error {
if ag.Exists() {
return ag.Update(db)
}
return ag.Insert(db)
} | go | {
"resource": ""
} |
q22808 | AuthGroupByID | train | 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... | go | {
"resource": ""
} |
q22809 | Save | train | func (ds *DjangoSession) Save(db XODB) error {
if ds.Exists() {
return ds.Update(db)
}
return ds.Insert(db)
} | go | {
"resource": ""
} |
q22810 | Delete | train | 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)
_,... | go | {
"resource": ""
} |
q22811 | Save | train | func (ap *AuthPermission) Save(db XODB) error {
if ap.Exists() {
return ap.Update(db)
}
return ap.Insert(db)
} | go | {
"resource": ""
} |
q22812 | AuthPermissionsByContentTypeID | train | 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 := ... | go | {
"resource": ""
} |
q22813 | PgGetColOrder | train | 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... | go | {
"resource": ""
} |
q22814 | NewTemplateFuncs | train | 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.colprefixnam... | go | {
"resource": ""
} |
q22815 | colcount | train | 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 | {
"resource": ""
} |
q22816 | schemafn | train | 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 =... | go | {
"resource": ""
} |
q22817 | colname | train | func (a *ArgType) colname(col *models.Column) string {
if a.EscapeColumnNames {
return a.Loader.Escape(ColumnEsc, col.ColumnName)
}
return col.ColumnName
} | go | {
"resource": ""
} |
q22818 | hascolumn | train | func (a *ArgType) hascolumn(fields []*Field, name string) bool {
for _, f := range fields {
if f.Col.ColumnName == name {
return true
}
}
return false
} | go | {
"resource": ""
} |
q22819 | hasfield | train | func (a *ArgType) hasfield(fields []*Field, name string) bool {
for _, f := range fields {
if f.Name == name {
return true
}
}
return false
} | go | {
"resource": ""
} |
q22820 | getstartcount | train | func (a *ArgType) getstartcount(fields []*Field, pkFields []*Field) int {
return len(fields) - len(pkFields)
} | go | {
"resource": ""
} |
q22821 | PgEnums | train | 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... | go | {
"resource": ""
} |
q22822 | String | train | 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... | go | {
"resource": ""
} |
q22823 | String | train | 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 | {
"resource": ""
} |
q22824 | Save | train | func (dal *DjangoAdminLog) Save(db XODB) error {
if dal.Exists() {
return dal.Update(db)
}
return dal.Insert(db)
} | go | {
"resource": ""
} |
q22825 | DjangoAdminLogsByUserID | train | 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
XO... | go | {
"resource": ""
} |
q22826 | Save | train | func (au *AuthUser) Save(db XODB) error {
if au.Exists() {
return au.Update(db)
}
return au.Insert(db)
} | go | {
"resource": ""
} |
q22827 | DjangoAdminLogByID | train | 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 := Djan... | go | {
"resource": ""
} |
q22828 | AuthGroupsByName | train | 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()
/... | go | {
"resource": ""
} |
q22829 | AuthGroupByName | train | 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)
... | go | {
"resource": ""
} |
q22830 | PgTableIndexes | train | 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_n... | go | {
"resource": ""
} |
q22831 | MsTables | train | 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(sql... | go | {
"resource": ""
} |
q22832 | PgEnumValues | train | 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 ` +
`LE... | go | {
"resource": ""
} |
q22833 | OrParseType | train | 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, "") {... | go | {
"resource": ""
} |
q22834 | PgIndexColumns | train | 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_clas... | go | {
"resource": ""
} |
q22835 | PgTableForeignKeys | train | 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, ` + // ::varcha... | go | {
"resource": ""
} |
q22836 | MsTableForeignKeys | train | 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 sysob... | go | {
"resource": ""
} |
q22837 | Update | train | 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_permissi... | go | {
"resource": ""
} |
q22838 | Delete | train | 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, ... | go | {
"resource": ""
} |
q22839 | Save | train | func (agp *AuthGroupPermission) Save(db XODB) error {
if agp.Exists() {
return agp.Update(db)
}
return agp.Insert(db)
} | go | {
"resource": ""
} |
q22840 | AuthGroupPermissionsByPermissionID | train | 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 := d... | go | {
"resource": ""
} |
q22841 | processArgs | train | 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() {
... | go | {
"resource": ""
} |
q22842 | openDB | train | 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 datab... | go | {
"resource": ""
} |
q22843 | getFile | train | 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... | go | {
"resource": ""
} |
q22844 | writeTypes | train | 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 {
cont... | go | {
"resource": ""
} |
q22845 | MyAutoIncrements | train | 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... | go | {
"resource": ""
} |
q22846 | SqAutoIncrements | train | 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
}
def... | go | {
"resource": ""
} |
q22847 | fmtIndexName | train | 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, table... | go | {
"resource": ""
} |
q22848 | BuildIndexFuncName | train | 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.Tab... | go | {
"resource": ""
} |
q22849 | reverseIndexRune | train | 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 | {
"resource": ""
} |
q22850 | SingularizeIdentifier | train | 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 | {
"resource": ""
} |
q22851 | SqParseType | train | 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, "")
}
va... | go | {
"resource": ""
} |
q22852 | SqTables | train | 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 ... | go | {
"resource": ""
} |
q22853 | SqTableColumns | train | 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{
Fiel... | go | {
"resource": ""
} |
q22854 | SqQueryColumns | train | func SqQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS ` + strings.Join(inspect, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err !=... | go | {
"resource": ""
} |
q22855 | AuthGroupPermissionByID | train | func AuthGroupPermissionByID(db XODB, id int) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM public.auth_group_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
agp := AuthGroupPermission{
_exists: true,
}
err ... | go | {
"resource": ""
} |
q22856 | Update | train | func (ds *DjangoSession) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ds._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ds._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_... | go | {
"resource": ""
} |
q22857 | DjangoSessionsBySessionKey | train | func DjangoSessionsBySessionKey(db XODB, sessionKey string) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM public.django_session ` +
`WHERE session_key = $1`
// run query
XOLog(sqlstr, sessionKey)
q, err := db.Query(sqlst... | go | {
"resource": ""
} |
q22858 | TemplateLoader | train | func (a *ArgType) TemplateLoader(name string) ([]byte, error) {
// no template path specified
if a.TemplatePath == "" {
return templates.Asset(name)
}
return ioutil.ReadFile(path.Join(a.TemplatePath, name))
} | go | {
"resource": ""
} |
q22859 | TemplateSet | train | func (a *ArgType) TemplateSet() *TemplateSet {
if a.templateSet == nil {
a.templateSet = &TemplateSet{
funcs: a.NewTemplateFuncs(),
l: a.TemplateLoader,
tpls: map[string]*template.Template{},
}
}
return a.templateSet
} | go | {
"resource": ""
} |
q22860 | ExecuteTemplate | train | func (a *ArgType) ExecuteTemplate(tt TemplateType, name string, sub string, obj interface{}) error {
var err error
// setup generated
if a.Generated == nil {
a.Generated = []TBuf{}
}
// create store
v := TBuf{
TemplateType: tt,
Name: name,
Subname: sub,
Buf: new(bytes.Buffer),
}... | go | {
"resource": ""
} |
q22861 | Execute | train | func (ts *TemplateSet) Execute(w io.Writer, name string, obj interface{}) error {
tpl, ok := ts.tpls[name]
if !ok {
// attempt to load and parse the template
buf, err := ts.l(name)
if err != nil {
return err
}
// parse template
tpl, err = template.New(name).Funcs(ts.funcs).Parse(string(buf))
if err ... | go | {
"resource": ""
} |
q22862 | Save | train | func (aug *AuthUserGroup) Save(db XODB) error {
if aug.Exists() {
return aug.Update(db)
}
return aug.Insert(db)
} | go | {
"resource": ""
} |
q22863 | AuthUserGroupByUserIDGroupID | train | func AuthUserGroupByUserIDGroupID(db XODB, userID int, groupID int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM auth_user_groups ` +
`WHERE user_id = ? AND group_id = ?`
// run query
XOLog(sqlstr, userID, groupID)
aug := AuthUserGroup{
... | go | {
"resource": ""
} |
q22864 | Update | train | func (agp *AuthGroupPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if agp._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_... | go | {
"resource": ""
} |
q22865 | Delete | train | func (agp *AuthGroupPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !agp._exists {
return nil
}
// if deleted, bail
if agp._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM auth_group_permissions WHERE id = ?`
// run query
XOLog(sqlstr, agp.ID)
_, err = ... | go | {
"resource": ""
} |
q22866 | AuthUsersByUsername | train | func AuthUsersByUsername(db XODB, username string) ([]*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM public.auth_user ` +
`WHERE username = $1`
// run query
... | go | {
"resource": ""
} |
q22867 | NthParam | train | func (tl TypeLoader) NthParam(i int) string {
if tl.ParamN != nil {
return tl.ParamN(i)
}
return fmt.Sprintf("$%d", i+1)
} | go | {
"resource": ""
} |
q22868 | Escape | train | func (tl TypeLoader) Escape(typ EscType, s string) string {
if e, ok := tl.Esc[typ]; ok && e != nil {
return e(s)
}
return `"` + s + `"`
} | go | {
"resource": ""
} |
q22869 | Relkind | train | func (tl TypeLoader) Relkind(rt RelType) string {
if tl.ProcessRelkind != nil {
return tl.ProcessRelkind(rt)
}
return rt.String()
} | go | {
"resource": ""
} |
q22870 | SchemaName | train | func (tl TypeLoader) SchemaName(args *ArgType) (string, error) {
if tl.Schema != nil {
return tl.Schema(args)
}
return "", nil
} | go | {
"resource": ""
} |
q22871 | LoadSchema | train | func (tl TypeLoader) LoadSchema(args *ArgType) error {
var err error
// load enums
_, err = tl.LoadEnums(args)
if err != nil {
return err
}
// load procs
_, err = tl.LoadProcs(args)
if err != nil {
return err
}
// load tables
tableMap, err := tl.LoadRelkind(args, Table)
if err != nil {
return err
... | go | {
"resource": ""
} |
q22872 | LoadEnums | train | func (tl TypeLoader) LoadEnums(args *ArgType) (map[string]*Enum, error) {
var err error
// not supplied, so bail
if tl.EnumList == nil {
return nil, nil
}
// load enums
enumList, err := tl.EnumList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process enums
enumMap := map[string]*Enum{}
f... | go | {
"resource": ""
} |
q22873 | LoadEnumValues | train | func (tl TypeLoader) LoadEnumValues(args *ArgType, enumTpl *Enum) error {
var err error
// load enum values
enumValues, err := tl.EnumValueList(args.DB, args.Schema, enumTpl.Enum.EnumName)
if err != nil {
return err
}
// process enum values
for _, ev := range enumValues {
// chop off redundant enum name if... | go | {
"resource": ""
} |
q22874 | LoadProcs | train | func (tl TypeLoader) LoadProcs(args *ArgType) (map[string]*Proc, error) {
var err error
// not supplied, so bail
if tl.ProcList == nil {
return nil, nil
}
// load procs
procList, err := tl.ProcList(args.DB, args.Schema)
if err != nil {
return nil, err
}
// process procs
procMap := map[string]*Proc{}
f... | go | {
"resource": ""
} |
q22875 | LoadProcParams | train | func (tl TypeLoader) LoadProcParams(args *ArgType, procTpl *Proc) error {
var err error
// load proc params
paramList, err := tl.ProcParamList(args.DB, args.Schema, procTpl.Proc.ProcName)
if err != nil {
return err
}
// process params
for i, p := range paramList {
// TODO: some databases support named para... | go | {
"resource": ""
} |
q22876 | LoadForeignKeys | train | func (tl TypeLoader) LoadForeignKeys(args *ArgType, tableMap map[string]*Type) (map[string]*ForeignKey, error) {
var err error
fkMap := map[string]*ForeignKey{}
for _, t := range tableMap {
// load keys per table
err = tl.LoadTableForeignKeys(args, tableMap, t, fkMap)
if err != nil {
return nil, err
}
}... | go | {
"resource": ""
} |
q22877 | LoadTableForeignKeys | train | func (tl TypeLoader) LoadTableForeignKeys(args *ArgType, tableMap map[string]*Type, typeTpl *Type, fkMap map[string]*ForeignKey) error {
var err error
// load foreign keys
foreignKeyList, err := tl.ForeignKeyList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// loop over foreign ... | go | {
"resource": ""
} |
q22878 | LoadIndexes | train | func (tl TypeLoader) LoadIndexes(args *ArgType, tableMap map[string]*Type) (map[string]*Index, error) {
var err error
ixMap := map[string]*Index{}
for _, t := range tableMap {
// load table indexes
err = tl.LoadTableIndexes(args, t, ixMap)
if err != nil {
return nil, err
}
}
// generate templates
for... | go | {
"resource": ""
} |
q22879 | LoadTableIndexes | train | func (tl TypeLoader) LoadTableIndexes(args *ArgType, typeTpl *Type, ixMap map[string]*Index) error {
var err error
var priIxLoaded bool
// load indexes
indexList, err := tl.IndexList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// process indexes
for _, ix := range indexList {... | go | {
"resource": ""
} |
q22880 | LoadIndexColumns | train | func (tl TypeLoader) LoadIndexColumns(args *ArgType, ixTpl *Index) error {
var err error
// load index columns
indexCols, err := tl.IndexColumnList(args.DB, args.Schema, ixTpl.Type.Table.TableName, ixTpl.Index.IndexName)
if err != nil {
return err
}
// process index columns
for _, ic := range indexCols {
v... | go | {
"resource": ""
} |
q22881 | AuthPermissionByContentTypeIDCodename | train | func AuthPermissionByContentTypeIDCodename(db XODB, contentTypeID int, codename string) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE content_type_id = $1 AND codename = $2`
// run query
XOLo... | go | {
"resource": ""
} |
q22882 | AuthPermissionByID | train | func AuthPermissionByID(db XODB, id int) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(s... | go | {
"resource": ""
} |
q22883 | PgSequences | train | func PgSequences(db XODB, schema string) ([]*Sequence, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.relname ` + // ::varchar AS table_name
`FROM pg_class s ` +
`JOIN pg_depend d ON d.objid = s.oid ` +
`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid ` +
`JOIN pg_namespace n ... | go | {
"resource": ""
} |
q22884 | SqTableColumns | train | func SqTableColumns(db XODB, table string) ([]*SqColumn, error) {
var err error
// sql query
var sqlstr = `PRAGMA table_info(` + table + `)`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqColumn{}
for q.Next() {... | go | {
"resource": ""
} |
q22885 | Save | train | func (auup *AuthUserUserPermission) Save(db XODB) error {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
} | go | {
"resource": ""
} |
q22886 | AuthUserUserPermissionByUserIDPermissionID | train | func AuthUserUserPermissionByUserIDPermissionID(db XODB, userID float64, permissionID float64) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1 AND permission_id = :2`
// r... | go | {
"resource": ""
} |
q22887 | AuthUserUserPermissionsByUserID | train | func AuthUserUserPermissionsByUserID(db XODB, userID float64) ([]*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1`
// run query
XOLog(sqlstr, userID)
q, err := db.Query(sq... | go | {
"resource": ""
} |
q22888 | Save | train | func (dm *DjangoMigration) Save(db XODB) error {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
} | go | {
"resource": ""
} |
q22889 | MySchema | train | func MySchema(args *internal.ArgType) (string, error) {
var err error
// sql query
const sqlstr = `SELECT SCHEMA()`
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
} | go | {
"resource": ""
} |
q22890 | MyEnumValues | train | func MyEnumValues(db models.XODB, schema string, enum string) ([]*models.EnumValue, error) {
var err error
// load enum vals
res, err := models.MyEnumValues(db, schema, enum)
if err != nil {
return nil, err
}
// process enum vals
enumVals := []*models.EnumValue{}
for i, ev := range strings.Split(res.EnumVal... | go | {
"resource": ""
} |
q22891 | MyTables | train | func MyTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MyTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Autoincrementing included
autoIncrements, err := models.MyAutoIncrements(db, ... | go | {
"resource": ""
} |
q22892 | MyQueryColumns | train | func MyQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != ni... | go | {
"resource": ""
} |
q22893 | NewDefaultArgs | train | func NewDefaultArgs() *ArgType {
fkMode := FkModeSmart
return &ArgType{
Suffix: ".xo.go",
Int32Type: "int",
Uint32Type: "uint",
ForeignKeyMode: &fkMode,
QueryParamDelimiter: "%%",
NameConflictSuffix: "Val",
// KnownTypeMap is the collection of known Go types.
Kn... | go | {
"resource": ""
} |
q22894 | MsIdentities | train | func MsIdentities(db XODB, schema string) ([]*MsIdentity, error) {
var err error
// sql query
const sqlstr = `SELECT o.name as table_name ` +
`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id ` +
`WHERE c.is_identity = 1 ` +
`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`
// run... | go | {
"resource": ""
} |
q22895 | PgRelkind | train | func PgRelkind(relType internal.RelType) string {
var s string
switch relType {
case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
} | go | {
"resource": ""
} |
q22896 | PgQueryStrip | train | func PgQueryStrip(query []string, queryComments []string) {
for i, l := range query {
pos := pgQueryStripRE.FindStringIndex(l)
if pos != nil {
query[i] = l[:pos[0]] + l[pos[1]:]
queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
} | go | {
"resource": ""
} |
q22897 | PgTables | train | func PgTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.PgTables(db, schema, relkind)
if err != nil {
return nil, err
}
// Get the tables that have a sequence defined.
sequences, err := models.PgSequences(db, schema)
if err ... | go | {
"resource": ""
} |
q22898 | PgQueryColumns | train | func PgQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if... | go | {
"resource": ""
} |
q22899 | PgIndexColumns | train | func PgIndexColumns(db models.XODB, schema string, table string, index string) ([]*models.IndexColumn, error) {
var err error
// load columns
cols, err := models.PgIndexColumns(db, schema, index)
if err != nil {
return nil, err
}
// load col order
colOrd, err := models.PgGetColOrder(db, schema, index)
if er... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.