id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c22800 | ` +
`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, &p... | |
c22801 | &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.Typan... | |
c22802 | 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
} | |
c22803 |
}
// 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
} | |
c22804 | `\`, `\\\`, -1), `"`, `\"`, -1) + `"`
}
return "{" + strings.Join(v, ",") + "}", nil
} | |
c22805 | {
if dct.Exists() {
return dct.Update(db)
}
return dct.Insert(db)
} | |
c22806 | 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
} | |
c22807 | return ag.Update(db)
}
return ag.Insert(db)
} | |
c22808 | := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
} | |
c22809 |
if ds.Exists() {
return ds.Update(db)
}
return ds.Insert(db)
} | |
c22810 |
// run query
XOLog(sqlstr, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionKey)
if err != nil {
return err
}
// set deleted
ds._deleted = true
return nil
} | |
c22811 |
if ap.Exists() {
return ap.Update(db)
}
return ap.Insert(db)
} | |
c22812 | 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
} | |
c22813 |
// 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
} | |
c22814 | a.retype,
"shortname": a.shortname,
"convext": a.convext,
"schema": a.schemafn,
"colname": a.colname,
"hascolumn": a.hascolumn,
"hasfield": a.hasfield,
"getstartcount": a.getstartcount,
}
} | |
c22815 | := 1
for _, f := range fields {
if ignore[f.Name] {
continue
}
i++
}
return i
} | |
c22816 | }
}
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
} | |
c22817 | a.Loader.Escape(ColumnEsc, col.ColumnName)
}
return col.ColumnName
} | |
c22818 | if f.Col.ColumnName == name {
return true
}
}
return false
} | |
c22819 |
if f.Name == name {
return true
}
}
return false
} | |
c22820 |
return len(fields) - len(pkFields)
} | |
c22821 | 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
} | |
c22822 | IndexTemplate:
s = "index"
case QueryTypeTemplate:
s = "querytype"
case QueryTemplate:
s = "query"
default:
panic("unknown TemplateType")
}
return s
} | |
c22823 |
s = "TABLE"
case View:
s = "VIEW"
default:
panic("unknown RelType")
}
return s
} | |
c22824 |
if dal.Exists() {
return dal.Update(db)
}
return dal.Insert(db)
} | |
c22825 | 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
} | |
c22826 | return au.Update(db)
}
return au.Insert(db)
} | |
c22827 | +
`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
... | |
c22828 |
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
} | |
c22829 | := AuthGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, name).Scan(&ag.ID, &ag.Name)
if err != nil {
return nil, err
}
return &ag, nil
} | |
c22830 | 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 {
... | |
c22831 | // 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
} | |
c22832 | := 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
} | |
c22833 |
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: u... | |
c22834 | <> '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, &i... | |
c22835 | `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... | |
c22836 | +
`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)
... | |
c22837 | 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
} | |
c22838 | 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
} | |
c22839 | {
if agp.Exists() {
return agp.Update(db)
}
return agp.Insert(db)
} | |
c22840 | 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
} | |
c22841 |
}
// 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
... | |
c22842 |
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
} | |
c22843 | 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, "... | |
c22844 | = 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 :... | |
c22845 | 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
} | |
c22846 | {
sai := SqAutoIncrement{}
// scan
err = q.Scan(&sai.TableName, &sai.SQL)
if err != nil {
return nil, err
}
res = append(res, &sai)
}
return res, nil
} | |
c22847 | ""
}
// chop off tablename_
if strings.HasPrefix(ixName, tableName+"_") {
ixName = ixName[len(tableName)+1:]
}
// camel case name
return snaker.SnakeToCamelIdentifier(ixName)
} | |
c22848 | 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, "")
} | |
c22849 |
rs := []rune(s)
for i := len(rs) - 1; i >= 0; i-- {
if rs[i] == r {
return i
}
}
return -1
} | |
c22850 | s = s[:i] + "_" + inflector.Singularize(s[i+1:])
} else {
s = inflector.Singularize(s)
}
return snaker.SnakeToCamelIdentifier(s)
} | |
c22851 | "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":
nilVa... | |
c22852 | 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, &mo... | |
c22853 |
FieldOrdinal: row.FieldOrdinal,
ColumnName: row.ColumnName,
DataType: row.DataType,
NotNull: row.NotNull,
DefaultValue: row.DefaultValue,
IsPrimaryKey: row.PkColIndex != 0,
})
}
return cols, nil
} | |
c22854 |
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load column information
return SqTableColumns(args.DB, "", xoid)
} | |
c22855 | := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
} | |
c22856 |
`) WHERE session_key = $3`
// run query
XOLog(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
_, err = db.Exec(sqlstr, ds.SessionData, ds.ExpireDate, ds.SessionKey)
return err
} | |
c22857 | q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
} | |
c22858 | templates.Asset(name)
}
return ioutil.ReadFile(path.Join(a.TemplatePath, name))
} | |
c22859 | funcs: a.NewTemplateFuncs(),
l: a.TemplateLoader,
tpls: map[string]*template.Template{},
}
}
return a.templateSet
} | |
c22860 |
// 'oracle' as valid protocol
loaderType = "oracle."
} else {
loaderType = a.LoaderType + "."
}
}
templateName := fmt.Sprintf("%s%s.go.tpl", loaderType, tt)
// execute template
err = a.TemplateSet().Execute(v.Buf, templateName, obj)
if err != nil {
return err
}
a.Generated = append(a.Generated,... | |
c22861 | buf, err := ts.l(name)
if err != nil {
return err
}
// parse template
tpl, err = template.New(name).Funcs(ts.funcs).Parse(string(buf))
if err != nil {
return err
}
}
return tpl.Execute(w, obj)
} | |
c22862 |
if aug.Exists() {
return aug.Update(db)
}
return aug.Insert(db)
} | |
c22863 |
`WHERE user_id = ? AND group_id = ?`
// run query
XOLog(sqlstr, userID, groupID)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, groupID).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
} | |
c22864 | marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group_permissions SET ` +
`group_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
_, err = db.Exec(sqlstr, agp.GroupID, agp.PermissionID, agp.ID)
return err
} | |
c22865 | auth_group_permissions WHERE id = ?`
// run query
XOLog(sqlstr, agp.ID)
_, err = db.Exec(sqlstr, agp.ID)
if err != nil {
return err
}
// set deleted
agp._deleted = true
return nil
} | |
c22866 | {
au := AuthUser{
_exists: true,
}
// scan
err = q.Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
res = append(res, &au)
}
return res, nil
} | |
c22867 | return tl.ParamN(i)
}
return fmt.Sprintf("$%d", i+1)
} | |
c22868 | e != nil {
return e(s)
}
return `"` + s + `"`
} | |
c22869 | return tl.ProcessRelkind(rt)
}
return rt.String()
} | |
c22870 | return tl.Schema(args)
}
return "", nil
} | |
c22871 |
// merge views with the tableMap
for k, v := range viewMap {
tableMap[k] = v
}
// load foreign keys
_, err = tl.LoadForeignKeys(args, tableMap)
if err != nil {
return err
}
// load indexes
_, err = tl.LoadIndexes(args, tableMap)
if err != nil {
return err
}
return nil
} | |
c22872 |
err = tl.LoadEnumValues(args, enumTpl)
if err != nil {
return nil, err
}
enumMap[enumTpl.Name] = enumTpl
args.KnownTypeMap[enumTpl.Name] = true
}
// generate enum templates
for _, e := range enumMap {
err = args.ExecuteTemplate(EnumTemplate, e.Name, "", e)
if err != nil {
return nil, err
}
... | |
c22873 | snaker.SnakeToCamelIdentifier(ev.EnumValue)
if strings.HasSuffix(strings.ToLower(name), strings.ToLower(enumTpl.Name)) {
n := name[:len(name)-len(enumTpl.Name)]
if len(n) > 0 {
name = n
}
}
enumTpl.Values = append(enumTpl.Values, &EnumValue{
Name: name,
Val: ev,
})
}
return nil
} | |
c22874 | procTpl.Return.Type = tl.ParseType(args, p.ReturnType, false)
// load proc parameters
err = tl.LoadProcParams(args, procTpl)
if err != nil {
return nil, err
}
procMap[p.ProcName] = procTpl
}
// generate proc templates
for _, p := range procMap {
err = args.ExecuteTemplate(ProcTemplate, "sp_"+p.Nam... | |
c22875 | _, paramTpl.Type = tl.ParseType(args, strings.TrimSpace(p.ParamType), false)
// add to proc params
if procTpl.ProcParams != "" {
procTpl.ProcParams = procTpl.ProcParams + ", "
}
procTpl.ProcParams = procTpl.ProcParams + p.ParamType
procTpl.Params = append(procTpl.Params, paramTpl)
}
return nil
} | |
c22876 |
fk.Name = args.ForeignKeyName(fkMap, fk)
}
// generate templates
for _, fk := range fkMap {
err = args.ExecuteTemplate(ForeignKeyTemplate, fk.Type.Name, fk.ForeignKey.ForeignKeyName, fk)
if err != nil {
return nil, err
}
}
return fkMap, nil
} | |
c22877 | fk.RefTableName {
refTpl = t
break refTplLoop
}
}
refColLoop:
// find ref column
for _, f := range refTpl.Fields {
if f.Col.ColumnName == fk.RefColumnName {
refCol = f
break refColLoop
}
}
// no ref col, but have ref tpl, so use primary key
if refTpl != nil && refCol == nil {
... | |
c22878 | ixMap {
err = args.ExecuteTemplate(IndexTemplate, ix.Type.Name, ix.Index.IndexName, ix)
if err != nil {
return nil, err
}
}
return ixMap, nil
} | |
c22879 | {
pk = f
break
}
}
}
// if no primary key index loaded, but a primary key column was defined in
// the type, then create the definition here. this is needed for sqlite, as
// sqlite doesn't define primary keys in its index list
if args.LoaderType != "ora" && !priIxLoaded && pk != nil {
ixName := t... | |
c22880 | for _, f := range ixTpl.Type.Fields {
if f.Col.ColumnName == ic.ColumnName {
field = f
break fieldLoop
}
}
if field == nil {
continue
}
ixTpl.Fields = append(ixTpl.Fields, field)
}
return nil
} | |
c22881 | XOLog(sqlstr, contentTypeID, codename)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, contentTypeID, codename).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | |
c22882 | := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | |
c22883 | schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Sequence{}
for q.Next() {
s := Sequence{}
// scan
err = q.Scan(&s.TableName)
if err != nil {
return nil, err
}
res = append(res, &s)
}
return res, nil
} | |
c22884 | err = q.Scan(&sc.FieldOrdinal, &sc.ColumnName, &sc.DataType, &sc.NotNull, &sc.DefaultValue, &sc.PkColIndex)
if err != nil {
return nil, err
}
res = append(res, &sc)
}
return res, nil
} | |
c22885 | {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
} | |
c22886 | XOLog(sqlstr, userID, permissionID)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, permissionID).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | |
c22887 | q.Next() {
auup := AuthUserUserPermission{
_exists: true,
}
// scan
err = q.Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &auup)
}
return res, nil
} | |
c22888 | {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
} | |
c22889 |
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
} | |
c22890 |
for i, ev := range strings.Split(res.EnumValues[1:len(res.EnumValues)-1], "','") {
enumVals = append(enumVals, &models.EnumValue{
EnumValue: ev,
ConstValue: i + 1,
})
}
return enumVals, nil
} | |
c22891 | := true
// Look for a match in the table name where it contains the autoincrement
for _, autoInc := range autoIncrements {
if autoInc.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
... | |
c22892 | `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MyTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols,... | |
c22893 | "Slice": true,
"StringSlice": true,
},
// ShortNameTypeMap is the collection of Go style short names for types, mainly
// used for use with declaring a func receiver on a type.
ShortNameTypeMap: map[string]string{
"bool": "b",
"string": "s",
"byte": "b",
"rune": ... | |
c22894 | q.Close()
// load results
res := []*MsIdentity{}
for q.Next() {
mi := MsIdentity{}
// scan
err = q.Scan(&mi.TableName)
if err != nil {
return nil, err
}
res = append(res, &mi)
}
return res, nil
} | |
c22895 | case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
} | |
c22896 | queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
} | |
c22897 | := true
// Look for a match in the table name where it contains the sequence
for _, sequence := range sequences {
if sequence.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
... | |
c22898 |
`JOIN pg_namespace n ON n.oid = c.relnamespace ` +
`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`
// run query
var schema string
models.XOLog(nspq, xoid)
err = args.DB.QueryRow(nspq, xoid).Scan(&schema)
if err != nil {
return nil, err
}
// load column information
return models.PgTableColumns(args... | |
c22899 |
found := false
var c *models.IndexColumn
for _, ic := range cols {
if cid == ic.Cid {
found = true
c = ic
break
}
}
// sanity check
if !found {
return nil, fmt.Errorf("could not find %s%s index %s column id %d", s, table, index, cid)
}
ret = append(ret, c)
}
return ret, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.