_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q13900 | Reset | train | func (worker *Worker) Reset() {
outpack := getOutPack()
outpack.dataType = dtResetAbilities
worker.broadcast(outpack)
worker.funcs = make(jobFuncs)
} | go | {
"resource": ""
} |
q13901 | SetId | train | func (worker *Worker) SetId(id string) {
worker.Id = id
outpack := getOutPack()
outpack.dataType = dtSetClientId
outpack.data = []byte(id)
worker.broadcast(outpack)
} | go | {
"resource": ""
} |
q13902 | exec | train | func (worker *Worker) exec(inpack *inPack) (err error) {
defer func() {
if worker.limit != nil {
<-worker.limit
}
if r := recover(); r != nil {
if e, ok := r.(error); ok {
err = e
} else {
err = ErrUnknown
}
}
}()
f, ok := worker.funcs[inpack.fn]
if !ok {
return fmt.Errorf("The function does not exist: %s", inpack.fn)
}
var r *result
if f.timeout == 0 {
d, e := f.f(inpack)
r = &result{data: d, err: e}
} else {
r = execTimeout(f.f, inpack, time.Duration(f.timeout)*time.Second)
}
if worker.running {
outpack := getOutPack()
if r.err == nil {
outpack.dataType = dtWorkComplete
} else {
if len(r.data) == 0 {
outpack.dataType = dtWorkFail
} else {
outpack.dataType = dtWorkException
}
err = r.err
}
outpack.handle = inpack.handle
outpack.data = r.data
inpack.a.Write(outpack)
}
return
} | go | {
"resource": ""
} |
q13903 | Server | train | func (e *WorkerDisconnectError) Server() (net string, addr string) {
return e.agent.net, e.agent.addr
} | go | {
"resource": ""
} |
q13904 | Result | train | func (resp *Response) Result() (data []byte, err error) {
switch resp.DataType {
case dtWorkFail:
resp.Handle = string(resp.Data)
err = ErrWorkFail
return
case dtWorkException:
err = ErrWorkException
fallthrough
case dtWorkComplete:
data = resp.Data
default:
err = ErrDataType
}
return
} | go | {
"resource": ""
} |
q13905 | Update | train | func (resp *Response) Update() (data []byte, err error) {
if resp.DataType != dtWorkData &&
resp.DataType != dtWorkWarning {
err = ErrDataType
return
}
data = resp.Data
if resp.DataType == dtWorkWarning {
err = ErrWorkWarning
}
return
} | go | {
"resource": ""
} |
q13906 | decodeResponse | train | func decodeResponse(data []byte) (resp *Response, l int, err error) {
a := len(data)
if a < minPacketLength { // valid package should not less 12 bytes
err = fmt.Errorf("Invalid data: %v", data)
return
}
dl := int(binary.BigEndian.Uint32(data[8:12]))
if a < minPacketLength+dl {
err = fmt.Errorf("Invalid data: %v", data)
return
}
dt := data[minPacketLength : dl+minPacketLength]
if len(dt) != int(dl) { // length not equal
err = fmt.Errorf("Invalid data: %v", data)
return
}
resp = getResponse()
resp.DataType = binary.BigEndian.Uint32(data[4:8])
switch resp.DataType {
case dtJobCreated:
resp.Handle = string(dt)
case dtStatusRes, dtWorkData, dtWorkWarning, dtWorkStatus,
dtWorkComplete, dtWorkException:
s := bytes.SplitN(dt, []byte{'\x00'}, 2)
if len(s) >= 2 {
resp.Handle = string(s[0])
resp.Data = s[1]
} else {
err = fmt.Errorf("Invalid data: %v", data)
return
}
case dtWorkFail:
s := bytes.SplitN(dt, []byte{'\x00'}, 2)
if len(s) >= 1 {
resp.Handle = string(s[0])
} else {
err = fmt.Errorf("Invalid data: %v", data)
return
}
case dtEchoRes:
fallthrough
default:
resp.Data = dt
}
l = dl + minPacketLength
return
} | go | {
"resource": ""
} |
q13907 | SendData | train | func (inpack *inPack) SendData(data []byte) {
outpack := getOutPack()
outpack.dataType = dtWorkData
hl := len(inpack.handle)
l := hl + len(data) + 1
outpack.data = getBuffer(l)
copy(outpack.data, []byte(inpack.handle))
copy(outpack.data[hl+1:], data)
inpack.a.write(outpack)
} | go | {
"resource": ""
} |
q13908 | UpdateStatus | train | func (inpack *inPack) UpdateStatus(numerator, denominator int) {
n := []byte(strconv.Itoa(numerator))
d := []byte(strconv.Itoa(denominator))
outpack := getOutPack()
outpack.dataType = dtWorkStatus
hl := len(inpack.handle)
nl := len(n)
dl := len(d)
outpack.data = getBuffer(hl + nl + dl + 2)
copy(outpack.data, []byte(inpack.handle))
copy(outpack.data[hl+1:], n)
copy(outpack.data[hl+nl+2:], d)
inpack.a.write(outpack)
} | go | {
"resource": ""
} |
q13909 | decodeInPack | train | func decodeInPack(data []byte) (inpack *inPack, l int, err error) {
if len(data) < minPacketLength { // valid package should not less 12 bytes
err = fmt.Errorf("Invalid data: %v", data)
return
}
dl := int(binary.BigEndian.Uint32(data[8:12]))
if len(data) < (dl + minPacketLength) {
err = fmt.Errorf("Not enough data: %v", data)
return
}
dt := data[minPacketLength : dl+minPacketLength]
if len(dt) != int(dl) { // length not equal
err = fmt.Errorf("Invalid data: %v", data)
return
}
inpack = getInPack()
inpack.dataType = binary.BigEndian.Uint32(data[4:8])
switch inpack.dataType {
case dtJobAssign:
s := bytes.SplitN(dt, []byte{'\x00'}, 3)
if len(s) == 3 {
inpack.handle = string(s[0])
inpack.fn = string(s[1])
inpack.data = s[2]
}
case dtJobAssignUniq:
s := bytes.SplitN(dt, []byte{'\x00'}, 4)
if len(s) == 4 {
inpack.handle = string(s[0])
inpack.fn = string(s[1])
inpack.uniqueId = string(s[2])
inpack.data = s[3]
}
default:
inpack.data = dt
}
l = dl + minPacketLength
return
} | go | {
"resource": ""
} |
q13910 | GetOrCreateSecondaryCache | train | func (c *LayeredCache) GetOrCreateSecondaryCache(primary string) *SecondaryCache {
primaryBkt := c.bucket(primary)
bkt := primaryBkt.getSecondaryBucket(primary)
primaryBkt.Lock()
if bkt == nil {
bkt = &bucket{lookup: make(map[string]*Item)}
primaryBkt.buckets[primary] = bkt
}
primaryBkt.Unlock()
return &SecondaryCache{
bucket: bkt,
pCache: c,
}
} | go | {
"resource": ""
} |
q13911 | Replace | train | func (c *LayeredCache) Replace(primary, secondary string, value interface{}) bool {
item := c.bucket(primary).get(primary, secondary)
if item == nil {
return false
}
c.Set(primary, secondary, value, item.TTL())
return true
} | go | {
"resource": ""
} |
q13912 | Fetch | train | func (c *LayeredCache) Fetch(primary, secondary string, duration time.Duration, fetch func() (interface{}, error)) (*Item, error) {
item := c.Get(primary, secondary)
if item != nil {
return item, nil
}
value, err := fetch()
if err != nil {
return nil, err
}
return c.set(primary, secondary, value, duration), nil
} | go | {
"resource": ""
} |
q13913 | DeleteAll | train | func (c *LayeredCache) DeleteAll(primary string) bool {
return c.bucket(primary).deleteAll(primary, c.deletables)
} | go | {
"resource": ""
} |
q13914 | Clear | train | func (c *LayeredCache) Clear() {
for _, bucket := range c.buckets {
bucket.clear()
}
c.size = 0
c.list = list.New()
} | go | {
"resource": ""
} |
q13915 | Replace | train | func (c *Cache) Replace(key string, value interface{}) bool {
item := c.bucket(key).get(key)
if item == nil {
return false
}
c.Set(key, value, item.TTL())
return true
} | go | {
"resource": ""
} |
q13916 | Get | train | func (s *SecondaryCache) Get(secondary string) *Item {
return s.bucket.get(secondary)
} | go | {
"resource": ""
} |
q13917 | Set | train | func (s *SecondaryCache) Set(secondary string, value interface{}, duration time.Duration) *Item {
item, existing := s.bucket.set(secondary, value, duration)
if existing != nil {
s.pCache.deletables <- existing
}
s.pCache.promote(item)
return item
} | go | {
"resource": ""
} |
q13918 | Fetch | train | func (s *SecondaryCache) Fetch(secondary string, duration time.Duration, fetch func() (interface{}, error)) (*Item, error) {
item := s.Get(secondary)
if item != nil {
return item, nil
}
value, err := fetch()
if err != nil {
return nil, err
}
return s.Set(secondary, value, duration), nil
} | go | {
"resource": ""
} |
q13919 | Delete | train | func (s *SecondaryCache) Delete(secondary string) bool {
item := s.bucket.delete(secondary)
if item != nil {
s.pCache.deletables <- item
return true
}
return false
} | go | {
"resource": ""
} |
q13920 | Replace | train | func (s *SecondaryCache) Replace(secondary string, value interface{}) bool {
item := s.Get(secondary)
if item == nil {
return false
}
s.Set(secondary, value, item.TTL())
return true
} | go | {
"resource": ""
} |
q13921 | TrackingGet | train | func (c *SecondaryCache) TrackingGet(secondary string) TrackedItem {
item := c.Get(secondary)
if item == nil {
return NilTracked
}
item.track()
return item
} | go | {
"resource": ""
} |
q13922 | Parse | train | func Parse(data []byte) (p7 *PKCS7, err error) {
if len(data) == 0 {
return nil, errors.New("pkcs7: input data is empty")
}
var info contentInfo
der, err := ber2der(data)
if err != nil {
return nil, err
}
rest, err := asn1.Unmarshal(der, &info)
if len(rest) > 0 {
err = asn1.SyntaxError{Msg: "trailing data"}
return
}
if err != nil {
return
}
// fmt.Printf("--> Content Type: %s", info.ContentType)
switch {
case info.ContentType.Equal(oidSignedData):
return parseSignedData(info.Content.Bytes)
case info.ContentType.Equal(oidEnvelopedData):
return parseEnvelopedData(info.Content.Bytes)
}
return nil, ErrUnsupportedContentType
} | go | {
"resource": ""
} |
q13923 | GetOnlySigner | train | func (p7 *PKCS7) GetOnlySigner() *x509.Certificate {
if len(p7.Signers) != 1 {
return nil
}
signer := p7.Signers[0]
return getCertFromCertsByIssuerAndSerial(p7.Certificates, signer.IssuerAndSerialNumber)
} | go | {
"resource": ""
} |
q13924 | Decrypt | train | func (p7 *PKCS7) Decrypt(cert *x509.Certificate, pk crypto.PrivateKey) ([]byte, error) {
data, ok := p7.raw.(envelopedData)
if !ok {
return nil, ErrNotEncryptedContent
}
recipient := selectRecipientForCertificate(data.RecipientInfos, cert)
if recipient.EncryptedKey == nil {
return nil, errors.New("pkcs7: no enveloped recipient for provided certificate")
}
if priv := pk.(*rsa.PrivateKey); priv != nil {
var contentKey []byte
contentKey, err := rsa.DecryptPKCS1v15(rand.Reader, priv, recipient.EncryptedKey)
if err != nil {
return nil, err
}
return data.EncryptedContentInfo.decrypt(contentKey)
}
fmt.Printf("Unsupported Private Key: %v\n", pk)
return nil, ErrUnsupportedAlgorithm
} | go | {
"resource": ""
} |
q13925 | AddSigner | train | func (sd *SignedData) AddSigner(cert *x509.Certificate, pkey crypto.PrivateKey, config SignerInfoConfig) error {
attrs := &attributes{}
attrs.Add(oidAttributeContentType, sd.sd.ContentInfo.ContentType)
attrs.Add(oidAttributeMessageDigest, sd.messageDigest)
attrs.Add(oidAttributeSigningTime, time.Now())
for _, attr := range config.ExtraSignedAttributes {
attrs.Add(attr.Type, attr.Value)
}
finalAttrs, err := attrs.ForMarshaling()
if err != nil {
return err
}
signature, err := signAttributes(finalAttrs, pkey, crypto.SHA1)
if err != nil {
return err
}
ias, err := cert2issuerAndSerial(cert)
if err != nil {
return err
}
signer := signerInfo{
AuthenticatedAttributes: finalAttrs,
DigestAlgorithm: pkix.AlgorithmIdentifier{Algorithm: oidDigestAlgorithmSHA1},
DigestEncryptionAlgorithm: pkix.AlgorithmIdentifier{Algorithm: oidSignatureSHA1WithRSA},
IssuerAndSerialNumber: ias,
EncryptedDigest: signature,
Version: 1,
}
// create signature of signed attributes
sd.certs = append(sd.certs, cert)
sd.sd.SignerInfos = append(sd.sd.SignerInfos, signer)
return nil
} | go | {
"resource": ""
} |
q13926 | AddCertificate | train | func (sd *SignedData) AddCertificate(cert *x509.Certificate) {
sd.certs = append(sd.certs, cert)
} | go | {
"resource": ""
} |
q13927 | complexity | train | func complexity(fn *ast.FuncDecl) int {
v := complexityVisitor{}
ast.Walk(&v, fn)
return v.Complexity
} | go | {
"resource": ""
} |
q13928 | GenerateFixtures | train | func GenerateFixtures(db *sql.DB, helper Helper, dir string) error {
tables, err := helper.tableNames(db)
if err != nil {
return err
}
for _, table := range tables {
filename := path.Join(dir, table+".yml")
if err := generateFixturesForTable(db, helper, &TableInfo{Name: table}, filename); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q13929 | NewSelectQuery | train | func NewSelectQuery(builder Builder, db *DB) *SelectQuery {
return &SelectQuery{
builder: builder,
selects: []string{},
from: []string{},
join: []JoinInfo{},
orderBy: []string{},
groupBy: []string{},
union: []UnionInfo{},
limit: -1,
params: Params{},
FieldMapper: db.FieldMapper,
}
} | go | {
"resource": ""
} |
q13930 | Select | train | func (s *SelectQuery) Select(cols ...string) *SelectQuery {
s.selects = cols
return s
} | go | {
"resource": ""
} |
q13931 | AndSelect | train | func (s *SelectQuery) AndSelect(cols ...string) *SelectQuery {
s.selects = append(s.selects, cols...)
return s
} | go | {
"resource": ""
} |
q13932 | Distinct | train | func (s *SelectQuery) Distinct(v bool) *SelectQuery {
s.distinct = v
return s
} | go | {
"resource": ""
} |
q13933 | SelectOption | train | func (s *SelectQuery) SelectOption(option string) *SelectQuery {
s.selectOption = option
return s
} | go | {
"resource": ""
} |
q13934 | From | train | func (s *SelectQuery) From(tables ...string) *SelectQuery {
s.from = tables
return s
} | go | {
"resource": ""
} |
q13935 | Where | train | func (s *SelectQuery) Where(e Expression) *SelectQuery {
s.where = e
return s
} | go | {
"resource": ""
} |
q13936 | InnerJoin | train | func (s *SelectQuery) InnerJoin(table string, on Expression) *SelectQuery {
return s.Join("INNER JOIN", table, on)
} | go | {
"resource": ""
} |
q13937 | LeftJoin | train | func (s *SelectQuery) LeftJoin(table string, on Expression) *SelectQuery {
return s.Join("LEFT JOIN", table, on)
} | go | {
"resource": ""
} |
q13938 | RightJoin | train | func (s *SelectQuery) RightJoin(table string, on Expression) *SelectQuery {
return s.Join("RIGHT JOIN", table, on)
} | go | {
"resource": ""
} |
q13939 | OrderBy | train | func (s *SelectQuery) OrderBy(cols ...string) *SelectQuery {
s.orderBy = cols
return s
} | go | {
"resource": ""
} |
q13940 | AndOrderBy | train | func (s *SelectQuery) AndOrderBy(cols ...string) *SelectQuery {
s.orderBy = append(s.orderBy, cols...)
return s
} | go | {
"resource": ""
} |
q13941 | GroupBy | train | func (s *SelectQuery) GroupBy(cols ...string) *SelectQuery {
s.groupBy = cols
return s
} | go | {
"resource": ""
} |
q13942 | AndGroupBy | train | func (s *SelectQuery) AndGroupBy(cols ...string) *SelectQuery {
s.groupBy = append(s.groupBy, cols...)
return s
} | go | {
"resource": ""
} |
q13943 | Having | train | func (s *SelectQuery) Having(e Expression) *SelectQuery {
s.having = e
return s
} | go | {
"resource": ""
} |
q13944 | Union | train | func (s *SelectQuery) Union(q *Query) *SelectQuery {
s.union = append(s.union, UnionInfo{false, q})
return s
} | go | {
"resource": ""
} |
q13945 | UnionAll | train | func (s *SelectQuery) UnionAll(q *Query) *SelectQuery {
s.union = append(s.union, UnionInfo{true, q})
return s
} | go | {
"resource": ""
} |
q13946 | Limit | train | func (s *SelectQuery) Limit(limit int64) *SelectQuery {
s.limit = limit
return s
} | go | {
"resource": ""
} |
q13947 | Offset | train | func (s *SelectQuery) Offset(offset int64) *SelectQuery {
s.offset = offset
return s
} | go | {
"resource": ""
} |
q13948 | Bind | train | func (s *SelectQuery) Bind(params Params) *SelectQuery {
s.params = params
return s
} | go | {
"resource": ""
} |
q13949 | AndBind | train | func (s *SelectQuery) AndBind(params Params) *SelectQuery {
if len(s.params) == 0 {
s.params = params
} else {
for k, v := range params {
s.params[k] = v
}
}
return s
} | go | {
"resource": ""
} |
q13950 | Build | train | func (s *SelectQuery) Build() *Query {
params := Params{}
for k, v := range s.params {
params[k] = v
}
qb := s.builder.QueryBuilder()
clauses := []string{
qb.BuildSelect(s.selects, s.distinct, s.selectOption),
qb.BuildFrom(s.from),
qb.BuildJoin(s.join, params),
qb.BuildWhere(s.where, params),
qb.BuildGroupBy(s.groupBy),
qb.BuildHaving(s.having, params),
}
sql := ""
for _, clause := range clauses {
if clause != "" {
if sql == "" {
sql = clause
} else {
sql += " " + clause
}
}
}
sql = qb.BuildOrderByAndLimit(sql, s.orderBy, s.limit, s.offset)
if union := qb.BuildUnion(s.union, params); union != "" {
sql = fmt.Sprintf("(%v) %v", sql, union)
}
return s.builder.NewQuery(sql).Bind(params)
} | go | {
"resource": ""
} |
q13951 | NewPgsqlBuilder | train | func NewPgsqlBuilder(db *DB, executor Executor) Builder {
return &PgsqlBuilder{
NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | go | {
"resource": ""
} |
q13952 | BuildSelect | train | func (q *BaseQueryBuilder) BuildSelect(cols []string, distinct bool, option string) string {
var s bytes.Buffer
s.WriteString("SELECT ")
if distinct {
s.WriteString("DISTINCT ")
}
if option != "" {
s.WriteString(option)
s.WriteString(" ")
}
if len(cols) == 0 {
s.WriteString("*")
return s.String()
}
for i, col := range cols {
if i > 0 {
s.WriteString(", ")
}
matches := selectRegex.FindStringSubmatch(col)
if len(matches) == 0 {
s.WriteString(q.db.QuoteColumnName(col))
} else {
col := col[:len(col)-len(matches[0])]
alias := matches[1]
s.WriteString(q.db.QuoteColumnName(col) + " AS " + q.db.QuoteSimpleColumnName(alias))
}
}
return s.String()
} | go | {
"resource": ""
} |
q13953 | BuildFrom | train | func (q *BaseQueryBuilder) BuildFrom(tables []string) string {
if len(tables) == 0 {
return ""
}
s := ""
for _, table := range tables {
table = q.quoteTableNameAndAlias(table)
if s == "" {
s = table
} else {
s += ", " + table
}
}
return "FROM " + s
} | go | {
"resource": ""
} |
q13954 | BuildJoin | train | func (q *BaseQueryBuilder) BuildJoin(joins []JoinInfo, params Params) string {
if len(joins) == 0 {
return ""
}
parts := []string{}
for _, join := range joins {
sql := join.Join + " " + q.quoteTableNameAndAlias(join.Table)
on := ""
if join.On != nil {
on = join.On.Build(q.db, params)
}
if on != "" {
sql += " ON " + on
}
parts = append(parts, sql)
}
return strings.Join(parts, " ")
} | go | {
"resource": ""
} |
q13955 | BuildWhere | train | func (q *BaseQueryBuilder) BuildWhere(e Expression, params Params) string {
if e != nil {
if c := e.Build(q.db, params); c != "" {
return "WHERE " + c
}
}
return ""
} | go | {
"resource": ""
} |
q13956 | BuildGroupBy | train | func (q *BaseQueryBuilder) BuildGroupBy(cols []string) string {
if len(cols) == 0 {
return ""
}
s := ""
for i, col := range cols {
if i == 0 {
s = q.db.QuoteColumnName(col)
} else {
s += ", " + q.db.QuoteColumnName(col)
}
}
return "GROUP BY " + s
} | go | {
"resource": ""
} |
q13957 | BuildUnion | train | func (q *BaseQueryBuilder) BuildUnion(unions []UnionInfo, params Params) string {
if len(unions) == 0 {
return ""
}
sql := ""
for i, union := range unions {
if i > 0 {
sql += " "
}
for k, v := range union.Query.params {
params[k] = v
}
u := "UNION"
if union.All {
u = "UNION ALL"
}
sql += fmt.Sprintf("%v (%v)", u, union.Query.sql)
}
return sql
} | go | {
"resource": ""
} |
q13958 | BuildOrderBy | train | func (q *BaseQueryBuilder) BuildOrderBy(cols []string) string {
if len(cols) == 0 {
return ""
}
s := ""
for i, col := range cols {
if i > 0 {
s += ", "
}
matches := orderRegex.FindStringSubmatch(col)
if len(matches) == 0 {
s += q.db.QuoteColumnName(col)
} else {
col := col[:len(col)-len(matches[0])]
dir := matches[1]
s += q.db.QuoteColumnName(col) + " " + dir
}
}
return "ORDER BY " + s
} | go | {
"resource": ""
} |
q13959 | BuildLimit | train | func (q *BaseQueryBuilder) BuildLimit(limit int64, offset int64) string {
if limit < 0 && offset > 0 {
// most DBMS requires LIMIT when OFFSET is present
limit = 9223372036854775807 // 2^63 - 1
}
sql := ""
if limit >= 0 {
sql = fmt.Sprintf("LIMIT %v", limit)
}
if offset <= 0 {
return sql
}
if sql != "" {
sql += " "
}
return sql + fmt.Sprintf("OFFSET %v", offset)
} | go | {
"resource": ""
} |
q13960 | ScanMap | train | func (r *Rows) ScanMap(a NullStringMap) error {
cols, _ := r.Columns()
var refs []interface{}
for i := 0; i < len(cols); i++ {
var t sql.NullString
refs = append(refs, &t)
}
if err := r.Scan(refs...); err != nil {
return err
}
for i, col := range cols {
a[col] = *refs[i].(*sql.NullString)
}
return nil
} | go | {
"resource": ""
} |
q13961 | all | train | func (r *Rows) all(slice interface{}) error {
defer r.Close()
v := reflect.ValueOf(slice)
if v.Kind() != reflect.Ptr || v.IsNil() {
return VarTypeError("must be a pointer")
}
v = indirect(v)
if v.Kind() != reflect.Slice {
return VarTypeError("must be a slice of struct or NullStringMap")
}
if v.IsNil() {
// create an empty slice
v.Set(reflect.MakeSlice(v.Type(), 0, 0))
}
et := v.Type().Elem()
if et.Kind() == reflect.Map {
for r.Next() {
ev, ok := reflect.MakeMap(et).Interface().(NullStringMap)
if !ok {
return VarTypeError("must be a slice of struct or NullStringMap")
}
if err := r.ScanMap(ev); err != nil {
return err
}
v.Set(reflect.Append(v, reflect.ValueOf(ev)))
}
return r.Close()
}
if et.Kind() != reflect.Struct {
return VarTypeError("must be a slice of struct or NullStringMap")
}
si := getStructInfo(et, r.fieldMapFunc)
cols, _ := r.Columns()
for r.Next() {
ev := reflect.New(et).Elem()
refs := make([]interface{}, len(cols))
for i, col := range cols {
if fi, ok := si.dbNameMap[col]; ok {
refs[i] = fi.getField(ev).Addr().Interface()
} else {
refs[i] = &sql.NullString{}
}
}
if err := r.Scan(refs...); err != nil {
return err
}
v.Set(reflect.Append(v, ev))
}
return r.Close()
} | go | {
"resource": ""
} |
q13962 | column | train | func (r *Rows) column(slice interface{}) error {
defer r.Close()
v := reflect.ValueOf(slice)
if v.Kind() != reflect.Ptr || v.IsNil() {
return VarTypeError("must be a pointer to a slice")
}
v = indirect(v)
if v.Kind() != reflect.Slice {
return VarTypeError("must be a pointer to a slice")
}
et := v.Type().Elem()
cols, _ := r.Columns()
for r.Next() {
ev := reflect.New(et)
refs := make([]interface{}, len(cols))
for i := range cols {
if i == 0 {
refs[i] = ev.Interface()
} else {
refs[i] = &sql.NullString{}
}
}
if err := r.Scan(refs...); err != nil {
return err
}
v.Set(reflect.Append(v, ev.Elem()))
}
return r.Close()
} | go | {
"resource": ""
} |
q13963 | one | train | func (r *Rows) one(a interface{}) error {
defer r.Close()
if !r.Next() {
if err := r.Err(); err != nil {
return err
}
return sql.ErrNoRows
}
var err error
rt := reflect.TypeOf(a)
if rt.Kind() == reflect.Ptr && rt.Elem().Kind() == reflect.Map {
// pointer to map
v := indirect(reflect.ValueOf(a))
if v.IsNil() {
v.Set(reflect.MakeMap(v.Type()))
}
a = v.Interface()
rt = reflect.TypeOf(a)
}
if rt.Kind() == reflect.Map {
v, ok := a.(NullStringMap)
if !ok {
return VarTypeError("must be a NullStringMap")
}
if v == nil {
return VarTypeError("NullStringMap is nil")
}
err = r.ScanMap(v)
} else {
err = r.ScanStruct(a)
}
if err != nil {
return err
}
return r.Close()
} | go | {
"resource": ""
} |
q13964 | row | train | func (r *Rows) row(a ...interface{}) error {
defer r.Close()
for _, dp := range a {
if _, ok := dp.(*sql.RawBytes); ok {
return VarTypeError("RawBytes isn't allowed on Row()")
}
}
if !r.Next() {
if err := r.Err(); err != nil {
return err
}
return sql.ErrNoRows
}
if err := r.Scan(a...); err != nil {
return err
}
return r.Close()
} | go | {
"resource": ""
} |
q13965 | NewQuery | train | func NewQuery(db *DB, executor Executor, sql string) *Query {
rawSQL, placeholders := db.processSQL(sql)
return &Query{
executor: executor,
sql: sql,
rawSQL: rawSQL,
placeholders: placeholders,
params: Params{},
FieldMapper: db.FieldMapper,
LogFunc: db.LogFunc,
PerfFunc: db.PerfFunc,
}
} | go | {
"resource": ""
} |
q13966 | logSQL | train | func (q *Query) logSQL() string {
s := q.sql
for k, v := range q.params {
if valuer, ok := v.(driver.Valuer); ok && valuer != nil {
v, _ = valuer.Value()
}
var sv string
if str, ok := v.(string); ok {
sv = "'" + strings.Replace(str, "'", "''", -1) + "'"
} else if bs, ok := v.([]byte); ok {
sv = "'" + strings.Replace(string(bs), "'", "''", -1) + "'"
} else {
sv = fmt.Sprintf("%v", v)
}
s = strings.Replace(s, "{:"+k+"}", sv, -1)
}
return s
} | go | {
"resource": ""
} |
q13967 | log | train | func (q *Query) log(start time.Time, execute bool) {
if q.LogFunc == nil && q.PerfFunc == nil {
return
}
ns := time.Now().Sub(start).Nanoseconds()
s := q.logSQL()
if q.LogFunc != nil {
if execute {
q.LogFunc("[%.2fms] Execute SQL: %v", float64(ns)/1e6, s)
} else {
q.LogFunc("[%.2fms] Query SQL: %v", float64(ns)/1e6, s)
}
}
if q.PerfFunc != nil {
q.PerfFunc(ns, s, execute)
}
} | go | {
"resource": ""
} |
q13968 | Close | train | func (q *Query) Close() error {
if q.stmt == nil {
return nil
}
err := q.stmt.Close()
q.stmt = nil
return err
} | go | {
"resource": ""
} |
q13969 | Execute | train | func (q *Query) Execute() (result sql.Result, err error) {
err = q.LastError
q.LastError = nil
if err != nil {
return
}
var params []interface{}
params, err = replacePlaceholders(q.placeholders, q.params)
if err != nil {
return
}
defer q.log(time.Now(), true)
if q.ctx == nil {
if q.stmt == nil {
result, err = q.executor.Exec(q.rawSQL, params...)
} else {
result, err = q.stmt.Exec(params...)
}
} else {
if q.stmt == nil {
result, err = q.executor.ExecContext(q.ctx, q.rawSQL, params...)
} else {
result, err = q.stmt.ExecContext(q.ctx, params...)
}
}
return
} | go | {
"resource": ""
} |
q13970 | Row | train | func (q *Query) Row(a ...interface{}) error {
rows, err := q.Rows()
if err != nil {
return err
}
return rows.row(a...)
} | go | {
"resource": ""
} |
q13971 | Column | train | func (q *Query) Column(a interface{}) error {
rows, err := q.Rows()
if err != nil {
return err
}
return rows.column(a)
} | go | {
"resource": ""
} |
q13972 | Rows | train | func (q *Query) Rows() (rows *Rows, err error) {
err = q.LastError
q.LastError = nil
if err != nil {
return
}
var params []interface{}
params, err = replacePlaceholders(q.placeholders, q.params)
if err != nil {
return
}
defer q.log(time.Now(), false)
var rr *sql.Rows
if q.ctx == nil {
if q.stmt == nil {
rr, err = q.executor.Query(q.rawSQL, params...)
} else {
rr, err = q.stmt.Query(params...)
}
} else {
if q.stmt == nil {
rr, err = q.executor.QueryContext(q.ctx, q.rawSQL, params...)
} else {
rr, err = q.stmt.QueryContext(q.ctx, params...)
}
}
rows = &Rows{rr, q.FieldMapper}
return
} | go | {
"resource": ""
} |
q13973 | replacePlaceholders | train | func replacePlaceholders(placeholders []string, params Params) ([]interface{}, error) {
if len(placeholders) == 0 {
return nil, nil
}
var result []interface{}
for _, name := range placeholders {
if value, ok := params[name]; ok {
result = append(result, value)
} else {
return nil, errors.New("Named parameter not found: " + name)
}
}
return result, nil
} | go | {
"resource": ""
} |
q13974 | NewOciBuilder | train | func NewOciBuilder(db *DB, executor Executor) Builder {
return &OciBuilder{
NewBaseBuilder(db, executor),
&OciQueryBuilder{NewBaseQueryBuilder(db)},
}
} | go | {
"resource": ""
} |
q13975 | NewQuery | train | func (b *BaseBuilder) NewQuery(sql string) *Query {
return NewQuery(b.db, b.executor, sql)
} | go | {
"resource": ""
} |
q13976 | Insert | train | func (b *BaseBuilder) Insert(table string, cols Params) *Query {
names := make([]string, 0, len(cols))
for name := range cols {
names = append(names, name)
}
sort.Strings(names)
params := Params{}
columns := make([]string, 0, len(names))
values := make([]string, 0, len(names))
for _, name := range names {
columns = append(columns, b.db.QuoteColumnName(name))
value := cols[name]
if e, ok := value.(Expression); ok {
values = append(values, e.Build(b.db, params))
} else {
values = append(values, fmt.Sprintf("{:p%v}", len(params)))
params[fmt.Sprintf("p%v", len(params))] = value
}
}
var sql string
if len(names) == 0 {
sql = fmt.Sprintf("INSERT INTO %v DEFAULT VALUES", b.db.QuoteTableName(table))
} else {
sql = fmt.Sprintf("INSERT INTO %v (%v) VALUES (%v)",
b.db.QuoteTableName(table),
strings.Join(columns, ", "),
strings.Join(values, ", "),
)
}
return b.NewQuery(sql).Bind(params)
} | go | {
"resource": ""
} |
q13977 | CreateTable | train | func (b *BaseBuilder) CreateTable(table string, cols map[string]string, options ...string) *Query {
names := []string{}
for name := range cols {
names = append(names, name)
}
sort.Strings(names)
columns := []string{}
for _, name := range names {
columns = append(columns, b.db.QuoteColumnName(name)+" "+cols[name])
}
sql := fmt.Sprintf("CREATE TABLE %v (%v)", b.db.QuoteTableName(table), strings.Join(columns, ", "))
for _, opt := range options {
sql += " " + opt
}
return b.NewQuery(sql)
} | go | {
"resource": ""
} |
q13978 | TruncateTable | train | func (b *BaseBuilder) TruncateTable(table string) *Query {
sql := "TRUNCATE TABLE " + b.db.QuoteTableName(table)
return b.NewQuery(sql)
} | go | {
"resource": ""
} |
q13979 | AddColumn | train | func (b *BaseBuilder) AddColumn(table, col, typ string) *Query {
sql := fmt.Sprintf("ALTER TABLE %v ADD %v %v", b.db.QuoteTableName(table), b.db.QuoteColumnName(col), typ)
return b.NewQuery(sql)
} | go | {
"resource": ""
} |
q13980 | CreateIndex | train | func (b *BaseBuilder) CreateIndex(table, name string, cols ...string) *Query {
sql := fmt.Sprintf("CREATE INDEX %v ON %v (%v)",
b.db.QuoteColumnName(name),
b.db.QuoteTableName(table),
b.quoteColumns(cols))
return b.NewQuery(sql)
} | go | {
"resource": ""
} |
q13981 | quoteColumns | train | func (b *BaseBuilder) quoteColumns(cols []string) string {
s := ""
for i, col := range cols {
if i == 0 {
s = b.db.QuoteColumnName(col)
} else {
s += ", " + b.db.QuoteColumnName(col)
}
}
return s
} | go | {
"resource": ""
} |
q13982 | NewMssqlBuilder | train | func NewMssqlBuilder(db *DB, executor Executor) Builder {
return &MssqlBuilder{
NewBaseBuilder(db, executor),
&MssqlQueryBuilder{NewBaseQueryBuilder(db)},
}
} | go | {
"resource": ""
} |
q13983 | NewMysqlBuilder | train | func NewMysqlBuilder(db *DB, executor Executor) Builder {
return &MysqlBuilder{
NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | go | {
"resource": ""
} |
q13984 | DropForeignKey | train | func (b *MysqlBuilder) DropForeignKey(table, name string) *Query {
sql := fmt.Sprintf("ALTER TABLE %v DROP FOREIGN KEY %v", b.db.QuoteTableName(table), b.db.QuoteColumnName(name))
return b.db.NewQuery(sql)
} | go | {
"resource": ""
} |
q13985 | NewFromDB | train | func NewFromDB(sqlDB *sql.DB, driverName string) *DB {
db := &DB{
driverName: driverName,
sqlDB: sqlDB,
FieldMapper: DefaultFieldMapFunc,
}
db.Builder = db.newBuilder(db.sqlDB)
return db
} | go | {
"resource": ""
} |
q13986 | Clone | train | func (db *DB) Clone() *DB {
db2 := &DB{
driverName: db.driverName,
sqlDB: db.sqlDB,
FieldMapper: db.FieldMapper,
PerfFunc: db.PerfFunc,
LogFunc: db.LogFunc,
}
db2.Builder = db2.newBuilder(db.sqlDB)
return db2
} | go | {
"resource": ""
} |
q13987 | BeginTx | train | func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
tx, err := db.sqlDB.BeginTx(ctx, opts)
if err != nil {
return nil, err
}
return &Tx{db.newBuilder(tx), tx}, nil
} | go | {
"resource": ""
} |
q13988 | Wrap | train | func (db *DB) Wrap(sqlTx *sql.Tx) *Tx {
return &Tx{db.newBuilder(sqlTx), sqlTx}
} | go | {
"resource": ""
} |
q13989 | Transactional | train | func (db *DB) Transactional(f func(*Tx) error) (err error) {
tx, err := db.Begin()
if err != nil {
return err
}
defer func() {
if p := recover(); p != nil {
tx.Rollback()
panic(p)
} else if err != nil {
if err2 := tx.Rollback(); err2 != nil {
if err2 == sql.ErrTxDone {
return
}
err = Errors{err, err2}
}
} else {
if err = tx.Commit(); err == sql.ErrTxDone {
err = nil
}
}
}()
err = f(tx)
return err
} | go | {
"resource": ""
} |
q13990 | TransactionalContext | train | func (db *DB) TransactionalContext(ctx context.Context, opts *sql.TxOptions, f func(*Tx) error) (err error) {
tx, err := db.BeginTx(ctx, opts)
if err != nil {
return err
}
defer func() {
if p := recover(); p != nil {
tx.Rollback()
panic(p)
} else if err != nil {
if err2 := tx.Rollback(); err2 != nil {
if err2 == sql.ErrTxDone {
return
}
err = Errors{err, err2}
}
} else {
if err = tx.Commit(); err == sql.ErrTxDone {
err = nil
}
}
}()
err = f(tx)
return err
} | go | {
"resource": ""
} |
q13991 | QuoteTableName | train | func (db *DB) QuoteTableName(s string) string {
if strings.Contains(s, "(") || strings.Contains(s, "{{") {
return s
}
if !strings.Contains(s, ".") {
return db.QuoteSimpleTableName(s)
}
parts := strings.Split(s, ".")
for i, part := range parts {
parts[i] = db.QuoteSimpleTableName(part)
}
return strings.Join(parts, ".")
} | go | {
"resource": ""
} |
q13992 | QuoteColumnName | train | func (db *DB) QuoteColumnName(s string) string {
if strings.Contains(s, "(") || strings.Contains(s, "{{") || strings.Contains(s, "[[") {
return s
}
prefix := ""
if pos := strings.LastIndex(s, "."); pos != -1 {
prefix = db.QuoteTableName(s[:pos]) + "."
s = s[pos+1:]
}
return prefix + db.QuoteSimpleColumnName(s)
} | go | {
"resource": ""
} |
q13993 | newBuilder | train | func (db *DB) newBuilder(executor Executor) Builder {
builderFunc, ok := BuilderFuncMap[db.driverName]
if !ok {
builderFunc = NewStandardBuilder
}
return builderFunc(db, executor)
} | go | {
"resource": ""
} |
q13994 | Delete | train | func (q *ModelQuery) Delete() error {
if q.lastError != nil {
return q.lastError
}
pk := q.model.pk()
if len(pk) == 0 {
return MissingPKError
}
_, err := q.builder.Delete(q.model.tableName, HashExp(pk)).WithContext(q.ctx).Execute()
return err
} | go | {
"resource": ""
} |
q13995 | NewStandardBuilder | train | func NewStandardBuilder(db *DB, executor Executor) Builder {
return &StandardBuilder{
NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | go | {
"resource": ""
} |
q13996 | NewSqliteBuilder | train | func NewSqliteBuilder(db *DB, executor Executor) Builder {
return &SqliteBuilder{
NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | go | {
"resource": ""
} |
q13997 | DropColumn | train | func (b *SqliteBuilder) DropColumn(table, col string) *Query {
q := b.NewQuery("")
q.LastError = errors.New("SQLite does not support dropping columns")
return q
} | go | {
"resource": ""
} |
q13998 | AlterColumn | train | func (b *SqliteBuilder) AlterColumn(table, col, typ string) *Query {
q := b.NewQuery("")
q.LastError = errors.New("SQLite does not support altering column")
return q
} | go | {
"resource": ""
} |
q13999 | DropPrimaryKey | train | func (b *SqliteBuilder) DropPrimaryKey(table, name string) *Query {
q := b.NewQuery("")
q.LastError = errors.New("SQLite does not support dropping primary key")
return q
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.