id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c13900 | = dtResetAbilities
worker.broadcast(outpack)
worker.funcs = make(jobFuncs)
} | |
c13901 | dtSetClientId
outpack.data = []byte(id)
worker.broadcast(outpack)
} | |
c13902 | 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.han... | |
c13903 |
return e.agent.net, e.agent.addr
} | |
c13904 | fallthrough
case dtWorkComplete:
data = resp.Data
default:
err = ErrDataType
}
return
} | |
c13905 | dtWorkWarning {
err = ErrDataType
return
}
data = resp.Data
if resp.DataType == dtWorkWarning {
err = ErrWorkWarning
}
return
} | |
c13906 |
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.Er... | |
c13907 | outpack.data = getBuffer(l)
copy(outpack.data, []byte(inpack.handle))
copy(outpack.data[hl+1:], data)
inpack.a.write(outpack)
} | |
c13908 | + 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)
} | |
c13909 | := 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[... | |
c13910 | primaryBkt.Lock()
if bkt == nil {
bkt = &bucket{lookup: make(map[string]*Item)}
primaryBkt.buckets[primary] = bkt
}
primaryBkt.Unlock()
return &SecondaryCache{
bucket: bkt,
pCache: c,
}
} | |
c13911 | return false
}
c.Set(primary, secondary, value, item.TTL())
return true
} | |
c13912 |
value, err := fetch()
if err != nil {
return nil, err
}
return c.set(primary, secondary, value, duration), nil
} | |
c13913 | c.bucket(primary).deleteAll(primary, c.deletables)
} | |
c13914 | range c.buckets {
bucket.clear()
}
c.size = 0
c.list = list.New()
} | |
c13915 | return false
}
c.Set(key, value, item.TTL())
return true
} | |
c13916 | return s.bucket.get(secondary)
} | |
c13917 | nil {
s.pCache.deletables <- existing
}
s.pCache.promote(item)
return item
} | |
c13918 |
value, err := fetch()
if err != nil {
return nil, err
}
return s.Set(secondary, value, duration), nil
} | |
c13919 |
if item != nil {
s.pCache.deletables <- item
return true
}
return false
} | |
c13920 | {
return false
}
s.Set(secondary, value, item.TTL())
return true
} | |
c13921 | nil {
return NilTracked
}
item.track()
return item
} | |
c13922 | {
case info.ContentType.Equal(oidSignedData):
return parseSignedData(info.Content.Bytes)
case info.ContentType.Equal(oidEnvelopedData):
return parseEnvelopedData(info.Content.Bytes)
}
return nil, ErrUnsupportedContentType
} | |
c13923 | getCertFromCertsByIssuerAndSerial(p7.Certificates, signer.IssuerAndSerialNumber)
} | |
c13924 | {
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
} | |
c13925 | }
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: oidDigestAlgori... | |
c13926 | *x509.Certificate) {
sd.certs = append(sd.certs, cert)
} | |
c13927 | := complexityVisitor{}
ast.Walk(&v, fn)
return v.Complexity
} | |
c13928 | := generateFixturesForTable(db, helper, &TableInfo{Name: table}, filename); err != nil {
return err
}
}
return nil
} | |
c13929 | union: []UnionInfo{},
limit: -1,
params: Params{},
FieldMapper: db.FieldMapper,
}
} | |
c13930 | *SelectQuery {
s.selects = cols
return s
} | |
c13931 | = append(s.selects, cols...)
return s
} | |
c13932 | s.distinct = v
return s
} | |
c13933 | s.selectOption = option
return s
} | |
c13934 | *SelectQuery {
s.from = tables
return s
} | |
c13935 |
s.where = e
return s
} | |
c13936 | return s.Join("INNER JOIN", table, on)
} | |
c13937 | return s.Join("LEFT JOIN", table, on)
} | |
c13938 | return s.Join("RIGHT JOIN", table, on)
} | |
c13939 | *SelectQuery {
s.orderBy = cols
return s
} | |
c13940 | = append(s.orderBy, cols...)
return s
} | |
c13941 | *SelectQuery {
s.groupBy = cols
return s
} | |
c13942 | = append(s.groupBy, cols...)
return s
} | |
c13943 | *SelectQuery {
s.having = e
return s
} | |
c13944 | append(s.union, UnionInfo{false, q})
return s
} | |
c13945 | append(s.union, UnionInfo{true, q})
return s
} | |
c13946 | s.limit = limit
return s
} | |
c13947 | s.offset = offset
return s
} | |
c13948 | *SelectQuery {
s.params = params
return s
} | |
c13949 | 0 {
s.params = params
} else {
for k, v := range params {
s.params[k] = v
}
}
return s
} | |
c13950 |
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 =... | |
c13951 | NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | |
c13952 | 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()
} | |
c13953 | for _, table := range tables {
table = q.quoteTableNameAndAlias(table)
if s == "" {
s = table
} else {
s += ", " + table
}
}
return "FROM " + s
} | |
c13954 | if join.On != nil {
on = join.On.Build(q.db, params)
}
if on != "" {
sql += " ON " + on
}
parts = append(parts, sql)
}
return strings.Join(parts, " ")
} | |
c13955 | if c := e.Build(q.db, params); c != "" {
return "WHERE " + c
}
}
return ""
} | |
c13956 | s = q.db.QuoteColumnName(col)
} else {
s += ", " + q.db.QuoteColumnName(col)
}
}
return "GROUP BY " + s
} | |
c13957 | }
u := "UNION"
if union.All {
u = "UNION ALL"
}
sql += fmt.Sprintf("%v (%v)", u, union.Query.sql)
}
return sql
} | |
c13958 | else {
col := col[:len(col)-len(matches[0])]
dir := matches[1]
s += q.db.QuoteColumnName(col) + " " + dir
}
}
return "ORDER BY " + s
} | |
c13959 | limit >= 0 {
sql = fmt.Sprintf("LIMIT %v", limit)
}
if offset <= 0 {
return sql
}
if sql != "" {
sql += " "
}
return sql + fmt.Sprintf("OFFSET %v", offset)
} | |
c13960 | err != nil {
return err
}
for i, col := range cols {
a[col] = *refs[i].(*sql.NullString)
}
return nil
} | |
c13961 | 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 {
r... | |
c13962 | 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()
} | |
c13963 | 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()
} | |
c13964 | := r.Err(); err != nil {
return err
}
return sql.ErrNoRows
}
if err := r.Scan(a...); err != nil {
return err
}
return r.Close()
} | |
c13965 | Params{},
FieldMapper: db.FieldMapper,
LogFunc: db.LogFunc,
PerfFunc: db.PerfFunc,
}
} | |
c13966 | strings.Replace(string(bs), "'", "''", -1) + "'"
} else {
sv = fmt.Sprintf("%v", v)
}
s = strings.Replace(s, "{:"+k+"}", sv, -1)
}
return s
} | |
c13967 | float64(ns)/1e6, s)
} else {
q.LogFunc("[%.2fms] Query SQL: %v", float64(ns)/1e6, s)
}
}
if q.PerfFunc != nil {
q.PerfFunc(ns, s, execute)
}
} | |
c13968 | err := q.stmt.Close()
q.stmt = nil
return err
} | |
c13969 | 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
} | |
c13970 |
return err
}
return rows.row(a...)
} | |
c13971 |
return err
}
return rows.column(a)
} | |
c13972 | 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
} | |
c13973 |
result = append(result, value)
} else {
return nil, errors.New("Named parameter not found: " + name)
}
}
return result, nil
} | |
c13974 | &OciBuilder{
NewBaseBuilder(db, executor),
&OciQueryBuilder{NewBaseQueryBuilder(db)},
}
} | |
c13975 | NewQuery(b.db, b.executor, sql)
} | |
c13976 | 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, ", "),
)
}
re... | |
c13977 | }
sql := fmt.Sprintf("CREATE TABLE %v (%v)", b.db.QuoteTableName(table), strings.Join(columns, ", "))
for _, opt := range options {
sql += " " + opt
}
return b.NewQuery(sql)
} | |
c13978 | {
sql := "TRUNCATE TABLE " + b.db.QuoteTableName(table)
return b.NewQuery(sql)
} | |
c13979 | %v", b.db.QuoteTableName(table), b.db.QuoteColumnName(col), typ)
return b.NewQuery(sql)
} | |
c13980 | b.db.QuoteTableName(table),
b.quoteColumns(cols))
return b.NewQuery(sql)
} | |
c13981 | else {
s += ", " + b.db.QuoteColumnName(col)
}
}
return s
} | |
c13982 | &MssqlBuilder{
NewBaseBuilder(db, executor),
&MssqlQueryBuilder{NewBaseQueryBuilder(db)},
}
} | |
c13983 | NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | |
c13984 | KEY %v", b.db.QuoteTableName(table), b.db.QuoteColumnName(name))
return b.db.NewQuery(sql)
} | |
c13985 | sqlDB,
FieldMapper: DefaultFieldMapFunc,
}
db.Builder = db.newBuilder(db.sqlDB)
return db
} | |
c13986 | FieldMapper: db.FieldMapper,
PerfFunc: db.PerfFunc,
LogFunc: db.LogFunc,
}
db2.Builder = db2.newBuilder(db.sqlDB)
return db2
} | |
c13987 | nil {
return nil, err
}
return &Tx{db.newBuilder(tx), tx}, nil
} | |
c13988 | &Tx{db.newBuilder(sqlTx), sqlTx}
} | |
c13989 | return
}
err = Errors{err, err2}
}
} else {
if err = tx.Commit(); err == sql.ErrTxDone {
err = nil
}
}
}()
err = f(tx)
return err
} | |
c13990 | if err2 == sql.ErrTxDone {
return
}
err = Errors{err, err2}
}
} else {
if err = tx.Commit(); err == sql.ErrTxDone {
err = nil
}
}
}()
err = f(tx)
return err
} | |
c13991 | {
return db.QuoteSimpleTableName(s)
}
parts := strings.Split(s, ".")
for i, part := range parts {
parts[i] = db.QuoteSimpleTableName(part)
}
return strings.Join(parts, ".")
} | |
c13992 | != -1 {
prefix = db.QuoteTableName(s[:pos]) + "."
s = s[pos+1:]
}
return prefix + db.QuoteSimpleColumnName(s)
} | |
c13993 |
if !ok {
builderFunc = NewStandardBuilder
}
return builderFunc(db, executor)
} | |
c13994 | if len(pk) == 0 {
return MissingPKError
}
_, err := q.builder.Delete(q.model.tableName, HashExp(pk)).WithContext(q.ctx).Execute()
return err
} | |
c13995 | NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | |
c13996 | NewBaseBuilder(db, executor),
NewBaseQueryBuilder(db),
}
} | |
c13997 | errors.New("SQLite does not support dropping columns")
return q
} | |
c13998 |
q := b.NewQuery("")
q.LastError = errors.New("SQLite does not support altering column")
return q
} | |
c13999 | = errors.New("SQLite does not support dropping primary key")
return q
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.