_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14500 | SetWindowsIgnoreFlushesDuringBoot | train | func (g *Generator) SetWindowsIgnoreFlushesDuringBoot(ignore bool) {
g.initConfigWindows()
g.Config.Windows.IgnoreFlushesDuringBoot = ignore
} | go | {
"resource": ""
} |
q14501 | AddWindowsLayerFolders | train | func (g *Generator) AddWindowsLayerFolders(folder string) {
g.initConfigWindows()
g.Config.Windows.LayerFolders = append(g.Config.Windows.LayerFolders, folder)
} | go | {
"resource": ""
} |
q14502 | AddWindowsDevices | train | func (g *Generator) AddWindowsDevices(id, idType string) error {
if idType != "class" {
return fmt.Errorf("Invalid idType value: %s. Windows only supports a value of class", idType)
}
device := rspec.WindowsDevice{
ID: id,
IDType: idType,
}
g.initConfigWindows()
for i, device := range g.Config.Windows.... | go | {
"resource": ""
} |
q14503 | SetWindowsNetwork | train | func (g *Generator) SetWindowsNetwork(network rspec.WindowsNetwork) {
g.initConfigWindows()
g.Config.Windows.Network = &network
} | go | {
"resource": ""
} |
q14504 | SetWindowsNetworkAllowUnqualifiedDNSQuery | train | func (g *Generator) SetWindowsNetworkAllowUnqualifiedDNSQuery(setting bool) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.AllowUnqualifiedDNSQuery = setting
} | go | {
"resource": ""
} |
q14505 | SetWindowsNetworkNamespace | train | func (g *Generator) SetWindowsNetworkNamespace(path string) {
g.initConfigWindowsNetwork()
g.Config.Windows.Network.NetworkNamespace = path
} | go | {
"resource": ""
} |
q14506 | SetWindowsResourcesCPU | train | func (g *Generator) SetWindowsResourcesCPU(cpu rspec.WindowsCPUResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.CPU = &cpu
} | go | {
"resource": ""
} |
q14507 | SetWindowsResourcesMemoryLimit | train | func (g *Generator) SetWindowsResourcesMemoryLimit(limit uint64) {
g.initConfigWindowsResourcesMemory()
g.Config.Windows.Resources.Memory.Limit = &limit
} | go | {
"resource": ""
} |
q14508 | SetWindowsResourcesStorage | train | func (g *Generator) SetWindowsResourcesStorage(storage rspec.WindowsStorageResources) {
g.initConfigWindowsResources()
g.Config.Windows.Resources.Storage = &storage
} | go | {
"resource": ""
} |
q14509 | SetWindowsServicing | train | func (g *Generator) SetWindowsServicing(servicing bool) {
g.initConfigWindows()
g.Config.Windows.Servicing = servicing
} | go | {
"resource": ""
} |
q14510 | ValidateLinuxResourcesDevices | train | func ValidateLinuxResourcesDevices(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find devices")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetDevicesData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get dev... | go | {
"resource": ""
} |
q14511 | IsAncestor | train | func IsAncestor(os, pathA, pathB, cwd string) (_ bool, err error) {
if pathA == pathB {
return false, nil
}
pathA, err = Abs(os, pathA, cwd)
if err != nil {
return false, err
}
pathB, err = Abs(os, pathB, cwd)
if err != nil {
return false, err
}
sep := Separator(os)
if !strings.HasSuffix(pathA, string(... | go | {
"resource": ""
} |
q14512 | ValidateLinuxResourcesNetwork | train | func ValidateLinuxResourcesNetwork(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find network cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lnd, err := cg.GetNetworkData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "... | go | {
"resource": ""
} |
q14513 | ValidateLinuxResourcesMemory | train | func ValidateLinuxResourcesMemory(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find memory cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lm, err := cg.GetMemoryData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get ... | go | {
"resource": ""
} |
q14514 | ParseLevel | train | func ParseLevel(level string) (Level, error) {
switch strings.ToUpper(level) {
case "MAY":
fallthrough
case "OPTIONAL":
return May, nil
case "SHOULD":
fallthrough
case "SHOULDNOT":
fallthrough
case "RECOMMENDED":
fallthrough
case "NOTRECOMMENDED":
return Should, nil
case "MUST":
fallthrough
case ... | go | {
"resource": ""
} |
q14515 | String | train | func (level Level) String() string {
switch level {
case May:
return "MAY"
case Optional:
return "OPTIONAL"
case Should:
return "SHOULD"
case ShouldNot:
return "SHOULD NOT"
case Recommended:
return "RECOMMENDED"
case NotRecommended:
return "NOT RECOMMENDED"
case Must:
return "MUST"
case MustNot:
... | go | {
"resource": ""
} |
q14516 | Error | train | func (err *Error) Error() string {
return fmt.Sprintf("%s\nRefer to: %s", err.Err.Error(), err.Reference)
} | go | {
"resource": ""
} |
q14517 | NewRuntime | train | func NewRuntime(runtimeCommand string, bundleDir string) (Runtime, error) {
var r Runtime
var err error
r.RuntimeCommand, err = exec.LookPath(runtimeCommand)
if err != nil {
return Runtime{}, err
}
r.BundleDir = bundleDir
return r, err
} | go | {
"resource": ""
} |
q14518 | SetConfig | train | func (r *Runtime) SetConfig(g *generate.Generator) error {
if g == nil {
return errors.New("cannot set a nil config")
}
return g.SaveToFile(filepath.Join(r.bundleDir(), "config.json"), generate.ExportOptions{})
} | go | {
"resource": ""
} |
q14519 | ReadStandardStreams | train | func (r *Runtime) ReadStandardStreams() (stdout []byte, stderr []byte, err error) {
_, err = r.stdout.Seek(0, io.SeekStart)
stdout, err2 := ioutil.ReadAll(r.stdout)
if err == nil && err2 != nil {
err = err2
}
_, err = r.stderr.Seek(0, io.SeekStart)
stderr, err2 = ioutil.ReadAll(r.stderr)
if err == nil && err2 ... | go | {
"resource": ""
} |
q14520 | State | train | func (r *Runtime) State() (rspecs.State, error) {
var args []string
args = append(args, "state")
if r.ID != "" {
args = append(args, r.ID)
}
out, err := exec.Command(r.RuntimeCommand, args...).Output()
if err != nil {
if e, ok := err.(*exec.ExitError); ok {
if len(e.Stderr) == 0 {
e.Stderr = out
r... | go | {
"resource": ""
} |
q14521 | Kill | train | func (r *Runtime) Kill(sig string) (err error) {
var args []string
args = append(args, "kill")
if r.ID != "" {
args = append(args, r.ID)
}
if sig != "" {
// TODO: runc does not support this
// args = append(args, "--signal", sig)
args = append(args, sig)
} else {
args = append(args, DefaultSignal)
}
... | go | {
"resource": ""
} |
q14522 | Delete | train | func (r *Runtime) Delete() (err error) {
var args []string
args = append(args, "delete")
if r.ID != "" {
args = append(args, r.ID)
}
cmd := exec.Command(r.RuntimeCommand, args...)
return execWithStderrFallbackToStdout(cmd)
} | go | {
"resource": ""
} |
q14523 | Clean | train | func (r *Runtime) Clean(removeBundle bool, forceRemoveBundle bool) error {
r.Kill("KILL")
WaitingForStatus(*r, LifecycleStatusStopped, time.Second*10, time.Second/10)
err := r.Delete()
if removeBundle && (err == nil || forceRemoveBundle) {
err2 := os.RemoveAll(r.bundleDir())
if err2 != nil && err == nil {
... | go | {
"resource": ""
} |
q14524 | NewRFCErrorOrPanic | train | func NewRFCErrorOrPanic(code Code, err error, version string) *rfc2119.Error {
rfcError, err2 := NewRFCError(code, err, version)
if err2 != nil {
panic(err2.Error())
}
return rfcError
} | go | {
"resource": ""
} |
q14525 | SplitLevel | train | func SplitLevel(errIn error, level rfc2119.Level) (levelErrors LevelErrors, errOut error) {
merr, ok := errIn.(*multierror.Error)
if !ok {
return levelErrors, errIn
}
for _, err := range merr.Errors {
e, ok := err.(*Error)
if ok && e.Err.Level < level {
fmt.Println(e)
levelErrors.Warnings = append(level... | go | {
"resource": ""
} |
q14526 | ParseSyscallFlag | train | func ParseSyscallFlag(args SyscallOpts, config *rspec.LinuxSeccomp) error {
var arguments []string
if args.Index != "" && args.Value != "" && args.ValueTwo != "" && args.Operator != "" {
arguments = []string{args.Action, args.Syscall, args.Index, args.Value,
args.ValueTwo, args.Operator}
} else {
arguments = ... | go | {
"resource": ""
} |
q14527 | ParseDefaultAction | train | func ParseDefaultAction(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
err = RemoveAllMatchingRules(config, defaultAction)
if err != nil {
return err
}
return n... | go | {
"resource": ""
} |
q14528 | ParseDefaultActionForce | train | func ParseDefaultActionForce(action string, config *rspec.LinuxSeccomp) error {
if action == "" {
return nil
}
defaultAction, err := parseAction(action)
if err != nil {
return err
}
config.DefaultAction = defaultAction
return nil
} | go | {
"resource": ""
} |
q14529 | NewValidator | train | func NewValidator(spec *rspec.Spec, bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if hostSpecific && platform != runtime.GOOS {
return Validator{}, fmt.Errorf("When hostSpecific is set, platform must be same as the host platform")
}
return Validator{
spec: spec,
bundlePath... | go | {
"resource": ""
} |
q14530 | NewValidatorFromPath | train | func NewValidatorFromPath(bundlePath string, hostSpecific bool, platform string) (Validator, error) {
if bundlePath == "" {
return Validator{}, fmt.Errorf("bundle path shouldn't be empty")
}
if _, err := os.Stat(bundlePath); err != nil {
return Validator{}, err
}
configPath := filepath.Join(bundlePath, specC... | go | {
"resource": ""
} |
q14531 | CheckAll | train | func (v *Validator) CheckAll() error {
var errs *multierror.Error
errs = multierror.Append(errs, v.CheckJSONSchema())
errs = multierror.Append(errs, v.CheckPlatform())
errs = multierror.Append(errs, v.CheckRoot())
errs = multierror.Append(errs, v.CheckMandatoryFields())
errs = multierror.Append(errs, v.CheckSemVe... | go | {
"resource": ""
} |
q14532 | JSONSchemaURL | train | func JSONSchemaURL(version string) (url string, err error) {
ver, err := semver.Parse(version)
if err != nil {
return "", specerror.NewError(specerror.SpecVersionInSemVer, err, rspec.Version)
}
configRenamedToConfigSchemaVersion, err := semver.Parse("1.0.0-rc2") // config.json became config-schema.json in 1.0.0-r... | go | {
"resource": ""
} |
q14533 | CheckJSONSchema | train | func (v *Validator) CheckJSONSchema() (errs error) {
logrus.Debugf("check JSON schema")
url, err := JSONSchemaURL(v.spec.Version)
if err != nil {
errs = multierror.Append(errs, err)
return errs
}
schemaLoader := gojsonschema.NewReferenceLoader(url)
documentLoader := gojsonschema.NewGoLoader(v.spec)
result,... | go | {
"resource": ""
} |
q14534 | CheckSemVer | train | func (v *Validator) CheckSemVer() (errs error) {
logrus.Debugf("check semver")
version := v.spec.Version
_, err := semver.Parse(version)
if err != nil {
errs = multierror.Append(errs,
specerror.NewError(specerror.SpecVersionInSemVer, fmt.Errorf("%q is not valid SemVer: %s", version, err.Error()), rspec.Versio... | go | {
"resource": ""
} |
q14535 | CheckHooks | train | func (v *Validator) CheckHooks() (errs error) {
logrus.Debugf("check hooks")
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support hooks", v.platform))
return
}
if v.spec.Hooks != nil {
errs = multierror... | go | {
"resource": ""
} |
q14536 | CheckProcess | train | func (v *Validator) CheckProcess() (errs error) {
logrus.Debugf("check process")
if v.spec.Process == nil {
return
}
process := v.spec.Process
if !osFilepath.IsAbs(v.platform, process.Cwd) {
errs = multierror.Append(errs,
specerror.NewError(
specerror.ProcCwdAbs,
fmt.Errorf("cwd %q is not an absol... | go | {
"resource": ""
} |
q14537 | CheckCapabilities | train | func (v *Validator) CheckCapabilities() (errs error) {
if v.platform != "linux" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.capabilities", v.platform))
return
}
process := v.spec.Process
var effective, permitted, inheritable, ambient bool
... | go | {
"resource": ""
} |
q14538 | CheckRlimits | train | func (v *Validator) CheckRlimits() (errs error) {
if v.platform != "linux" && v.platform != "solaris" {
errs = multierror.Append(errs, fmt.Errorf("For %q platform, the configuration structure does not support process.rlimits", v.platform))
return
}
process := v.spec.Process
for index, rlimit := range process.R... | go | {
"resource": ""
} |
q14539 | CheckMounts | train | func (v *Validator) CheckMounts() (errs error) {
logrus.Debugf("check mounts")
supportedTypes, err := supportedMountTypes(v.platform, v.HostSpecific)
if err != nil {
errs = multierror.Append(errs, err)
return
}
for i, mountA := range v.spec.Mounts {
if supportedTypes != nil && !supportedTypes[mountA.Type] ... | go | {
"resource": ""
} |
q14540 | CheckPlatform | train | func (v *Validator) CheckPlatform() (errs error) {
logrus.Debugf("check platform")
if v.platform != "linux" && v.platform != "solaris" && v.platform != "windows" {
errs = multierror.Append(errs, fmt.Errorf("platform %q is not supported", v.platform))
return
}
if v.HostSpecific && v.platform != runtime.GOOS {
... | go | {
"resource": ""
} |
q14541 | CheckLinuxResources | train | func (v *Validator) CheckLinuxResources() (errs error) {
logrus.Debugf("check linux resources")
r := v.spec.Linux.Resources
if r.Memory != nil {
if r.Memory.Limit != nil && r.Memory.Swap != nil && uint64(*r.Memory.Limit) > uint64(*r.Memory.Swap) {
errs = multierror.Append(errs, fmt.Errorf("minimum memoryswap s... | go | {
"resource": ""
} |
q14542 | CheckAnnotations | train | func (v *Validator) CheckAnnotations() (errs error) {
logrus.Debugf("check annotations")
reversedDomain := regexp.MustCompile(`^[A-Za-z]{2,6}(\.[A-Za-z0-9-]{1,63})+$`)
for key := range v.spec.Annotations {
if strings.HasPrefix(key, "org.opencontainers") {
errs = multierror.Append(errs,
specerror.NewError(
... | go | {
"resource": ""
} |
q14543 | CapValid | train | func CapValid(c string, hostSpecific bool) error {
isValid := false
if !strings.HasPrefix(c, "CAP_") {
return fmt.Errorf("capability %s must start with CAP_", c)
}
for _, cap := range capability.List() {
if c == fmt.Sprintf("CAP_%s", strings.ToUpper(cap.String())) {
if hostSpecific && cap > LastCap() {
... | go | {
"resource": ""
} |
q14544 | CheckMandatoryFields | train | func (v *Validator) CheckMandatoryFields() error {
logrus.Debugf("check mandatory fields")
if v.spec == nil {
return fmt.Errorf("Spec can't be nil")
}
return checkMandatory(v.spec)
} | go | {
"resource": ""
} |
q14545 | ValidateLinuxResourcesPids | train | func ValidateLinuxResourcesPids(config *rspec.Spec, t *tap.T, state *rspec.State) error {
cg, err := cgroups.FindCgroup()
t.Ok((err == nil), "find pids cgroup")
if err != nil {
t.Diagnostic(err.Error())
return nil
}
lpd, err := cg.GetPidsData(state.Pid, config.Linux.CgroupsPath)
t.Ok((err == nil), "get pids ... | go | {
"resource": ""
} |
q14546 | removeAdapter | train | func removeAdapter(dialect string) {
if HasAdapter(dialect) {
dialect = strings.ToLower(dialect)
delete(ds_adapters, dialect)
}
} | go | {
"resource": ""
} |
q14547 | Literal | train | func (me *DefaultAdapter) Literal(buf *SqlBuilder, val interface{}) error {
return me.dataset.Literal(buf, val)
} | go | {
"resource": ""
} |
q14548 | UpdateBeginSql | train | func (me *DefaultAdapter) UpdateBeginSql(buf *SqlBuilder) error {
buf.Write(me.UpdateClause)
return nil
} | go | {
"resource": ""
} |
q14549 | InsertBeginSql | train | func (me *DefaultAdapter) InsertBeginSql(buf *SqlBuilder, o ConflictExpression) error {
if me.SupportsInsertIgnoreSyntax() && o != nil {
buf.Write(me.InsertIgnoreClause)
} else {
buf.Write(me.InsertClause)
}
return nil
} | go | {
"resource": ""
} |
q14550 | DeleteBeginSql | train | func (me *DefaultAdapter) DeleteBeginSql(buf *SqlBuilder) error {
buf.Write(me.DeleteClause)
return nil
} | go | {
"resource": ""
} |
q14551 | TruncateSql | train | func (me *DefaultAdapter) TruncateSql(buf *SqlBuilder, from ColumnList, opts TruncateOptions) error {
buf.Write(me.TruncateClause)
if err := me.SourcesSql(buf, from); err != nil {
return err
}
if opts.Identity != empty_string {
buf.WriteRune(space_rune)
buf.WriteString(strings.ToUpper(opts.Identity))
buf.Wr... | go | {
"resource": ""
} |
q14552 | InsertColumnsSql | train | func (me *DefaultAdapter) InsertColumnsSql(buf *SqlBuilder, cols ColumnList) error {
buf.WriteRune(space_rune)
buf.WriteRune(left_paren_rune)
if err := me.Literal(buf, cols); err != nil {
return err
}
buf.WriteRune(right_paren_rune)
return nil
} | go | {
"resource": ""
} |
q14553 | InsertValuesSql | train | func (me *DefaultAdapter) InsertValuesSql(buf *SqlBuilder, values [][]interface{}) error {
buf.Write(me.ValuesFragment)
rowLen := len(values[0])
valueLen := len(values)
for i, row := range values {
if len(row) != rowLen {
return fmt.Errorf("Rows with different value length expected %d got %d", rowLen, len(row)... | go | {
"resource": ""
} |
q14554 | SelectSql | train | func (me *DefaultAdapter) SelectSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.WriteRune(space_rune)
if len(cols.Columns()) == 0 {
buf.WriteRune(star_rune)
} else {
return me.Literal(buf, cols)
}
return nil
} | go | {
"resource": ""
} |
q14555 | SelectDistinctSql | train | func (me *DefaultAdapter) SelectDistinctSql(buf *SqlBuilder, cols ColumnList) error {
buf.Write(me.SelectClause)
buf.Write(me.DistinctFragment)
return me.Literal(buf, cols)
} | go | {
"resource": ""
} |
q14556 | FromSql | train | func (me *DefaultAdapter) FromSql(buf *SqlBuilder, from ColumnList) error {
if from != nil && len(from.Columns()) > 0 {
buf.Write(me.FromFragment)
return me.SourcesSql(buf, from)
}
return nil
} | go | {
"resource": ""
} |
q14557 | SourcesSql | train | func (me *DefaultAdapter) SourcesSql(buf *SqlBuilder, from ColumnList) error {
buf.WriteRune(space_rune)
return me.Literal(buf, from)
} | go | {
"resource": ""
} |
q14558 | JoinSql | train | func (me *DefaultAdapter) JoinSql(buf *SqlBuilder, joins JoiningClauses) error {
if len(joins) > 0 {
for _, j := range joins {
joinType := me.JoinTypeLookup[j.JoinType]
buf.Write(joinType)
if err := me.Literal(buf, j.Table); err != nil {
return err
}
if j.IsConditioned {
buf.WriteRune(space_ru... | go | {
"resource": ""
} |
q14559 | WhereSql | train | func (me *DefaultAdapter) WhereSql(buf *SqlBuilder, where ExpressionList) error {
if where != nil && len(where.Expressions()) > 0 {
buf.Write(me.WhereFragment)
return me.Literal(buf, where)
}
return nil
} | go | {
"resource": ""
} |
q14560 | GroupBySql | train | func (me *DefaultAdapter) GroupBySql(buf *SqlBuilder, groupBy ColumnList) error {
if groupBy != nil && len(groupBy.Columns()) > 0 {
buf.Write(me.GroupByFragment)
return me.Literal(buf, groupBy)
}
return nil
} | go | {
"resource": ""
} |
q14561 | HavingSql | train | func (me *DefaultAdapter) HavingSql(buf *SqlBuilder, having ExpressionList) error {
if having != nil && len(having.Expressions()) > 0 {
buf.Write(me.HavingFragment)
return me.Literal(buf, having)
}
return nil
} | go | {
"resource": ""
} |
q14562 | OrderSql | train | func (me *DefaultAdapter) OrderSql(buf *SqlBuilder, order ColumnList) error {
if order != nil && len(order.Columns()) > 0 {
buf.Write(me.OrderByFragment)
return me.Literal(buf, order)
}
return nil
} | go | {
"resource": ""
} |
q14563 | LimitSql | train | func (me *DefaultAdapter) LimitSql(buf *SqlBuilder, limit interface{}) error {
if limit != nil {
buf.Write(me.LimitFragment)
return me.Literal(buf, limit)
}
return nil
} | go | {
"resource": ""
} |
q14564 | OffsetSql | train | func (me *DefaultAdapter) OffsetSql(buf *SqlBuilder, offset uint) error {
if offset > 0 {
buf.Write(me.OffsetFragment)
return me.Literal(buf, offset)
}
return nil
} | go | {
"resource": ""
} |
q14565 | DatasetSql | train | func (me *DefaultAdapter) DatasetSql(buf *SqlBuilder, dataset Dataset) error {
buf.WriteRune(left_paren_rune)
if buf.IsPrepared {
if err := dataset.selectSqlWriteTo(buf); err != nil {
return err
}
} else {
sql, _, err := dataset.Prepared(false).ToSql()
if err != nil {
return err
}
buf.WriteString(s... | go | {
"resource": ""
} |
q14566 | LiteralNil | train | func (me *DefaultAdapter) LiteralNil(buf *SqlBuilder) error {
buf.Write(me.Null)
return nil
} | go | {
"resource": ""
} |
q14567 | LiteralTime | train | func (me *DefaultAdapter) LiteralTime(buf *SqlBuilder, t time.Time) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, t)
}
return me.Literal(buf, t.UTC().Format(me.TimeFormat))
} | go | {
"resource": ""
} |
q14568 | LiteralFloat | train | func (me *DefaultAdapter) LiteralFloat(buf *SqlBuilder, f float64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, f)
}
buf.WriteString(strconv.FormatFloat(f, 'f', -1, 64))
return nil
} | go | {
"resource": ""
} |
q14569 | LiteralInt | train | func (me *DefaultAdapter) LiteralInt(buf *SqlBuilder, i int64) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, i)
}
buf.WriteString(strconv.FormatInt(i, 10))
return nil
} | go | {
"resource": ""
} |
q14570 | LiteralString | train | func (me *DefaultAdapter) LiteralString(buf *SqlBuilder, s string) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, s)
}
buf.WriteRune(me.StringQuote)
for _, char := range s {
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
}
}
buf.WriteRune(me.StringQuote... | go | {
"resource": ""
} |
q14571 | LiteralBytes | train | func (me *DefaultAdapter) LiteralBytes(buf *SqlBuilder, bs []byte) error {
if buf.IsPrepared {
return me.PlaceHolderSql(buf, bs)
}
buf.WriteRune(me.StringQuote)
i := 0
for len(bs) > 0 {
char, l := utf8.DecodeRune(bs)
if e, ok := me.EscapedRunes[char]; ok {
buf.Write(e)
} else {
buf.WriteRune(char)
... | go | {
"resource": ""
} |
q14572 | ColumnListSql | train | func (me *DefaultAdapter) ColumnListSql(buf *SqlBuilder, columnList ColumnList) error {
cols := columnList.Columns()
colLen := len(cols)
for i, col := range cols {
if err := me.Literal(buf, col); err != nil {
return err
}
if i < colLen-1 {
buf.WriteRune(comma_rune)
buf.WriteRune(space_rune)
}
}
re... | go | {
"resource": ""
} |
q14573 | UpdateExpressionSql | train | func (me *DefaultAdapter) UpdateExpressionSql(buf *SqlBuilder, update UpdateExpression) error {
if err := me.Literal(buf, update.Col()); err != nil {
return err
}
buf.WriteRune(me.SetOperatorRune)
return me.Literal(buf, update.Val())
} | go | {
"resource": ""
} |
q14574 | CommonTableExpressionSql | train | func (me *DefaultAdapter) CommonTableExpressionSql(buf *SqlBuilder, cte CommonTableExpression) error {
if err := me.Literal(buf, cte.Name()); err != nil {
return err
}
buf.Write(me.AsFragment)
if err := me.Literal(buf, cte.SubQuery()); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q14575 | CompoundExpressionSql | train | func (me *DefaultAdapter) CompoundExpressionSql(buf *SqlBuilder, compound CompoundExpression) error {
switch compound.Type() {
case UNION:
buf.Write(me.UnionFragment)
case UNION_ALL:
buf.Write(me.UnionAllFragment)
case INTERSECT:
buf.Write(me.IntersectFragment)
case INTERSECT_ALL:
buf.Write(me.IntersectAll... | go | {
"resource": ""
} |
q14576 | withDatabase | train | func withDatabase(db database) *Dataset {
ret := new(Dataset)
ret.database = db
ret.clauses = clauses{
Select: cols(Star()),
}
ret.adapter = db.queryAdapter(ret)
return ret
} | go | {
"resource": ""
} |
q14577 | SetAdapter | train | func (me *Dataset) SetAdapter(adapter Adapter) *Dataset {
me.adapter = adapter
return me
} | go | {
"resource": ""
} |
q14578 | hasSources | train | func (me *Dataset) hasSources() bool {
return me.clauses.From != nil && len(me.clauses.From.Columns()) > 0
} | go | {
"resource": ""
} |
q14579 | WriteArg | train | func (me *SqlBuilder) WriteArg(i interface{}) {
me.CurrentArgPosition++
me.args = append(me.args, i)
} | go | {
"resource": ""
} |
q14580 | Begin | train | func (me *Database) Begin() (*TxDatabase, error) {
tx, err := me.Db.Begin()
if err != nil {
return nil, err
}
return &TxDatabase{Dialect: me.Dialect, Tx: tx, logger: me.logger}, nil
} | go | {
"resource": ""
} |
q14581 | queryAdapter | train | func (me *Database) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
} | go | {
"resource": ""
} |
q14582 | Trace | train | func (me *Database) Trace(op, sql string, args ...interface{}) {
if me.logger != nil {
if sql != "" {
if len(args) != 0 {
me.logger.Printf("[goqu] %s [query:=`%s` args:=%+v]", op, sql, args)
} else {
me.logger.Printf("[goqu] %s [query:=`%s`]", op, sql)
}
} else {
me.logger.Printf("[goqu] %s", o... | go | {
"resource": ""
} |
q14583 | queryAdapter | train | func (me *TxDatabase) queryAdapter(dataset *Dataset) Adapter {
return NewAdapter(me.Dialect, dataset)
} | go | {
"resource": ""
} |
q14584 | getInsertColsAndVals | train | func (me *Dataset) getInsertColsAndVals(rows ...interface{}) (columns ColumnList, vals [][]interface{}, err error) {
var mapKeys valueSlice
rowValue := reflect.Indirect(reflect.ValueOf(rows[0]))
rowType := rowValue.Type()
rowKind := rowValue.Kind()
vals = make([][]interface{}, len(rows))
for i, row := range rows ... | go | {
"resource": ""
} |
q14585 | insertSql | train | func (me *Dataset) insertSql(cols ColumnList, values [][]interface{}, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf,... | go | {
"resource": ""
} |
q14586 | insertFromSql | train | func (me *Dataset) insertFromSql(other Dataset, prepared bool, c ConflictExpression) (string, []interface{}, error) {
buf := NewSqlBuilder(prepared)
if err := me.adapter.CommonTablesSql(buf, me.clauses.CommonTables); err != nil {
return "", nil, err
}
if err := me.adapter.InsertBeginSql(buf, nil); err != nil {
... | go | {
"resource": ""
} |
q14587 | eq | train | func eq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, false)
} | go | {
"resource": ""
} |
q14588 | neq | train | func neq(lhs Expression, rhs interface{}) BooleanExpression {
return checkBoolExpType(EQ_OP, lhs, rhs, true)
} | go | {
"resource": ""
} |
q14589 | gt | train | func gt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GT_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14590 | gte | train | func gte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: GTE_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14591 | lt | train | func lt(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LT_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14592 | lte | train | func lte(lhs Expression, rhs interface{}) BooleanExpression {
return boolean{op: LTE_OP, lhs: lhs, rhs: rhs}
} | go | {
"resource": ""
} |
q14593 | in | train | func in(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: IN_OP, lhs: lhs, rhs: vals}
} | go | {
"resource": ""
} |
q14594 | notIn | train | func notIn(lhs Expression, vals ...interface{}) BooleanExpression {
if len(vals) == 1 && reflect.Indirect(reflect.ValueOf(vals[0])).Kind() == reflect.Slice {
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals[0]}
}
return boolean{op: NOT_IN_OP, lhs: lhs, rhs: vals}
} | go | {
"resource": ""
} |
q14595 | is | train | func is(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, false)
} | go | {
"resource": ""
} |
q14596 | isNot | train | func isNot(lhs Expression, val interface{}) BooleanExpression {
return checkBoolExpType(IS_OP, lhs, val, true)
} | go | {
"resource": ""
} |
q14597 | like | train | func like(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, false)
} | go | {
"resource": ""
} |
q14598 | iLike | train | func iLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(I_LIKE_OP, lhs, val, false)
} | go | {
"resource": ""
} |
q14599 | notLike | train | func notLike(lhs Expression, val interface{}) BooleanExpression {
return checkLikeExp(LIKE_OP, lhs, val, true)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.