id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c181500 |
if err != nil {
return err
}
return check(resp)
} | |
c181501 | _, err := kr.api.c.postJSON(kickChatMember, resp, kr)
if err != nil {
return err
}
return check(resp)
} | |
c181502 |
_, err := ub.api.c.postJSON(unbanChatMember, resp, ub)
if err != nil {
return err
}
return check(resp)
} | |
c181503 | cbr.api.c.postJSON(answerCallbackQuery, resp, cbr)
if err != nil {
return err
}
return check(resp)
} | |
c181504 | c.cfg = cfg
c.common.client = c
// API Services
c.ServiceProviderConfigApi = (*ServiceProviderConfigApiService)(&c.common)
c.UserApi = (*UserApiService)(&c.common)
return c
} | |
c181505 |
n := now()
ts.CreatedAt = n
ts.UpdatedAt = n
return nil
} | |
c181506 | "" {
return cname
}
return fmt.Sprintf("%s.%s", d.Quote(tname), cname)
} | |
c181507 |
if err != nil {
return nil, err
}
return &DB{db: db, dialect: dialect, logger: defaultLogger}, nil
} | |
c181508 | struct (or that pointer) type, got %v", t))
}
return &From{TableName: db.tableName(t)}
} | |
c181509 | newCondition(db).Where(cond, args...)
} | |
c181510 | return newCondition(db).OrderBy(table, column, order...)
} | |
c181511 | {
return newCondition(db).Limit(lim)
} | |
c181512 | {
return newCondition(db).Offset(offset)
} | |
c181513 | {
return (&JoinCondition{db: db}).Join(table)
} | |
c181514 | default:
panic(fmt.Errorf("Count: a number of argument must be 0 or 1, got %v", len(column)))
}
return &Function{
Name: "COUNT",
Args: column,
}
} | |
c181515 | %s WHERE %s = %s",
db.dialect.Quote(tableName),
strings.Join(sets, ", "),
db.dialect.Quote(db.columnFromTag(rtype.FieldByIndex(pkIdx))),
db.dialect.PlaceHolder(len(fieldIndexes)))
args = append(args, rv.FieldByIndex(pkIdx).Interface())
stmt, err := db.prepare(query, args...)
if err != nil {
return -1, err
}
defer stmt.Close()
result, err := stmt.Exec(args...)
if err != nil {
return -1, err
}
affected, _ = result.RowsAffected()
if hook, ok := obj.(AfterUpdater); ok {
if err := hook.AfterUpdate(); err != nil {
return affected, err
}
}
return affected, nil
} | |
c181516 |
holders[i] = db.dialect.PlaceHolder(i)
}
query := fmt.Sprintf("DELETE FROM %s WHERE %s IN (%s)",
db.dialect.Quote(tableName),
db.dialect.Quote(db.columnFromTag(rtype.FieldByIndex(pkIdx))),
strings.Join(holders, ", "))
stmt, err := db.prepare(query, args...)
if err != nil {
return -1, err
}
defer stmt.Close()
result, err := stmt.Exec(args...)
if err != nil {
return -1, err
}
affected, _ = result.RowsAffected()
for _, obj := range objs {
if hook, ok := obj.(AfterDeleter); ok {
if err := hook.AfterDelete(); err != nil {
return affected, err
}
}
}
return affected, nil
} | |
c181517 | }
db.m.Lock()
defer db.m.Unlock()
db.tx = tx
return nil
} | |
c181518 | ErrTxDone
}
err := db.tx.Commit()
db.tx = nil
return err
} | |
c181519 | db.dialect.Quote(s)
} | |
c181520 | = &templateLogger{w: w, t: defaultLoggerTemplate}
}
} | |
c181521 |
fieldIndexes[i] = index
}
dest := make([]interface{}, len(columns))
var result []reflect.Value
for rows.Next() {
v := reflect.New(t).Elem()
for i, index := range fieldIndexes {
field := v.FieldByIndex(index)
dest[i] = field.Addr().Interface()
}
if err := rows.Scan(dest...); err != nil {
return reflect.Value{}, err
}
result = append(result, v)
}
if err := rows.Err(); err != nil {
return reflect.Value{}, err
}
for i := 0; i < ptrN; i++ {
t = reflect.PtrTo(t)
}
slice := reflect.MakeSlice(reflect.SliceOf(t), len(result), len(result))
for i, v := range result {
for j := 0; j < ptrN; j++ {
v = v.Addr()
}
slice.Index(i).Set(v)
}
return slice, nil
} | |
c181522 | nil {
return reflect.Value{}, err
}
}
for i := 0; i < ptrN; i++ {
dest = dest.Addr()
}
return dest, nil
} | |
c181523 |
if idx := db.fieldIndexByName(field.Type, name, append(index, i)); len(idx) > 0 {
return append(index, idx...)
}
}
}
return nil
} | |
c181524 | case Raw:
names[i] = fmt.Sprint(*c)
case string:
names[i] = ColumnName(db.dialect, tableName, c)
case *Distinct:
names[i] = fmt.Sprintf("DISTINCT %s", db.columns(tableName, ToInterfaceSlice(c.columns)))
default:
panic(fmt.Errorf("column name must be string, Raw or *Distinct, got %T", c))
}
}
return strings.Join(names, ", ")
} | |
c181525 | if t := strings.ToLower(strings.TrimSpace(tag)); t != "" {
options = append(options, t)
}
}
return options
} | |
c181526 | field.Tag.Get(dbTag) == skipTag {
return true
}
return false
} | |
c181527 | tag := range db.tagsFromField(field) {
if tag == "pk" {
return true
}
}
return false
} | |
c181528 | reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
return true
}
return false
} | |
c181529 | tmp[len(tmp)-1] = i
if field.Anonymous {
indexes = append(indexes, db.collectFieldIndexes(field.Type, tmp)...)
} else {
indexes = append(indexes, tmp)
}
}
}
return indexes
} | |
c181530 | db.findPKIndex(field.Type, append(index, i)); idx != nil {
return append(index, idx...)
}
continue
}
if db.hasPKTag(&field) {
return append(index, i)
}
}
return nil
} | |
c181531 | {
size, err = strconv.ParseUint(s, 10, 64)
}
return size, err
} | |
c181532 | return stringutil.ToSnakeCase(field.Name)
}
return col
} | |
c181533 |
return "", err
}
return fmt.Sprintf("DEFAULT %v", db.dialect.FormatBool(b)), nil
}
return fmt.Sprintf("DEFAULT %v", def), nil
} | |
c181534 | c.appendQueryByCondOrExpr("Where", 0, Where, cond, args...)
} | |
c181535 | c.appendQueryByCondOrExpr("And", 100, And, cond, args...)
} | |
c181536 | c.appendQueryByCondOrExpr("Or", 100, Or, cond, args...)
} | |
c181537 | c.appendQuery(100, Like, arg)
} | |
c181538 | c.appendQuery(100, Between, &between{from, to})
} | |
c181539 |
if len(rest) < 2 {
panic(fmt.Errorf("OrderBy: few arguments"))
}
// OrderBy(tbl{}, "column", genmai.DESC)
orderbys = append(orderbys, c.orderBy(o, rest[0], rest[1]))
order = rest[2:]
}
return c.appendQuery(300, OrderBy, orderbys)
} | |
c181540 | {
return c.appendQuery(500, Limit, lim)
} | |
c181541 | c.appendQuery(700, Offset, offset)
} | |
c181542 | template.New("genmai").Parse(format)
if err != nil {
return err
}
l.t = t
return nil
} | |
c181543 | var buf bytes.Buffer
if err := l.t.Execute(&buf, data); err != nil {
return err
}
l.m.Lock()
defer l.m.Unlock()
if _, err := fmt.Fprintln(l.w, strings.TrimSuffix(buf.String(), "\n")); err != nil {
return err
}
return nil
} | |
c181544 | query string, args ...interface{}) error {
return nil
} | |
c181545 | strings.Replace(s, "`", "``", -1))
} | |
c181546 | *int64, *uint64, sql.NullInt64:
return d.bigint(autoIncrement), true
case string:
return d.varchar(size), false
case *string, sql.NullString:
return d.varchar(size), true
case []byte:
return "bytea", true
case time.Time:
return "timestamp with time zone", false
case *time.Time:
return "timestamp with time zone", true
case Rat:
return fmt.Sprintf("numeric(%d, %d)", decimalPrecision, decimalScale), false
case *Rat:
return fmt.Sprintf("numeric(%d, %d)", decimalPrecision, decimalScale), true
case Float32, Float64:
return "double precision", false
case *Float32, *Float64:
return "double precision", true
case float32, *float32, float64, *float64, sql.NullFloat64:
panic(ErrUsingFloatType)
}
panic(fmt.Errorf("PostgresDialect: unsupported SQL type: %T", v))
} | |
c181547 | return zip.New(file)
}
return tar.New(file)
} | |
c181548 | nil &&
h.handle != C.VIX_INVALID_HANDLE {
C.VixHost_Disconnect(h.handle)
h.handle = C.VIX_INVALID_HANDLE
}
} | |
c181549 | present, its id is recycled
if vmx[ethN+".present"] == "FALSE" {
return number
}
if number > nextID {
nextID = number
}
}
}
nextID++
return nextID
} | |
c181550 | {
ethN := strings.Split(key, ".")[0]
number, _ := strconv.Atoi(strings.Split(ethN, prefix)[1])
if number > total {
total = number
}
}
}
return total
} | |
c181551 | := range vmx {
if strings.HasPrefix(key, "ethernet") {
delete(vmx, key)
}
}
return writeVmx(vmxPath, vmx)
} | |
c181552 |
if err != nil {
return err
}
device := "ethernet" + adapter.ID
for key := range vmx {
if strings.HasPrefix(key, device) {
delete(vmx, key)
}
}
vmx[device+".present"] = "FALSE"
err = writeVmx(vmxPath, vmx)
if err != nil {
return err
}
return nil
} | |
c181553 | net.ParseMAC(vmx[prefix+".address"])
genAddress, _ := net.ParseMAC(vmx[prefix+".generatedAddress"])
vswitch, _ := GetVSwitch(vmx[prefix+".vnet"])
adapter := &NetworkAdapter{
ID: id,
present: present,
ConnType: NetworkType(vmx[prefix+".connectionType"]),
Vdevice: VNetDevice(vmx[prefix+".virtualDev"]),
WakeOnPcktRcv: wakeOnPckRcv,
LinkStatePropagation: lnkStateProp,
MacAddrType: MacAddressType(vmx[prefix+".addressType"]),
MacAddress: address,
VSwitch: vswitch,
StartConnected: startConnected,
GeneratedMacAddress: genAddress,
GeneratedMacAddressOffset: vmx[prefix+".generatedAddressOffset"],
PciSlotNumber: vmx[prefix+".pciSlotNumber"],
}
adapters = append(adapters, adapter)
}
return adapters, nil
} | |
c181554 | }
entries, err := parse7zListOutput(out)
if err != nil {
return nil, err
}
return &Archive{
Path: path,
Entries: entries,
password: password,
}, nil
} | |
c181555 |
params = append(params, a.Path, name)
cmd := exec.Command("7z", params...)
stdout, err := cmd.StdoutPipe()
rc := &readCloser{
rc: stdout,
cmd: cmd,
}
err = cmd.Start()
if err != nil {
stdout.Close()
return nil, err
}
return rc, nil
} | |
c181556 | if err != nil {
return err
}
_, err = io.Copy(dst, r)
err2 := r.Close()
if err != nil {
return err
}
return err2
} | |
c181557 | return err
}
defer f.Close()
return a.ExtractToWriter(f, name)
} | |
c181558 | Operation: "guest.SharedFoldersParentDir",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(path), nil
} | |
c181559 | Operation: "snapshot.Name",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(name), nil
} | |
c181560 | Operation: "snapshot.Description",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(desc), nil
} | |
c181561 | {
C.Vix_ReleaseHandle(s.handle)
s.handle = C.VIX_INVALID_HANDLE
}
} | |
c181562 |
bus = vmx.SCSI
case strings.HasPrefix(ID, string(vmx.SATA)):
bus = vmx.SATA
}
return bus
} | |
c181563 |
err = vmx.Unmarshal(data, model)
if err != nil {
return err
}
vmxfile.model = model
return nil
} | |
c181564 |
data, err := vmx.Marshal(vmxfile.model)
if err != nil {
return err
}
_, err = file.Write(data)
if err != nil {
return err
}
return nil
} | |
c181565 | err
}
vm := &VM{
handle: handle,
vmxfile: vmxfile,
}
runtime.SetFinalizer(vm, cleanupVM)
return vm, nil
} | |
c181566 | Operation: "vm.Vcpus",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return uint8(vcpus), nil
} | |
c181567 | Operation: "vm.VmxPath",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(path), nil
} | |
c181568 | Operation: "vm.MemorySize",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return uint(memsize), nil
} | |
c181569 | Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
if readonly == 0 {
return false, nil
}
return true, nil
} | |
c181570 | Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
if inTeam == 0 {
return false, nil
}
return true, nil
} | |
c181571 | Operation: "vm.PowerState",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return VMPowerState(state), nil
} | |
c181572 | Operation: "vm.ToolsState",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return GuestToolsState(state), nil
} | |
c181573 | Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
if running == 0 {
return false, nil
}
return true, nil
} | |
c181574 | Operation: "vm.GuestOS",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(os), nil
} | |
c181575 | {
C.Vix_ReleaseHandle(v.handle)
v.handle = C.VIX_INVALID_HANDLE
}
} | |
c181576 | return &Error{
Operation: "vm.updateVMX",
Code: 300001,
Text: fmt.Sprintf("Error reading vmx file: %s", err),
}
}
err = updateFunc(v.vmxfile.model)
if err != nil {
return &Error{
Operation: "vm.updateVMX",
Code: 300002,
Text: fmt.Sprintf("Error changing vmx value: %s", err),
}
}
err = v.vmxfile.Write()
if err != nil {
return &Error{
Operation: "vm.updateVMX",
Code: 300003,
Text: fmt.Sprintf("Error writing vmx file: %s", err),
}
}
return nil
} | |
c181577 | uint(math.Floor(float64((size / 4) * 4)))
}
return v.updateVMX(func(model *vmx.VirtualMachine) error {
model.Memsize = size
return nil
})
} | |
c181578 | 1
}
return v.updateVMX(func(model *vmx.VirtualMachine) error {
model.NumvCPUs = vcpus
return nil
})
} | |
c181579 | {
model.DisplayName = name
return nil
})
} | |
c181580 | {
model.Annotation = text
return nil
})
} | |
c181581 | }
model.Vhardware.Compat = "hosted"
model.Vhardware.Version = int(version)
return nil
})
} | |
c181582 | operation: %s", e.Text, e.Code, e.Operation)
} | |
c181583 | wrap(fmt.Errorf(message, a...))
} | |
c181584 | += fmt.Sprintf("\n at %s", frame.string())
}
return str
} | |
c181585 | fmt.Sprintf("%s (%s:%d)", s.function, s.file, s.line)
} | |
c181586 | return &stackFrame{
file: filepath.Join(packagePath, fileName),
line: line,
function: funcSignature,
}
} | |
c181587 | i, pc := range pcs[0:count] {
frames[i] = newStackFrame(pc)
}
return frames
} | |
c181588 |
parts := regEx.FindStringSubmatch(fnName)
packagePath = parts[1]
signature = parts[2]
return
} | |
c181589 | false)]
log.Printf("%v\n%s", err, stack)
} | |
c181590 | {
log.Printf("%s: %v\n%s", pack, err, stack)
} else {
log.Printf("%v\n%s", err, stack)
}
} | |
c181591 | {
f(p)
}
return w.Writer.Write(p)
} | |
c181592 | int(httpResponseStruct(reflect.ValueOf(w)).FieldByName("status").Int())
} | |
c181593 |
}
if v.Type().String() == "http.response" {
return v
}
return httpResponseStruct(v.FieldByName("ResponseWriter").Elem())
} | |
c181594 | = http.DetectContentType(p)
w.Header().Set("Content-Type", ct)
}
return ct
} | |
c181595 | = http.StatusInternalServerError
e.Errno = 0
e.Message = message
return e
} | |
c181596 | = 0
e.Message = message
e.DBName = dbName
return e
} | |
c181597 | http.StatusBadRequest
e.Errno = 0
e.Message = message
return e
} | |
c181598 | http.StatusNotFound
e.Errno = 0
e.Message = message
return e
} | |
c181599 | }
b := c.Validate.Length(v, n)
if b == false {
panic((&ValidationError{}).New(fieldName + "长度应该为" + strconv.Itoa(n)))
}
return v
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.