_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172100 | pull | validation | func (r *Repo) pull() error {
// if not pulled, perform clone
if !r.pulled {
return r.clone()
}
// if latest tag config is set
if r.Branch == latestTag {
return r.checkoutLatestTag()
}
params := append([]string{"pull"}, append(r.PullArgs, "origin", r.Branch)...)
var err error
if err = r.gitCmd(params, r... | go | {
"resource": ""
} |
q172101 | checkoutCommit | validation | func (r *Repo) checkoutCommit(commitHash string) error {
var err error
params := []string{"checkout", commitHash}
if err = r.gitCmd(params, r.Path); err == nil {
Logger().Printf("Commit %v checkout done.\n", commitHash)
}
return err
} | go | {
"resource": ""
} |
q172102 | gitCmd | validation | func (r *Repo) gitCmd(params []string, dir string) error {
// if key is specified, use ssh key
if r.KeyPath != "" {
return r.gitCmdWithKey(params, dir)
}
return runCmd(gitBinary, params, dir)
} | go | {
"resource": ""
} |
q172103 | Prepare | validation | func (r *Repo) Prepare() error {
// check if directory exists or is empty
// if not, create directory
fs, err := gos.ReadDir(r.Path)
if err != nil || len(fs) == 0 {
return gos.MkdirAll(r.Path, os.FileMode(0755))
}
// validate git repo
isGit := false
for _, f := range fs {
if f.IsDir() && f.Name() == ".git"... | go | {
"resource": ""
} |
q172104 | mostRecentCommit | validation | func (r *Repo) mostRecentCommit() (string, error) {
command := gitBinary + ` --no-pager log -n 1 --pretty=format:"%H"`
c, args, err := caddy.SplitCommandAndArgs(command)
if err != nil {
return "", err
}
return runCmdOutput(c, args, r.Path)
} | go | {
"resource": ""
} |
q172105 | originURL | validation | func (r *Repo) originURL() (string, error) {
_, err := gos.Stat(r.Path)
if err != nil {
return "", err
}
args := []string{"config", "--get", "remote.origin.url"}
return runCmdOutput(gitBinary, args, r.Path)
} | go | {
"resource": ""
} |
q172106 | execThen | validation | func (r *Repo) execThen() error {
var errs error
for _, command := range r.Then {
err := command.Exec(r.Path)
if err == nil {
Logger().Printf("Command '%v' successful.\n", command.Command())
}
errs = mergeErrors(errs, err)
}
return errs
} | go | {
"resource": ""
} |
q172107 | Stdin | validation | func (g *gitCmd) Stdin(stdin io.Reader) {
g.Cmd.Stdin = stdin
} | go | {
"resource": ""
} |
q172108 | Stdout | validation | func (g *gitCmd) Stdout(stdout io.Writer) {
g.Cmd.Stdout = stdout
} | go | {
"resource": ""
} |
q172109 | Stderr | validation | func (g *gitCmd) Stderr(stderr io.Writer) {
g.Cmd.Stderr = stderr
} | go | {
"resource": ""
} |
q172110 | Mkdir | validation | func (g GitOS) Mkdir(name string, perm os.FileMode) error {
return os.Mkdir(name, perm)
} | go | {
"resource": ""
} |
q172111 | MkdirAll | validation | func (g GitOS) MkdirAll(path string, perm os.FileMode) error {
return os.MkdirAll(path, perm)
} | go | {
"resource": ""
} |
q172112 | Stat | validation | func (g GitOS) Stat(name string) (os.FileInfo, error) {
return os.Stat(name)
} | go | {
"resource": ""
} |
q172113 | LookPath | validation | func (g GitOS) LookPath(file string) (string, error) {
return exec.LookPath(file)
} | go | {
"resource": ""
} |
q172114 | TempFile | validation | func (g GitOS) TempFile(dir, prefix string) (File, error) {
return ioutil.TempFile(dir, prefix)
} | go | {
"resource": ""
} |
q172115 | ReadDir | validation | func (g GitOS) ReadDir(dirname string) ([]os.FileInfo, error) {
return ioutil.ReadDir(dirname)
} | go | {
"resource": ""
} |
q172116 | Command | validation | func (g GitOS) Command(name string, args ...string) Cmd {
return &gitCmd{exec.Command(name, args...)}
} | go | {
"resource": ""
} |
q172117 | NewTicker | validation | func (g GitOS) NewTicker(d time.Duration) Ticker {
return &GitTicker{time.NewTicker(d)}
} | go | {
"resource": ""
} |
q172118 | TimeSince | validation | func (g GitOS) TimeSince(t time.Time) time.Duration {
return time.Since(t)
} | go | {
"resource": ""
} |
q172119 | handleSignature | validation | func (t TravisHook) handleSignature(r *http.Request, secret string) error {
signature := r.Header.Get("Authorization")
if signature == "" {
return errors.New("request sent no authorization signature")
}
if secret == "" {
Logger().Print("Unable to verify request signature. Secret not set in caddyfile!\n")
retu... | go | {
"resource": ""
} |
q172120 | Error | validation | func (h hookIgnoredError) Error() string {
return fmt.Sprintf("%s webhook ignored. Error: %v", h.hookType, h.err)
} | go | {
"resource": ""
} |
q172121 | hookName | validation | func hookName(h hookHandler) string {
for name, handler := range handlers {
if handler == h {
return name
}
}
return ""
} | go | {
"resource": ""
} |
q172122 | ServeHTTP | validation | func (h WebHook) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
for _, repo := range h.Repos {
if r.URL.Path == repo.Hook.URL {
// if handler type is specified.
if handler, ok := handlers[repo.Hook.Type]; ok {
if !handler.DoesHandle(r.Header) {
return http.StatusBadRequest, errors... | go | {
"resource": ""
} |
q172123 | hostname | validation | func hostname(hostport string) string {
colon := strings.IndexByte(hostport, ':')
if colon == -1 {
return hostport
}
if i := strings.IndexByte(hostport, ']'); i != -1 {
return strings.TrimPrefix(hostport[:i], "[")
}
return hostport[:colon]
} | go | {
"resource": ""
} |
q172124 | genOptionsODBC | validation | func genOptionsODBC(q url.Values, skipWhenEmpty bool, ignore ...string) string {
return genOptions(q, "", "=", ";", ",", skipWhenEmpty, ignore...)
} | go | {
"resource": ""
} |
q172125 | genQueryOptions | validation | func genQueryOptions(q url.Values) string {
if s := q.Encode(); s != "" {
return "?" + s
}
return ""
} | go | {
"resource": ""
} |
q172126 | convertOptions | validation | func convertOptions(q url.Values, pairs ...string) url.Values {
n := make(url.Values)
for k, v := range q {
x := make([]string, len(v))
for i, z := range v {
for j := 0; j < len(pairs); j += 2 {
if pairs[j] == z {
z = pairs[j+1]
}
}
x[i] = z
}
n[k] = x
}
return n
} | go | {
"resource": ""
} |
q172127 | mode | validation | func mode(path string) os.FileMode {
if fi, err := os.Stat(path); err == nil {
return fi.Mode()
}
return 0
} | go | {
"resource": ""
} |
q172128 | registerAlias | validation | func registerAlias(name, alias string, doSort bool) {
scheme, ok := schemeMap[name]
if !ok {
panic(fmt.Sprintf("scheme %s not registered", name))
}
if doSort && has(scheme.Aliases, alias) {
panic(fmt.Sprintf("scheme %s already has alias %s", name, alias))
}
if _, ok := schemeMap[alias]; ok {
panic(fmt.Spr... | go | {
"resource": ""
} |
q172129 | Register | validation | func Register(scheme Scheme) {
if scheme.Generator == nil {
panic("must specify Generator when registering Scheme")
}
if scheme.Opaque && scheme.Proto&ProtoUnix != 0 {
panic("scheme must support only Opaque or Unix protocols, not both")
}
// register
if _, ok := schemeMap[scheme.Driver]; ok {
panic(fmt.Sp... | go | {
"resource": ""
} |
q172130 | Unregister | validation | func Unregister(name string) *Scheme {
scheme, ok := schemeMap[name]
if ok {
for _, alias := range scheme.Aliases {
delete(schemeMap, alias)
}
delete(schemeMap, name)
return scheme
}
return nil
} | go | {
"resource": ""
} |
q172131 | has | validation | func has(a []string, b string) bool {
for _, s := range a {
if s == b {
return true
}
}
return false
} | go | {
"resource": ""
} |
q172132 | SchemeDriverAndAliases | validation | func SchemeDriverAndAliases(name string) (string, []string) {
if scheme, ok := schemeMap[name]; ok {
driver := scheme.Driver
if scheme.Override != "" {
driver = scheme.Override
}
var aliases []string
for _, alias := range scheme.Aliases {
if alias == driver {
continue
}
aliases = append(alia... | go | {
"resource": ""
} |
q172133 | GenFromURL | validation | func GenFromURL(urlstr string) func(*URL) (string, error) {
z, err := url.Parse(urlstr)
if err != nil {
panic(err)
}
return func(u *URL) (string, error) {
opaque := z.Opaque
if u.Opaque != "" {
opaque = u.Opaque
}
user := z.User
if u.User != nil {
user = u.User
}
host, port := hostname(z.Ho... | go | {
"resource": ""
} |
q172134 | GenOpaque | validation | func GenOpaque(u *URL) (string, error) {
if u.Opaque == "" {
return "", ErrMissingPath
}
return u.Opaque + genQueryOptions(u.Query()), nil
} | go | {
"resource": ""
} |
q172135 | GenPostgres | validation | func GenPostgres(u *URL) (string, error) {
host, port, dbname := hostname(u.Host), hostport(u.Host), strings.TrimPrefix(u.Path, "/")
if host == "." {
return "", ErrRelativePathNotSupported
}
// resolve path
if u.Proto == "unix" {
if host == "" {
dbname = "/" + dbname
}
host, port, dbname = resolveDir(... | go | {
"resource": ""
} |
q172136 | GenSQLServer | validation | func GenSQLServer(u *URL) (string, error) {
host, port, dbname := hostname(u.Host), hostport(u.Host), strings.TrimPrefix(u.Path, "/")
// add instance name to host if present
if i := strings.Index(dbname, "/"); i != -1 {
host = host + `\` + dbname[:i]
dbname = dbname[i+1:]
}
q := u.Query()
q.Set("Server", ho... | go | {
"resource": ""
} |
q172137 | GenMyMySQL | validation | func GenMyMySQL(u *URL) (string, error) {
host, port, dbname := hostname(u.Host), hostport(u.Host), strings.TrimPrefix(u.Path, "/")
// resolve path
if u.Proto == "unix" {
if host == "" {
dbname = "/" + dbname
}
host, dbname = resolveSocket(stdpath.Join(host, dbname))
port = ""
}
// save host, port, db... | go | {
"resource": ""
} |
q172138 | GenOracle | validation | func GenOracle(u *URL) (string, error) {
// create dsn
dsn := u.Host + u.Path
// build user/pass
var un string
if u.User != nil {
if un = u.User.Username(); len(un) > 0 {
if up, ok := u.User.Password(); ok {
un += "/" + up
}
}
}
return un + "@" + dsn, nil
} | go | {
"resource": ""
} |
q172139 | GenFirebird | validation | func GenFirebird(u *URL) (string, error) {
z := &url.URL{
User: u.User,
Host: u.Host,
Path: u.Path,
RawPath: u.RawPath,
RawQuery: u.RawQuery,
Fragment: u.Fragment,
}
return strings.TrimPrefix(z.String(), "//"), nil
} | go | {
"resource": ""
} |
q172140 | GenADODB | validation | func GenADODB(u *URL) (string, error) {
// grab data source
host, port := hostname(u.Host), hostport(u.Host)
dsname, dbname := strings.TrimPrefix(u.Path, "/"), ""
if dsname == "" {
dsname = "."
}
// check if data source is not a path on disk
if mode(dsname) == 0 {
if i := strings.IndexAny(dsname, `\/`); i !... | go | {
"resource": ""
} |
q172141 | GenODBC | validation | func GenODBC(u *URL) (string, error) {
q := u.Query()
host, port, dbname := hostname(u.Host), hostport(u.Host), strings.TrimPrefix(u.Path, "/")
// save host, port, dbname
if u.hostPortDB == nil {
u.hostPortDB = []string{host, port, dbname}
}
q.Set("Driver", "{"+strings.Replace(u.Proto, "+", " ", -1)+"}")
q.... | go | {
"resource": ""
} |
q172142 | GenOLEODBC | validation | func GenOLEODBC(u *URL) (string, error) {
props, err := GenODBC(u)
if err != nil {
return "", nil
}
return `Provider=MSDASQL.1;Extended Properties="` + props + `"`, nil
} | go | {
"resource": ""
} |
q172143 | GenClickhouse | validation | func GenClickhouse(u *URL) (string, error) {
z := &url.URL{
Scheme: "tcp",
Opaque: u.Opaque,
Host: u.Host,
Path: u.Path,
RawPath: u.RawPath,
RawQuery: u.RawQuery,
Fragment: u.Fragment,
}
if hostport(z.Host) == "" {
z.Host += ":9000"
}
// add parameters
q := z.Query()
if u.User != n... | go | {
"resource": ""
} |
q172144 | GenVoltDB | validation | func GenVoltDB(u *URL) (string, error) {
host, port := "localhost", "21212"
if h := hostname(u.Host); h != "" {
host = h
}
if p := hostport(u.Host); p != "" {
port = p
}
return host + ":" + port, nil
} | go | {
"resource": ""
} |
q172145 | GenPresto | validation | func GenPresto(u *URL) (string, error) {
z := &url.URL{
Scheme: "http",
Opaque: u.Opaque,
User: u.User,
Host: u.Host,
RawQuery: u.RawQuery,
Fragment: u.Fragment,
}
// change to https
if strings.HasSuffix(u.OriginalScheme, "s") {
z.Scheme = "https"
}
// force user
if z.User == nil {
... | go | {
"resource": ""
} |
q172146 | GenCassandra | validation | func GenCassandra(u *URL) (string, error) {
host, port, dbname := "localhost", "9042", strings.TrimPrefix(u.Path, "/")
if h := hostname(u.Host); h != "" {
host = h
}
if p := hostport(u.Host); p != "" {
port = p
}
q := u.Query()
// add user/pass
if u.User != nil {
q.Set("username", u.User.Username())
if ... | go | {
"resource": ""
} |
q172147 | GenSnowflake | validation | func GenSnowflake(u *URL) (string, error) {
host, port, dbname := hostname(u.Host), hostport(u.Host), strings.TrimPrefix(u.Path, "/")
if host == "" {
return "", ErrMissingHost
}
if dbname == "" {
return "", ErrMissingPath
}
if port != "" {
port = ":" + port
}
// add user/pass
var user string
if u.User ... | go | {
"resource": ""
} |
q172148 | String | validation | func (u *URL) String() string {
p := &url.URL{
Scheme: u.OriginalScheme,
Opaque: u.Opaque,
User: u.User,
Host: u.Host,
Path: u.Path,
RawPath: u.RawPath,
RawQuery: u.RawQuery,
Fragment: u.Fragment,
}
return p.String()
} | go | {
"resource": ""
} |
q172149 | Short | validation | func (u *URL) Short() string {
if u.Scheme == "" {
return ""
}
s := schemeMap[u.Scheme].Aliases[0]
if u.Scheme == "odbc" || u.Scheme == "oleodbc" {
n := u.Proto
if v, ok := schemeMap[n]; ok {
n = v.Aliases[0]
}
s += "+" + n
} else if u.Proto != "tcp" {
s += "+" + u.Proto
}
s += ":"
if u.User ... | go | {
"resource": ""
} |
q172150 | Normalize | validation | func (u *URL) Normalize(sep, empty string, cut int) string {
s := make([]string, 5)
s[0] = u.Unaliased
if u.Proto != "tcp" && u.Proto != "unix" {
s[0] += "+" + u.Proto
}
// set host port dbname fields
if u.hostPortDB == nil {
if u.Opaque != "" {
u.hostPortDB = []string{u.Opaque, "", ""}
} else {
u.h... | go | {
"resource": ""
} |
q172151 | NewLimiter | validation | func NewLimiter(
client *redis.Client,
hasher RateHasher,
max int64,
) *RateLimiter {
return &RateLimiter{
redisClient: client,
hasher: hasher,
max: max,
}
} | go | {
"resource": ""
} |
q172152 | Has | validation | func (r *RateLimiter) Has(id string) (bool, error) {
hash := r.hasher.Hash(id)
return r.redisClient.Exists(hash).Result()
} | go | {
"resource": ""
} |
q172153 | Attempted | validation | func (r *RateLimiter) Attempted(id string) (int64, error) {
hash := r.hasher.Hash(id)
val, err := r.redisClient.Get(hash).Result()
if err != nil {
if err == redis.Nil {
// Key does not exist. See: http://redis.io/commands/GET
return 0, nil
}
return 0, err
}
if err != nil {
return 0, err
}
return... | go | {
"resource": ""
} |
q172154 | Left | validation | func (r *RateLimiter) Left(id string) (int64, error) {
// Retrieve attempted count.
attempted, err := r.Attempted(id)
if err != nil {
return 0, err
}
// Left is max minus attempted.
left := r.max - attempted
if left < 0 {
return 0, nil
}
return left, nil
} | go | {
"resource": ""
} |
q172155 | Attempt | validation | func (r *RateLimiter) Attempt(id string) (bool, error) {
// Create hash from id
hash := r.hasher.Hash(id)
// Get value for hash in Redis. If redis.Nil is returned, key does not
// exist.
exists := true
val, err := r.redisClient.Get(hash).Result()
if err != nil {
if err == redis.Nil {
// Key does not exist... | go | {
"resource": ""
} |
q172156 | IsPublicIP | validation | func IsPublicIP(ip net.IP) bool {
if !ip.IsGlobalUnicast() {
return false
}
for _, mask := range privateMasks {
if mask.Contains(ip) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q172157 | ParseForwarded | validation | func ParseForwarded(ipList string) string {
for _, ip := range strings.Split(ipList, ",") {
ip = strings.TrimSpace(ip)
if parsed := net.ParseIP(ip); parsed != nil && IsPublicIP(parsed) {
return ip
}
}
return ""
} | go | {
"resource": ""
} |
q172158 | In | validation | func (f *ParameterField) In() bool {
return f.mode == pmInout || f.mode == pmIn
} | go | {
"resource": ""
} |
q172159 | Out | validation | func (f *ParameterField) Out() bool {
return f.mode == pmInout || f.mode == pmOut
} | go | {
"resource": ""
} |
q172160 | SetLobReader | validation | func (f *ParameterField) SetLobReader(rd io.Reader) error {
f.chunkReader = newLobChunkReader(f.TypeCode().isCharBased(), rd)
return nil
} | go | {
"resource": ""
} |
q172161 | Error | validation | func (e *hdbError) Error() string {
if e.stmtNo != -1 {
return fmt.Sprintf("SQL %s %d - %s (statement no: %d)", e.errorLevel, e.errorCode, e.errorText, e.stmtNo)
}
return fmt.Sprintf("SQL %s %d - %s", e.errorLevel, e.errorCode, e.errorText)
} | go | {
"resource": ""
} |
q172162 | SetIdx | validation | func (e *hdbErrors) SetIdx(idx int) {
switch {
case idx < 0:
e.idx = 0
case idx >= e.numArg:
e.idx = e.numArg - 1
default:
e.idx = idx
}
} | go | {
"resource": ""
} |
q172163 | Code | validation | func (e *hdbErrors) Code() int {
return int(e.errors[e.idx].errorCode)
} | go | {
"resource": ""
} |
q172164 | Position | validation | func (e *hdbErrors) Position() int {
return int(e.errors[e.idx].errorPosition)
} | go | {
"resource": ""
} |
q172165 | Level | validation | func (e *hdbErrors) Level() int {
return int(e.errors[e.idx].errorLevel)
} | go | {
"resource": ""
} |
q172166 | Text | validation | func (e *hdbErrors) Text() string {
return string(e.errors[e.idx].errorText)
} | go | {
"resource": ""
} |
q172167 | IsWarning | validation | func (e *hdbErrors) IsWarning() bool {
return e.errors[e.idx].errorLevel == errorLevelWarning
} | go | {
"resource": ""
} |
q172168 | IsError | validation | func (e *hdbErrors) IsError() bool {
return e.errors[e.idx].errorLevel == errorLevelError
} | go | {
"resource": ""
} |
q172169 | IsFatal | validation | func (e *hdbErrors) IsFatal() bool {
return e.errors[e.idx].errorLevel == errorLevelFatalError
} | go | {
"resource": ""
} |
q172170 | Size | validation | func Size(p []byte) int {
n := 0
for i := 0; i < len(p); {
r, size, _ := decodeRune(p[i:])
i += size
n += RuneLen(r)
}
return n
} | go | {
"resource": ""
} |
q172171 | StringSize | validation | func StringSize(s string) int {
n := 0
for _, r := range s {
n += RuneLen(r)
}
return n
} | go | {
"resource": ""
} |
q172172 | FullRune | validation | func FullRune(p []byte) bool {
high, n, short := decodeRune(p)
if short {
return false
}
if !utf16.IsSurrogate(high) {
return true
}
_, _, short = decodeRune(p[n:])
return !short
} | go | {
"resource": ""
} |
q172173 | DecodeRune | validation | func DecodeRune(p []byte) (rune, int) {
high, n1, _ := decodeRune(p)
if !utf16.IsSurrogate(high) {
return high, n1
}
low, n2, _ := decodeRune(p[n1:])
if low == utf8.RuneError {
return low, n1 + n2
}
return utf16.DecodeRune(high, low), n1 + n2
} | go | {
"resource": ""
} |
q172174 | RuneLen | validation | func RuneLen(r rune) int {
switch {
case r < 0:
return -1
case r <= rune1Max:
return 1
case r <= rune2Max:
return 2
case r <= rune3Max:
return 3
case r <= utf8.MaxRune:
return CESUMax
}
return -1
} | go | {
"resource": ""
} |
q172175 | On | validation | func On() bool {
tracer.mu.RLock()
on := tracer.on
tracer.mu.RUnlock()
return on
} | go | {
"resource": ""
} |
q172176 | SetOn | validation | func SetOn(on bool) {
tracer.mu.Lock()
tracer.on = on
tracer.mu.Unlock()
} | go | {
"resource": ""
} |
q172177 | read | validation | func (h *segmentHeader) read(rd *bufio.Reader) error {
h.segmentLength = rd.ReadInt32()
h.segmentOfs = rd.ReadInt32()
h.noOfParts = rd.ReadInt16()
h.segmentNo = rd.ReadInt16()
h.segmentKind = segmentKind(rd.ReadInt8())
switch h.segmentKind {
default: //error
rd.Skip(11) //segmentHeaderLength
case skRequest... | go | {
"resource": ""
} |
q172178 | Go | validation | func (s *Sniffer) Go() {
defer s.dbConn.Close()
defer s.conn.Close()
req := newInitRequest()
if err := s.streamFragment(dir(true), s.clRd, s.dbWr, req); err != nil {
return
}
rep := newInitReply()
if err := s.streamFragment(dir(false), s.dbRd, s.clWr, rep); err != nil {
return
}
for {
//up stream
if... | go | {
"resource": ""
} |
q172179 | Write | validation | func (c *sessionConn) Write(b []byte) (int, error) {
//set timeout
if err := c.conn.SetWriteDeadline(time.Now().Add(c.timeout)); err != nil {
return 0, err
}
n, err := c.conn.Write(b)
if err != nil {
errLogger.Printf("Connection write error local address %s remote address %s: %s", c.conn.LocalAddr(), c.conn.Re... | go | {
"resource": ""
} |
q172180 | NewSession | validation | func NewSession(ctx context.Context, prm sessionPrm) (*Session, error) {
if trace {
outLogger.Printf("%s", prm)
}
conn, err := newSessionConn(ctx, prm.Host(), prm.Timeout(), prm.TLSConfig())
if err != nil {
return nil, err
}
rd := bufio.NewReader(conn)
wr := bufio.NewWriter(conn)
s := &Session{
prm: ... | go | {
"resource": ""
} |
q172181 | QueryDirect | validation | func (s *Session) QueryDirect(query string) (uint64, *ResultFieldSet, *FieldValues, PartAttributes, error) {
s.mu.Lock()
defer s.mu.Unlock()
if err := s.writeRequest(mtExecuteDirect, false, command(query)); err != nil {
return 0, nil, nil, nil, err
}
var id uint64
var resultFieldSet *ResultFieldSet
fieldValu... | go | {
"resource": ""
} |
q172182 | ExecDirect | validation | func (s *Session) ExecDirect(query string) (driver.Result, error) {
s.mu.Lock()
defer s.mu.Unlock()
if err := s.writeRequest(mtExecuteDirect, !s.conn.inTx, command(query)); err != nil {
return nil, err
}
if err := s.readReply(nil); err != nil {
return nil, err
}
if s.sh.functionCode == fcDDL {
return dr... | go | {
"resource": ""
} |
q172183 | Prepare | validation | func (s *Session) Prepare(query string) (QueryType, uint64, *ParameterFieldSet, *ResultFieldSet, error) {
s.mu.Lock()
defer s.mu.Unlock()
if err := s.writeRequest(mtPrepare, false, command(query)); err != nil {
return QtNone, 0, nil, nil, err
}
var id uint64
var prmFieldSet *ParameterFieldSet
var resultField... | go | {
"resource": ""
} |
q172184 | Exec | validation | func (s *Session) Exec(id uint64, prmFieldSet *ParameterFieldSet, args []driver.NamedValue) (driver.Result, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.statementID.id = &id
if err := s.writeRequest(mtExecute, !s.conn.inTx, s.statementID, newInputParameters(prmFieldSet.inputFields(), args)); err != nil {
return ni... | go | {
"resource": ""
} |
q172185 | DropStatementID | validation | func (s *Session) DropStatementID(id uint64) error {
s.mu.Lock()
defer s.mu.Unlock()
s.statementID.id = &id
if err := s.writeRequest(mtDropStatementID, false, s.statementID); err != nil {
return err
}
if err := s.readReply(nil); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q172186 | Call | validation | func (s *Session) Call(id uint64, prmFieldSet *ParameterFieldSet, args []driver.NamedValue) (*FieldValues, []*TableResult, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.statementID.id = &id
if err := s.writeRequest(mtExecute, false, s.statementID, newInputParameters(prmFieldSet.inputFields(), args)); err != nil {
r... | go | {
"resource": ""
} |
q172187 | Query | validation | func (s *Session) Query(stmtID uint64, prmFieldSet *ParameterFieldSet, resultFieldSet *ResultFieldSet, args []driver.NamedValue) (uint64, *FieldValues, PartAttributes, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.statementID.id = &stmtID
if err := s.writeRequest(mtExecute, false, s.statementID, newInputParameters(pr... | go | {
"resource": ""
} |
q172188 | FetchNext | validation | func (s *Session) FetchNext(id uint64, resultFieldSet *ResultFieldSet, fieldValues *FieldValues) (PartAttributes, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.resultsetID.id = &id
if err := s.writeRequest(mtFetchNext, false, s.resultsetID, fetchsize(s.prm.FetchSize())); err != nil {
return nil, err
}
f := func(... | go | {
"resource": ""
} |
q172189 | CloseResultsetID | validation | func (s *Session) CloseResultsetID(id uint64) error {
s.mu.Lock()
defer s.mu.Unlock()
s.resultsetID.id = &id
if err := s.writeRequest(mtCloseResultset, false, s.resultsetID); err != nil {
return err
}
if err := s.readReply(nil); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q172190 | Commit | validation | func (s *Session) Commit() error {
s.mu.Lock()
defer s.mu.Unlock()
if err := s.writeRequest(mtCommit, false); err != nil {
return err
}
if err := s.readReply(nil); err != nil {
return err
}
if trace {
outLogger.Printf("transaction flags: %s", s.txFlags)
}
s.conn.inTx = false
return nil
} | go | {
"resource": ""
} |
q172191 | NewReader | validation | func NewReader(r io.Reader) *Reader {
return &Reader{
rd: bufio.NewReader(r),
tr: unicode.Cesu8ToUtf8Transformer,
}
} | go | {
"resource": ""
} |
q172192 | NewReaderSize | validation | func NewReaderSize(r io.Reader, size int) *Reader {
return &Reader{
rd: bufio.NewReaderSize(r, size),
tr: unicode.Cesu8ToUtf8Transformer,
}
} | go | {
"resource": ""
} |
q172193 | GetError | validation | func (r *Reader) GetError() error {
err := r.err
r.err = nil
return err
} | go | {
"resource": ""
} |
q172194 | Skip | validation | func (r *Reader) Skip(cnt int) {
if r.err != nil {
return
}
var n int
n, r.err = r.rd.Discard(cnt)
r.cnt += n
} | go | {
"resource": ""
} |
q172195 | ReadB | validation | func (r *Reader) ReadB() byte { // ReadB as sig differs from ReadByte (vet issues)
if r.err != nil {
return 0
}
var b byte
b, r.err = r.rd.ReadByte()
r.cnt++
return b
} | go | {
"resource": ""
} |
q172196 | ReadFull | validation | func (r *Reader) ReadFull(p []byte) {
if r.err != nil {
return
}
var n int
n, r.err = io.ReadFull(r.rd, p)
r.cnt += n
} | go | {
"resource": ""
} |
q172197 | ReadBool | validation | func (r *Reader) ReadBool() bool {
if r.err != nil {
return false
}
return !(r.ReadB() == 0)
} | go | {
"resource": ""
} |
q172198 | ReadInt16 | validation | func (r *Reader) ReadInt16() int16 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:2])
r.cnt += n
if r.err != nil {
return 0
}
return int16(binary.LittleEndian.Uint16(r.b[:2]))
} | go | {
"resource": ""
} |
q172199 | ReadUint16 | validation | func (r *Reader) ReadUint16() uint16 {
if r.err != nil {
return 0
}
var n int
n, r.err = io.ReadFull(r.rd, r.b[:2])
r.cnt += n
if r.err != nil {
return 0
}
return binary.LittleEndian.Uint16(r.b[:2])
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.