id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c22700 | != nil {
return false
}
h.Lock()
_, _, err := checkIfAvailable(h.head, ordinal)
h.Unlock()
return err != nil
} | |
c22701 | !ok {
return fmt.Errorf("internal failure while fixing inconsistent bitsequence: %v", err)
}
continue
}
logrus.Infof("Fixed inconsistent bit sequence in datastore:\n%s\n%s", h, nh)
h.Lock()
h.head = nh.head
h.Unlock()
return nil
}
} | |
c22702 | return errors.New("bit does not belong to the sequence")
}
return nil
} | |
c22703 | }
// Fetch latest
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil {
if err == datastore.ErrKeyNotFound { // already removed
return nil
}
return fmt.Errorf("failed to fetch from store when destroying the sequence: %v", err)
}
continue
}
return nil
}
} | |
c22704 | binary.BigEndian.PutUint64(ba[8:], h.unselected)
bm, err := h.head.toByteArray()
if err != nil {
return nil, fmt.Errorf("failed to serialize head: %s", err.Error())
}
ba = append(ba, bm...)
return ba, nil
} | |
c22705 |
h.Lock()
h.head = nh
h.bits = binary.BigEndian.Uint64(ba[0:8])
h.unselected = binary.BigEndian.Uint64(ba[8:16])
h.Unlock()
return nil
} | |
c22706 | defer h.Unlock()
return h.unselected
} | |
c22707 |
}
b, err := h.ToByteArray()
if err != nil {
return nil, err
}
m["sequence"] = b
return json.Marshal(m)
} | |
c22708 | := json.Marshal(m["sequence"])
if err := json.Unmarshal(bi, &b); err != nil {
return err
}
return h.FromByteArray(b)
} | |
c22709 | next block.
goto next
}
if err != nil {
// There are some more instances of the same block, so add the offset
// and be optimistic that you will find the available bit in the next
// instance of the same block.
bitOffset = 0
byteOffset += blockBytes
precBlocks++
goto retry
}
... | |
c22710 | bytePos, bitPos, err = getFirstAvailable(head, start)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bytePos, bitPos, nil
} | |
c22711 | address is unset
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
if current.block&bitSel == 0 {
return bytePos, bitPos, nil
}
}
return invalidPos, invalidPos, ErrBitAllocated
} | |
c22712 | } else {
previous.next = current.next
current = current.next
}
}
} | |
c22713 | }
stats := l.Attrs().Statistics
if stats == nil {
return nil, fmt.Errorf("no statistics were returned")
}
return &types.InterfaceStatistics{
RxBytes: uint64(stats.RxBytes),
TxBytes: uint64(stats.TxBytes),
RxPackets: uint64(stats.RxPackets),
TxPackets: uint64(stats.TxPackets),
RxDropped: uint64(st... | |
c22714 |
defer mutex.Unlock()
defaultNetworks, err := splitNetworks(defaultAddressPool)
if err != nil {
return err
}
*result = defaultNetworks
return nil
} | |
c22715 | }
return configDefaultNetworks(defaultAddressPool, &PredefinedGlobalScopeDefaultNetworks)
} | |
c22716 |
return configDefaultNetworks(defaultAddressPool, &PredefinedLocalScopeDefaultNetworks)
} | |
c22717 | return nil, fmt.Errorf("invalid pools size: %d", p.Size)
}
localPools = append(localPools, splitNetwork(p.Size, b)...)
}
return localPools, nil
} | |
c22718 | pm.chain = c
pm.bridgeName = bridgeName
} | |
c22719 | containerIP string, containerPort int) error {
return pm.forward(iptables.Delete, proto, sourceIP, sourcePort, containerIP, containerPort)
} | |
c22720 | err = u.UnmarshalBinary(input)
return
} | |
c22721 | err := FromBytes(input)
if err != nil {
return Nil
}
return uuid
} | |
c22722 | err := FromString(input)
if err != nil {
return Nil
}
return uuid
} | |
c22723 | text = []byte(u.String())
return
} | |
c22724 | }
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
if err != nil {
return
}
src = src[byteGroup:]
dst = dst[byteGroup/2:]
}
return
} | |
c22725 | err = hex.Decode(dst, src); err != nil {
return err
}
return
} | |
c22726 |
case 36:
return u.decodeCanonical(t)
default:
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
}
} | |
c22727 | got %d bytes", len(data))
return
}
copy(u[:], data)
return
} | |
c22728 |
if err != nil {
return 0, 0, err
}
g.storageMutex.Lock()
defer g.storageMutex.Unlock()
timeNow := g.getEpoch()
// Clock didn't change since last UUID generation.
// Should increase clock sequence.
if timeNow <= g.lastTime {
g.clockSequence++
}
g.lastTime = timeNow
return timeNow, g.clockSequence, nil... | |
c22729 | bytes.Equal(u1[:], u2[:])
} | |
c22730 | << 5))
case VariantFuture:
fallthrough
default:
u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
}
} | |
c22731 | &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval)
... | |
c22732 | &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amname, &pa.Amstrategies, &pa.Amsupport, &pa.Amcanorder, &pa.Amcanorderbyop, &pa.Amcanbackward, &pa.Amcanunique, &pa.Amcanmulticol, &pa.Amoptionalkey, &pa.Amsearcharray, &pa.Amsearchnulls, &pa.Amstorage, &pa.Amclusterable, &pa.Ampredlocks, &pa.Amkeytype, &pa.Aminsert, &pa.Ambeginscan, ... | |
c22733 | amopstrategy)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsor... | |
c22734 | &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | |
c22735 |
err = db.QueryRow(sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
re... | |
c22736 | amprocnum)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
... | |
c22737 | `FROM pg_catalog.pg_amproc ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
... | |
c22738 | +
`WHERE adrelid = $1 AND adnum = $2`
// run query
XOLog(sqlstr, adrelid, adnum)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return... | |
c22739 | pa := PgAttrdef{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
} | |
c22740 | attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Attisdropped, &pa.Atti... | |
c22741 | +
`WHERE member = $1 AND roleid = $2`
// run query
XOLog(sqlstr, member, roleid)
pam := PgAuthMember{}
err = db.QueryRow(sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption)
if err != nil {
return nil, er... | |
c22742 | &pa.Oid, &pa.Ctid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil)
if err != nil {
return nil, err
}
return &pa, nil
} | |
c22743 |
pc := PgCast{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod)
if err != nil {
return nil, err
}
return &pc, nil
} | |
c22744 | &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relcheck... | |
c22745 |
err = db.QueryRow(sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
} | |
c22746 | `FROM pg_catalog.pg_collation ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCollation{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
... | |
c22747 | &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc... | |
c22748 | &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Co... | |
c22749 | pc := PgConversion{}
err = db.QueryRow(sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault)
if err != nil {
return nil... | |
c22750 | &pd.Oid, &pd.Ctid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl)
if err != nil {
return nil, err
}
return &pd, nil
} | |
c22751 | +
`WHERE setdatabase = $1 AND setrole = $2`
// run query
XOLog(sqlstr, setdatabase, setrole)
pdrs := PgDbRoleSetting{}
err = db.QueryRow(sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig)
if err != n... | |
c22752 | pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | |
c22753 | db.QueryRow(sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | |
c22754 | }
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
... | |
c22755 | 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
} | |
c22756 | 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
} | |
c22757 | `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)
... | |
c22758 | +
`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 {... | |
c22759 | 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
} | |
c22760 | `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.E... | |
c22761 | := 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
} | |
c22762 | 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
} | |
c22763 | 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
} | |
c22764 | &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)
... | |
c22765 | 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... | |
c22766 | 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
} | |
c22767 | +
`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... | |
c22768 | `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.Laninli... | |
c22769 | +
`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
} | |
c22770 | 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
} | |
c22771 |
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
} | |
c22772 |
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
} | |
c22773 | `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.Opcdefaul... | |
c22774 | &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
} | |
c22775 |
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
} | |
c22776 |
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
} | |
c22777 |
`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.Tm... | |
c22778 |
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
} | |
c22779 | := 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, ... | |
c22780 | `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 ... | |
c22781 | 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
} | |
c22782 | 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
} | |
c22783 | `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 ... | |
c22784 | 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
} | |
c22785 |
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 {
... | |
c22786 |
// 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... | |
c22787 | `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 !... | |
c22788 | 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
} | |
c22789 |
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, &p... | |
c22790 |
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
} | |
c22791 |
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
} | |
c22792 | &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
} | |
c22793 | 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... | |
c22794 | +
`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... | |
c22795 | 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
} | |
c22796 | 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
} | |
c22797 | ` +
`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.... | |
c22798 | 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
} | |
c22799 | 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
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.