id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15700 | [%s] not found in row", left)
}
p.LeftValue.v = val.v
return p.Operator(p.LeftValue, p.RightValue), nil
} | |
c15701 |
typeName: typeName,
autoIncrement: autoIncrement,
}
return a
} | |
c15702 |
c.parent.closingConn()
}
return nil
} | |
c15703 | {
tx := Tx{
conn: c,
}
return &tx, nil
} | |
c15704 | "", -1)
// Do things here
if strings.HasPrefix(stmt, "SELECT") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "SHOW") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "DESCRIBE") {
query(db, stmt)
} else {
exec(db, stmt)
}
}
} | |
c15705 |
close(cdc.conn)
cdc.conn = nil
} | |
c15706 | make(chan message)
cdc := &ChannelDriverConn{conn: channel}
cde.newConnChannel <- channel
return cdc, nil
} | |
c15707 | return nil, io.EOF
}
return NewChannelEngineConn(newConn), nil
} | |
c15708 | cec.conn = nil
return "", io.EOF
}
return message.Value[0], nil
} | |
c15709 | Value: []string{fmt.Sprintf("%d %d", lastInsertedID, rowsAffected)},
}
cec.conn <- m
return nil
} | |
c15710 | []string{err.Error()},
}
cec.conn <- m
return nil
} | |
c15711 | rowHeaderMessage,
Value: header,
}
cec.conn <- m
return nil
} | |
c15712 |
Value: row,
}
cec.conn <- m
return nil
} | |
c15713 | {
m := message{
Type: rowEndMessage,
}
cec.conn <- m
return nil
} | |
c15714 |
Type: queryMessage,
Value: []string{query},
}
cdc.conn <- m
return nil
} | |
c15715 |
Type: execMessage,
Value: []string{statement},
}
cdc.conn <- m
return nil
} | |
c15716 |
}
return 0, 0, fmt.Errorf("Protocal error: ReadResult received %v", m)
}
_, err = fmt.Sscanf(m.Value[0], "%d %d", &lastInsertedID, &rowsAffected)
return lastInsertedID, rowsAffected, err
} | |
c15717 | != rowHeaderMessage {
return nil, errors.New("not a rows header")
}
return UnlimitedRowsChannel(cdc.conn, m), nil
} | |
c15718 | like lock read/write here
// Maybe index
r.rows = append(r.rows, t)
return nil
} | |
c15719 |
return nil, fmt.Errorf("Cannot send query to server: %s", err)
}
// Get answer from server
lastInsertedID, rowsAffected, err := s.conn.conn.ReadResult()
if err != nil {
return nil, err
}
// Create a driver.Result
return newResult(lastInsertedID, rowsAffected), nil
} | |
c15720 | %s >\n", finalQuery)
err = s.conn.conn.WriteQuery(finalQuery)
if err != nil {
return nil, err
}
rowsChannel, err := s.conn.conn.ReadRows()
if err != nil {
return nil, err
}
r = newRows(rowsChannel)
return r, nil
} | |
c15721 | }
return
}
if driverChannel == nil {
log.Critical("Unlimited: But there is nobody to read it, exiting")
return
}
} else if newRow.Type == errMessage {
log.Critical("Runtime error: %s", newRow.Value[0])
if driverChannel != nil {
close(driverChannel)
}
r... | |
c15722 |
case parser.RightDipleToken:
return greaterThanOperator, nil
case parser.LessOrEqualToken:
return lessOrEqualOperator, nil
case parser.GreaterOrEqualToken:
return greaterOrEqualOperator, nil
}
return nil, fmt.Errorf("Operator '%s' does not exist", lexeme)
} | |
c15723 | leftValue.v) == rightValue.lexeme {
return true
}
return false
} | |
c15724 | = append(t.attributes, attr)
return nil
} | |
c15725 | }
stringy += a.name + " " + a.typeName
}
stringy += ")"
return stringy
} | |
c15726 | if lvl() <= DebugLevel {
logger.Logf("[DEBUG] "+format, values...)
}
} | |
c15727 | if lvl() <= InfoLevel {
logger.Logf("[INFO] "+format, values...)
}
} | |
c15728 | if lvl() <= NoticeLevel {
logger.Logf("[NOTICE] "+format, values...)
}
} | |
c15729 |
if lvl() <= WarningLevel {
logger.Logf("[WARNING] "+format, values...)
}
} | |
c15730 | logger.Logf("[CRITICAL] "+format, values...)
mu.Unlock()
} | |
c15731 | log.Printf(fmt, values...)
} | |
c15732 | l.t.Logf(fmt, values...)
} | |
c15733 | {
return nil, err
}
if len(instructions) == 0 {
return nil, errors.New("Error in syntax near " + instruction)
}
return instructions, nil
} | |
c15734 | if err == nil {
return &t, nil
}
t, err = time.Parse(DateShortFormat, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(DateNumberFormat, data)
if err == nil {
return &t, nil
}
return nil, fmt.Errorf("not a date")
} | |
c15735 |
}
server, err := engine.New(engineEndpoint)
if err != nil {
rs.Unlock()
return nil, err
}
driverConn, err := driverEndpoint.New(dsn)
if err != nil {
rs.Unlock()
return nil, err
}
s := &Server{
endpoint: driverEndpoint,
server: server,
}
rs.servers[dsn] = s
rs.Unlock()
re... | |
c15736 | to close itself
//r.rowsChannel <- []string{}
r.rowsChannel = nil
return nil
} | |
c15737 | := make(chan chan message)
return NewChannelDriverEndpoint(channel), NewChannelEngineEndpoint(channel)
} | |
c15738 | return bytes.Equal(l.Value, b.Value)
} | |
c15739 |
err := newDecodeError("line", reason)
return errors.Wrap(err, "failed to decode")
}
r, _ := utf8.DecodeRune(b[:delimiter])
l.Type = Type(r)
l.Value = append(l.Value, b[delimiter+1:]...)
return nil
} | |
c15740 | lineDelimiter)
return append(b, l.Value...)
} | |
c15741 | = l.AppendTo(b)
b = appendCLRF(b)
}
return b
} | |
c15742 | s {
if !s[i].Equal(b[i]) {
return false
}
}
return true
} | |
c15743 | v.Key == attribute {
return v.Value
}
}
return blank
} | |
c15744 | values = append(values, v.Value)
}
}
return values
} | |
c15745 | return time.Time{}
}
return m.Timing[0].Start
} | |
c15746 | return time.Time{}
}
return m.Timing[0].End
} | |
c15747 | return strings.TrimSpace(
strings.TrimPrefix(v, payloadType),
)
}
}
return ""
} | |
c15748 | i := len(buf)
var q int
for n >= 10 {
i--
q = n / 10
buf[i] = '0' + byte(n-q*10)
n = q
}
i--
buf[i] = '0' + byte(n)
dst = append(dst, buf[i:]...)
return dst
} | |
c15749 | s.appendString(Type(k), v)
} | |
c15750 | return s.appendString(t, v)
} | |
c15751 | = appendInt(v, version)
return s.append(TypeProtocolVersion, v)
} | |
c15752 | s.appendString(TypePhone, phone)
} | |
c15753 | s.appendString(TypeEmail, email)
} | |
c15754 |
v = appendSpace(v)
v = data.appendAddress(v)
return s.append(TypeConnectionData, v)
} | |
c15755 | s.AddConnectionData(ConnectionData{
IP: ip,
})
} | |
c15756 | s.appendString(TypeSessionName, name)
} | |
c15757 | s.appendString(TypeSessionInformation, info)
} | |
c15758 | s.appendString(TypeURI, uri)
} | |
c15759 | }
if c.TTL != b.TTL {
return false
}
if c.Addresses != b.Addresses {
return false
}
return true
} | |
c15760 | false
}
if o.AddressType != b.AddressType {
return false
}
if o.Address != b.Address {
return false
}
return true
} | |
c15761 | o.getNetworkType()...))
v = appendSpace(append(v, o.getAddressType()...))
v = append(v, o.Address...)
return s.append(TypeOrigin, v)
} | |
c15762 | {
return 0
}
return uint64(t.Unix()) + ntpDelta
} | |
c15763 | {
return time.Time{}
}
return time.Unix(int64(v-ntpDelta), 0)
} | |
c15764 | v = appendUint64(v, TimeToNTP(end))
return s.append(TypeTiming, v)
} | |
c15765 | s.AddTiming(NTPToTime(start), NTPToTime(end))
} | |
c15766 | = appendRune(v, ':')
v = appendInt(v, bandwidth)
return s.append(TypeBandwidth, v)
} | |
c15767 | return s.addRepeatTimes(false, interval, duration, offsets...)
} | |
c15768 |
offsets ...time.Duration) Session {
return s.addRepeatTimes(true, interval, duration, offsets...)
} | |
c15769 |
}
if len(m.Formats) != len(b.Formats) {
return false
}
for i := range m.Formats {
if m.Formats[i] != b.Formats[i] {
return false
}
}
return true
} | |
c15770 |
for i := range m.Formats {
v = append(v, m.Formats[i]...)
if i != len(m.Formats)-1 {
v = appendRune(v, fieldsDelimiter)
}
}
return s.append(TypeMediaDescription, v)
} | |
c15771 | s.AddEncryptionKey(e.Method, e.Key)
} | |
c15772 | zone := range zones {
v = zone.append(v)
if i != len(zones)-1 {
v = appendSpace(v)
}
}
return s.append(TypeTimeZones, v)
} | |
c15773 |
TypeTimeZones, TypeEncryptionKey,
TypeAttribute, TypeMediaDescription:
return true
default:
return false
}
} | |
c15774 | return nil
}
if isExpected(t, sectionMedia, 0) == nil {
return nil
}
case sectionTime:
if isExpected(t, sectionSession, orderingAfterTime) == nil {
return nil
}
case sectionMedia:
if pos != 0 && isExpected(t, sectionMedia, 0) == nil {
return nil
}
}
if !isKnown(t) {
return errUnknownType
... | |
c15775 | s = s.AddTiming(t.Start, t.End)
if len(t.Offsets) > 0 {
s = s.AddRepeatTimesCompact(t.Repeat, t.Active, t.Offsets...)
}
}
if len(m.TZAdjustments) > 0 {
s = s.AddTimeZones(m.TZAdjustments...)
}
if !m.Encryption.Blank() {
s = s.AddEncryption(m.Encryption)
}
s = s.appendAttributes(m.Attributes)
for i :... | |
c15776 | b.optimize = optimize
return Optimize(prev)
}
} | |
c15777 |
b.setOptions(opts)
return b.buildParser(g)
} | |
c15778 | basicLatinChars[unicode.ToUpper(j)] = true
} else {
basicLatinChars[unicode.ToLower(j)] = true
}
}
}
}
}
for _, cl := range unicodeClasses {
rt := rangeTable(cl)
for r := rune(0); r < 128; r++ {
if unicode.Is(rt, r) {
basicLatinChars[r] = true
}
}
}
return
} | |
c15779 | args...)
fmt.Fprintln(os.Stderr)
usage()
exit(exitCode)
} | |
c15780 |
}
inf = f
nm = filename
}
r := bufio.NewReader(inf)
return nm, makeReadCloser(r, inf)
} | |
c15781 | f, err := os.Create(filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(4)
}
out = f
}
return out
} | |
c15782 |
io.Closer
}{r, c}
return io.ReadCloser(rc)
} | |
c15783 | Col: c.pos.col, Off: c.pos.offset}
} | |
c15784 | (%d)", p.Filename, p.Line, p.Col, p.Off)
}
return fmt.Sprintf("%d:%d (%d)", p.Line, p.Col, p.Off)
} | |
c15785 | &Rule{p: p, Name: name}
} | |
c15786 | {
return &LitMatcher{posValue: posValue{p: p, Val: v}}
} | |
c15787 | &CharClassMatcher{posValue: posValue{p: p, Val: raw}}
c.parse()
return c
} | |
c15788 | &AnyMatcher{posValue{p, v}}
} | |
c15789 | &CodeBlock{posValue{p, code}}
} | |
c15790 | {
return &Identifier{posValue{p: p, Val: name}}
} | |
c15791 | {
return &StringLit{posValue{p: p, Val: val}}
} | |
c15792 | s.errh = errh
s.eof = false
s.cpos = ast.Pos{
Filename: filename,
Line: 1,
}
s.cur, s.cw = -1, 0
s.tok.Reset()
} | |
c15793 |
// newline is '\n' as in Go
if r == '\n' {
s.cpos.Line++
s.cpos.Col = 0
} else {
s.cpos.Col++
}
} | |
c15794 | == ' ' || s.cur == '\t' || s.cur == '\r' {
s.read()
}
} | |
c15795 | || r == '_' ||
r >= 0x80 && unicode.IsLetter(r)
} | |
c15796 | 0x80 && unicode.IsDigit(r)
} | |
c15797 | return
}
fmt.Fprintf(os.Stderr, "%s: %v\n", p, err)
} | |
c15798 | ...interface{}) {
s.errorpf(s.cpos, f, args...)
} | |
c15799 | s.error(p, fmt.Errorf(f, args...))
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.