Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "GroupContainsMember", "(", "ctx", "context", ".", "Context", ",", "groupName", ",", "uid", "string", ")", "(", "bool", ",", "error", ")", "{", "if", "uid", "==", "\"", "\"", "{", "return", "false", ",", "constants", ".", "ErrEmptyUID", "\n", "}", "\n", "return", "groupServiceInstance", ".", "GroupContainsMember", "(", "ctx", ",", "groupName", ",", "uid", ")", "\n", "}" ]

[ "GroupContainsMember", "checks", "whether", "an", "UID", "is", "contained", "in", "group", "or", "not" ]

[ "func", "GroupRemoveAll", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "return", "groupServiceInstance", ".", "GroupRemoveAll", "(", "ctx", ",", "groupName", ")", "\n", "}" ]

[ "GroupRemoveAll", "clears", "all", "UIDs" ]

[ "func", "GroupRenewTTL", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "return", "groupServiceInstance", ".", "GroupRenewTTL", "(", "ctx", ",", "groupName", ")", "\n", "}" ]

[ "GroupRenewTTL", "renews", "group", "with", "the", "initial", "TTL" ]

[ "func", "GroupDelete", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "return", "groupServiceInstance", ".", "GroupDelete", "(", "ctx", ",", "groupName", ")", "\n", "}" ]

[ "GroupDelete", "deletes", "whole", "group", "including", "UIDs", "and", "base", "group" ]

[ "func", "SendPushToUsers", "(", "route", "string", ",", "v", "interface", "{", "}", ",", "uids", "[", "]", "string", ",", "frontendType", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "data", ",", "err", ":=", "util", ".", "SerializeOrRaw", "(", "app", ".", "serializer", ",", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "uids", ",", "err", "\n", "}", "\n\n", "if", "!", "app", ".", "server", ".", "Frontend", "&&", "frontendType", "==", "\"", "\"", "{", "return", "uids", ",", "constants", ".", "ErrFrontendTypeNotSpecified", "\n", "}", "\n\n", "var", "notPushedUids", "[", "]", "string", "\n\n", "logger", ".", "Log", ".", "Debugf", "(", "\"", "\"", ",", "route", ",", "v", ",", "frontendType", ",", "len", "(", "uids", ")", ")", "\n\n", "for", "_", ",", "uid", ":=", "range", "uids", "{", "if", "s", ":=", "session", ".", "GetSessionByUID", "(", "uid", ")", ";", "s", "!=", "nil", "&&", "app", ".", "server", ".", "Type", "==", "frontendType", "{", "if", "err", ":=", "s", ".", "Push", "(", "route", ",", "data", ")", ";", "err", "!=", "nil", "{", "notPushedUids", "=", "append", "(", "notPushedUids", ",", "uid", ")", "\n", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "ID", "(", ")", ",", "s", ".", "UID", "(", ")", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "if", "app", ".", "rpcClient", "!=", "nil", "{", "push", ":=", "&", "protos", ".", "Push", "{", "Route", ":", "route", ",", "Uid", ":", "uid", ",", "Data", ":", "data", ",", "}", "\n", "if", "err", "=", "app", ".", "rpcClient", ".", "SendPush", "(", "uid", ",", "&", "cluster", ".", "Server", "{", "Type", ":", "frontendType", "}", ",", "push", ")", ";", "err", "!=", "nil", "{", "notPushedUids", "=", "append", "(", "notPushedUids", ",", "uid", ")", "\n", "logger", ".", "Log", ".", "Errorf", "(", "\"", "\"", ",", "uid", ",", "frontendType", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "else", "{", "notPushedUids", "=", "append", "(", "notPushedUids", ",", "uid", ")", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "notPushedUids", ")", "!=", "0", "{", "return", "notPushedUids", ",", "constants", ".", "ErrPushingToUsers", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "SendPushToUsers", "sends", "a", "message", "to", "the", "given", "list", "of", "users" ]

[ "func", "(", "gs", "*", "GRPCServer", ")", "Init", "(", ")", "error", "{", "port", ":=", "gs", ".", "config", ".", "GetInt", "(", "\"", "\"", ")", "\n", "lis", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "port", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "gs", ".", "grpcSv", "=", "grpc", ".", "NewServer", "(", ")", "\n", "protos", ".", "RegisterPitayaServer", "(", "gs", ".", "grpcSv", ",", "gs", ".", "pitayaServer", ")", "\n", "go", "gs", ".", "grpcSv", ".", "Serve", "(", "lis", ")", "\n", "return", "nil", "\n", "}" ]

[ "Init", "inits", "grpc", "rpc", "server" ]

[ "func", "ReportTimingFromCtx", "(", "ctx", "context", ".", "Context", ",", "reporters", "[", "]", "Reporter", ",", "typ", "string", ",", "err", "error", ")", "{", "code", ":=", "errors", ".", "CodeFromError", "(", "err", ")", "\n", "status", ":=", "\"", "\"", "\n", "if", "err", "!=", "nil", "{", "status", "=", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "reporters", ")", ">", "0", "{", "startTime", ":=", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "StartTimeKey", ")", "\n", "route", ":=", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "RouteKey", ")", "\n", "elapsed", ":=", "time", ".", "Since", "(", "time", ".", "Unix", "(", "0", ",", "startTime", ".", "(", "int64", ")", ")", ")", "\n", "tags", ":=", "getTags", "(", "ctx", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "route", ".", "(", "string", ")", ",", "\"", "\"", ":", "status", ",", "\"", "\"", ":", "typ", ",", "\"", "\"", ":", "code", ",", "}", ")", "\n", "for", "_", ",", "r", ":=", "range", "reporters", "{", "r", ".", "ReportSummary", "(", "ResponseTime", ",", "tags", ",", "float64", "(", "elapsed", ".", "Nanoseconds", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReportTimingFromCtx", "reports", "the", "latency", "from", "the", "context" ]

[ "func", "ReportMessageProcessDelayFromCtx", "(", "ctx", "context", ".", "Context", ",", "reporters", "[", "]", "Reporter", ",", "typ", "string", ")", "{", "if", "len", "(", "reporters", ")", ">", "0", "{", "startTime", ":=", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "StartTimeKey", ")", "\n", "elapsed", ":=", "time", ".", "Since", "(", "time", ".", "Unix", "(", "0", ",", "startTime", ".", "(", "int64", ")", ")", ")", "\n", "route", ":=", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "RouteKey", ")", "\n", "tags", ":=", "getTags", "(", "ctx", ",", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "route", ".", "(", "string", ")", ",", "\"", "\"", ":", "typ", ",", "}", ")", "\n", "for", "_", ",", "r", ":=", "range", "reporters", "{", "r", ".", "ReportSummary", "(", "ProcessDelay", ",", "tags", ",", "float64", "(", "elapsed", ".", "Nanoseconds", "(", ")", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "ReportMessageProcessDelayFromCtx", "reports", "the", "delay", "to", "process", "the", "messages" ]

[ "func", "ReportNumberOfConnectedClients", "(", "reporters", "[", "]", "Reporter", ",", "number", "int64", ")", "{", "for", "_", ",", "r", ":=", "range", "reporters", "{", "r", ".", "ReportGauge", "(", "ConnectedClients", ",", "map", "[", "string", "]", "string", "{", "}", ",", "float64", "(", "number", ")", ")", "\n", "}", "\n", "}" ]

[ "ReportNumberOfConnectedClients", "reports", "the", "number", "of", "connected", "clients" ]

[ "func", "ReportSysMetrics", "(", "reporters", "[", "]", "Reporter", ",", "period", "time", ".", "Duration", ")", "{", "for", "{", "for", "_", ",", "r", ":=", "range", "reporters", "{", "num", ":=", "runtime", ".", "NumGoroutine", "(", ")", "\n", "m", ":=", "&", "runtime", ".", "MemStats", "{", "}", "\n", "runtime", ".", "ReadMemStats", "(", "m", ")", "\n\n", "r", ".", "ReportGauge", "(", "Goroutines", ",", "map", "[", "string", "]", "string", "{", "}", ",", "float64", "(", "num", ")", ")", "\n", "r", ".", "ReportGauge", "(", "HeapSize", ",", "map", "[", "string", "]", "string", "{", "}", ",", "float64", "(", "m", ".", "Alloc", ")", ")", "\n", "r", ".", "ReportGauge", "(", "HeapObjects", ",", "map", "[", "string", "]", "string", "{", "}", ",", "float64", "(", "m", ".", "HeapObjects", ")", ")", "\n", "}", "\n\n", "time", ".", "Sleep", "(", "period", ")", "\n", "}", "\n", "}" ]

[ "ReportSysMetrics", "reports", "sys", "metrics" ]

[ "func", "NewMemoryGroupService", "(", "conf", "*", "config", ".", "Config", ")", "*", "MemoryGroupService", "{", "memoryOnce", ".", "Do", "(", "func", "(", ")", "{", "memoryGroups", "=", "make", "(", "map", "[", "string", "]", "*", "MemoryGroup", ")", "\n", "go", "groupTTLCleanup", "(", "conf", ")", "\n", "}", ")", "\n", "return", "&", "MemoryGroupService", "{", "}", "\n", "}" ]

[ "NewMemoryGroupService", "returns", "a", "new", "group", "instance" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupCreate", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "if", "_", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", ";", "ok", "{", "return", "constants", ".", "ErrGroupAlreadyExists", "\n", "}", "\n\n", "memoryGroups", "[", "groupName", "]", "=", "&", "MemoryGroup", "{", "}", "\n", "return", "nil", "\n", "}" ]

[ "GroupCreate", "creates", "a", "group", "without", "TTL" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupCreateWithTTL", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ",", "ttlTime", "time", ".", "Duration", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "if", "_", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", ";", "ok", "{", "return", "constants", ".", "ErrGroupAlreadyExists", "\n", "}", "\n\n", "memoryGroups", "[", "groupName", "]", "=", "&", "MemoryGroup", "{", "LastRefresh", ":", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ",", "TTL", ":", "ttlTime", ".", "Nanoseconds", "(", ")", "}", "\n", "return", "nil", "\n", "}" ]

[ "GroupCreateWithTTL", "creates", "a", "group", "with", "TTL", "which", "the", "go", "routine", "will", "clean", "later" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupMembers", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "mg", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n\n", "uids", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "mg", ".", "Uids", ")", ")", "\n", "copy", "(", "uids", ",", "mg", ".", "Uids", ")", "\n\n", "return", "uids", ",", "nil", "\n", "}" ]

[ "GroupMembers", "returns", "all", "member", "s", "UID", "in", "given", "group" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupContainsMember", "(", "ctx", "context", ".", "Context", ",", "groupName", ",", "uid", "string", ")", "(", "bool", ",", "error", ")", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "mg", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "false", ",", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n\n", "_", ",", "contains", ":=", "elementIndex", "(", "mg", ".", "Uids", ",", "uid", ")", "\n", "return", "contains", ",", "nil", "\n", "}" ]

[ "GroupContainsMember", "check", "whether", "an", "UID", "is", "contained", "in", "given", "group", "or", "not" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupRemoveMember", "(", "ctx", "context", ".", "Context", ",", "groupName", ",", "uid", "string", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "mg", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n", "index", ",", "contains", ":=", "elementIndex", "(", "mg", ".", "Uids", ",", "uid", ")", "\n", "if", "contains", "{", "mg", ".", "Uids", "[", "index", "]", "=", "mg", ".", "Uids", "[", "len", "(", "mg", ".", "Uids", ")", "-", "1", "]", "\n", "mg", ".", "Uids", "=", "mg", ".", "Uids", "[", ":", "len", "(", "mg", ".", "Uids", ")", "-", "1", "]", "\n", "memoryGroups", "[", "groupName", "]", "=", "mg", "\n", "return", "nil", "\n", "}", "\n\n", "return", "constants", ".", "ErrMemberNotFound", "\n", "}" ]

[ "GroupRemoveMember", "removes", "specific", "UID", "from", "group" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupRemoveAll", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "mg", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n\n", "mg", ".", "Uids", "=", "[", "]", "string", "{", "}", "\n", "return", "nil", "\n", "}" ]

[ "GroupRemoveAll", "clears", "all", "UIDs", "from", "group" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupDelete", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "_", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n\n", "delete", "(", "memoryGroups", ",", "groupName", ")", "\n", "return", "nil", "\n", "}" ]

[ "GroupDelete", "deletes", "the", "whole", "group", "including", "members", "and", "base", "group" ]

[ "func", "(", "c", "*", "MemoryGroupService", ")", "GroupRenewTTL", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "memoryGroupsMu", ".", "Lock", "(", ")", "\n", "defer", "memoryGroupsMu", ".", "Unlock", "(", ")", "\n\n", "mg", ",", "ok", ":=", "memoryGroups", "[", "groupName", "]", "\n", "if", "!", "ok", "{", "return", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n\n", "if", "mg", ".", "TTL", "!=", "0", "{", "mg", ".", "LastRefresh", "=", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", "\n", "memoryGroups", "[", "groupName", "]", "=", "mg", "\n", "return", "nil", "\n", "}", "\n", "return", "constants", ".", "ErrMemoryTTLNotFound", "\n", "}" ]

[ "GroupRenewTTL", "will", "renew", "lease", "TTL" ]

[ "func", "NewETCDBindingStorage", "(", "server", "*", "cluster", ".", "Server", ",", "conf", "*", "config", ".", "Config", ")", "*", "ETCDBindingStorage", "{", "b", ":=", "&", "ETCDBindingStorage", "{", "config", ":", "conf", ",", "thisServer", ":", "server", ",", "stopChan", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "b", ".", "configure", "(", ")", "\n", "return", "b", "\n", "}" ]

[ "NewETCDBindingStorage", "returns", "a", "new", "instance", "of", "BindingStorage" ]

[ "func", "(", "b", "*", "ETCDBindingStorage", ")", "PutBinding", "(", "uid", "string", ")", "error", "{", "_", ",", "err", ":=", "b", ".", "cli", ".", "Put", "(", "context", ".", "Background", "(", ")", ",", "getUserBindingKey", "(", "uid", ",", "b", ".", "thisServer", ".", "Type", ")", ",", "b", ".", "thisServer", ".", "ID", ",", "clientv3", ".", "WithLease", "(", "b", ".", "leaseID", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "PutBinding", "puts", "the", "binding", "info", "into", "etcd" ]

[ "func", "(", "b", "*", "ETCDBindingStorage", ")", "Init", "(", ")", "error", "{", "var", "cli", "*", "clientv3", ".", "Client", "\n", "var", "err", "error", "\n", "if", "b", ".", "cli", "==", "nil", "{", "cli", ",", "err", "=", "clientv3", ".", "New", "(", "clientv3", ".", "Config", "{", "Endpoints", ":", "b", ".", "etcdEndpoints", ",", "DialTimeout", ":", "b", ".", "etcdDialTimeout", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "b", ".", "cli", "=", "cli", "\n", "}", "\n", "// namespaced etcd :)", "b", ".", "cli", ".", "KV", "=", "namespace", ".", "NewKV", "(", "b", ".", "cli", ".", "KV", ",", "b", ".", "etcdPrefix", ")", "\n", "err", "=", "b", ".", "bootstrapLease", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "b", ".", "thisServer", ".", "Frontend", "{", "b", ".", "setupOnSessionCloseCB", "(", ")", "\n", "b", ".", "setupOnAfterSessionBindCB", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Init", "starts", "the", "binding", "storage", "module" ]

[ "func", "NewAPIDocsGen", "(", "basePath", "string", ",", "services", "[", "]", "*", "component", ".", "Service", ")", "*", "APIDocsGen", "{", "return", "&", "APIDocsGen", "{", "basePath", ":", "basePath", ",", "services", ":", "services", ",", "}", "\n", "}" ]

[ "NewAPIDocsGen", "creates", "a", "new", "APIDocsGen" ]

[ "func", "(", "a", "*", "APIDocsGen", ")", "Init", "(", ")", "error", "{", "for", "_", ",", "s", ":=", "range", "a", ".", "services", "{", "logger", ".", "Log", ".", "Infof", "(", "\"", "\"", ",", "s", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "is", "called", "on", "init", "method" ]

[ "func", "Configure", "(", "options", "Options", ")", "(", "io", ".", "Closer", ",", "error", ")", "{", "cfg", ":=", "config", ".", "Configuration", "{", "Disabled", ":", "options", ".", "Disabled", ",", "Sampler", ":", "&", "config", ".", "SamplerConfig", "{", "Type", ":", "jaeger", ".", "SamplerTypeProbabilistic", ",", "Param", ":", "options", ".", "Probability", ",", "}", ",", "}", "\n\n", "return", "cfg", ".", "InitGlobalTracer", "(", "options", ".", "ServiceName", ")", "\n", "}" ]

[ "Configure", "configures", "a", "global", "Jaeger", "tracer" ]

[ "func", "NewConfig", "(", "cfgs", "...", "*", "viper", ".", "Viper", ")", "*", "Config", "{", "var", "cfg", "*", "viper", ".", "Viper", "\n", "if", "len", "(", "cfgs", ")", ">", "0", "{", "cfg", "=", "cfgs", "[", "0", "]", "\n", "}", "else", "{", "cfg", "=", "viper", ".", "New", "(", ")", "\n", "}", "\n\n", "cfg", ".", "SetEnvKeyReplacer", "(", "strings", ".", "NewReplacer", "(", "\"", "\"", ",", "\"", "\"", ")", ")", "\n", "cfg", ".", "AutomaticEnv", "(", ")", "\n", "c", ":=", "&", "Config", "{", "config", ":", "cfg", "}", "\n", "c", ".", "fillDefaultValues", "(", ")", "\n", "return", "c", "\n", "}" ]

[ "NewConfig", "creates", "a", "new", "config", "with", "a", "given", "viper", "config", "if", "given" ]

[ "func", "(", "c", "*", "Config", ")", "GetDuration", "(", "s", "string", ")", "time", ".", "Duration", "{", "return", "c", ".", "config", ".", "GetDuration", "(", "s", ")", "\n", "}" ]

[ "GetDuration", "returns", "a", "duration", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "GetString", "(", "s", "string", ")", "string", "{", "return", "c", ".", "config", ".", "GetString", "(", "s", ")", "\n", "}" ]

[ "GetString", "returns", "a", "string", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "GetInt", "(", "s", "string", ")", "int", "{", "return", "c", ".", "config", ".", "GetInt", "(", "s", ")", "\n", "}" ]

[ "GetInt", "returns", "an", "int", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "GetBool", "(", "s", "string", ")", "bool", "{", "return", "c", ".", "config", ".", "GetBool", "(", "s", ")", "\n", "}" ]

[ "GetBool", "returns", "an", "boolean", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "GetStringSlice", "(", "s", "string", ")", "[", "]", "string", "{", "return", "c", ".", "config", ".", "GetStringSlice", "(", "s", ")", "\n", "}" ]

[ "GetStringSlice", "returns", "a", "string", "slice", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "GetStringMapString", "(", "s", "string", ")", "map", "[", "string", "]", "string", "{", "return", "c", ".", "config", ".", "GetStringMapString", "(", "s", ")", "\n", "}" ]

[ "GetStringMapString", "returns", "a", "string", "map", "string", "from", "the", "inner", "config" ]

[ "func", "(", "c", "*", "Config", ")", "UnmarshalKey", "(", "s", "string", ",", "v", "interface", "{", "}", ")", "error", "{", "return", "c", ".", "config", ".", "UnmarshalKey", "(", "s", ",", "v", ")", "\n", "}" ]

[ "UnmarshalKey", "unmarshals", "key", "into", "v" ]

[ "func", "NewEtcdGroupService", "(", "conf", "*", "config", ".", "Config", ",", "clientOrNil", "*", "clientv3", ".", "Client", ")", "(", "*", "EtcdGroupService", ",", "error", ")", "{", "err", ":=", "initClientInstance", "(", "conf", ",", "clientOrNil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "EtcdGroupService", "{", "}", ",", "err", "\n", "}" ]

[ "NewEtcdGroupService", "returns", "a", "new", "group", "instance" ]

[ "func", "(", "c", "*", "EtcdGroupService", ")", "GroupCreate", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "return", "c", ".", "createGroup", "(", "ctx", ",", "groupName", ",", "0", ")", "\n", "}" ]

[ "GroupCreate", "creates", "a", "group", "struct", "inside", "ETCD", "without", "TTL" ]

[ "func", "(", "c", "*", "EtcdGroupService", ")", "GroupCreateWithTTL", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ",", "ttlTime", "time", ".", "Duration", ")", "error", "{", "ctxT", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "transactionTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "lease", ",", "err", ":=", "clientInstance", ".", "Grant", "(", "ctxT", ",", "int64", "(", "ttlTime", ".", "Seconds", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "c", ".", "createGroup", "(", "ctx", ",", "groupName", ",", "lease", ".", "ID", ")", "\n", "}" ]

[ "GroupCreateWithTTL", "creates", "a", "group", "struct", "inside", "ETCD", "with", "TTL", "using", "leaseID" ]

[ "func", "(", "c", "*", "EtcdGroupService", ")", "GroupContainsMember", "(", "ctx", "context", ".", "Context", ",", "groupName", ",", "uid", "string", ")", "(", "bool", ",", "error", ")", "{", "ctxT", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "transactionTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "etcdRes", ",", "err", ":=", "clientInstance", ".", "Txn", "(", "ctxT", ")", ".", "If", "(", "clientv3", ".", "Compare", "(", "clientv3", ".", "CreateRevision", "(", "groupKey", "(", "groupName", ")", ")", ",", "\"", "\"", ",", "0", ")", ")", ".", "Then", "(", "clientv3", ".", "OpGet", "(", "memberKey", "(", "groupName", ",", "uid", ")", ",", "clientv3", ".", "WithCountOnly", "(", ")", ")", ")", ".", "Commit", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "etcdRes", ".", "Succeeded", "{", "return", "false", ",", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n", "return", "etcdRes", ".", "Responses", "[", "0", "]", ".", "GetResponseRange", "(", ")", ".", "GetCount", "(", ")", ">", "0", ",", "nil", "\n", "}" ]

[ "GroupContainsMember", "checks", "whether", "a", "UID", "is", "contained", "in", "current", "group", "or", "not" ]

[ "func", "(", "c", "*", "EtcdGroupService", ")", "GroupRemoveAll", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "ctxT", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "transactionTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "etcdRes", ",", "err", ":=", "clientInstance", ".", "Txn", "(", "ctxT", ")", ".", "If", "(", "clientv3", ".", "Compare", "(", "clientv3", ".", "CreateRevision", "(", "groupKey", "(", "groupName", ")", ")", ",", "\"", "\"", ",", "0", ")", ")", ".", "Then", "(", "clientv3", ".", "OpDelete", "(", "memberKey", "(", "groupName", ",", "\"", "\"", ")", ",", "clientv3", ".", "WithPrefix", "(", ")", ")", ")", ".", "Commit", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "etcdRes", ".", "Succeeded", "{", "return", "constants", ".", "ErrGroupNotFound", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GroupRemoveAll", "clears", "all", "UIDs", "in", "the", "group" ]

[ "func", "(", "c", "*", "EtcdGroupService", ")", "GroupRenewTTL", "(", "ctx", "context", ".", "Context", ",", "groupName", "string", ")", "error", "{", "kv", ",", "err", ":=", "getGroupKV", "(", "ctx", ",", "groupName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "kv", ".", "Lease", "!=", "0", "{", "ctxT", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "transactionTimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "_", ",", "err", "=", "clientInstance", ".", "KeepAliveOnce", "(", "ctxT", ",", "clientv3", ".", "LeaseID", "(", "kv", ".", "Lease", ")", ")", "\n", "return", "err", "\n", "}", "\n", "return", "constants", ".", "ErrEtcdLeaseNotFound", "\n", "}" ]

[ "GroupRenewTTL", "will", "renew", "ETCD", "lease", "TTL" ]

[ "func", "Report", "(", "reporters", "[", "]", "metrics", ".", "Reporter", ",", "period", "time", ".", "Duration", ")", "{", "for", "{", "time", ".", "Sleep", "(", "period", ")", "\n\n", "workerStats", ":=", "workers", ".", "GetStats", "(", ")", "\n", "for", "_", ",", "r", ":=", "range", "reporters", "{", "reportJobsRetry", "(", "r", ",", "workerStats", ".", "Retries", ")", "\n", "reportQueueSizes", "(", "r", ",", "workerStats", ".", "Enqueued", ")", "\n", "reportJobsTotal", "(", "r", ",", "workerStats", ".", "Failed", ",", "workerStats", ".", "Processed", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Report", "sends", "periodic", "of", "worker", "reports" ]

[ "func", "Pcall", "(", "method", "reflect", ".", "Method", ",", "args", "[", "]", "reflect", ".", "Value", ")", "(", "rets", "interface", "{", "}", ",", "err", "error", ")", "{", "defer", "func", "(", ")", "{", "if", "rec", ":=", "recover", "(", ")", ";", "rec", "!=", "nil", "{", "// Try to use logger from context here to help trace error cause", "log", ":=", "getLoggerFromArgs", "(", "args", ")", "\n", "log", ".", "Errorf", "(", "\"", "\"", ",", "method", ".", "Name", ",", "rec", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "debug", ".", "Stack", "(", ")", ")", "\n", "if", "s", ",", "ok", ":=", "rec", ".", "(", "string", ")", ";", "ok", "{", "err", "=", "errors", ".", "New", "(", "s", ")", "\n", "}", "else", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "method", ".", "Name", ",", "rec", ")", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "r", ":=", "method", ".", "Func", ".", "Call", "(", "args", ")", "\n", "// r can have 0 length in case of notify handlers", "// otherwise it will have 2 outputs: an interface and an error", "if", "len", "(", "r", ")", "==", "2", "{", "if", "v", ":=", "r", "[", "1", "]", ".", "Interface", "(", ")", ";", "v", "!=", "nil", "{", "err", "=", "v", ".", "(", "error", ")", "\n", "}", "else", "if", "!", "r", "[", "0", "]", ".", "IsNil", "(", ")", "{", "rets", "=", "r", "[", "0", "]", ".", "Interface", "(", ")", "\n", "}", "else", "{", "err", "=", "constants", ".", "ErrReplyShouldBeNotNull", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "Pcall", "calls", "a", "method", "that", "returns", "an", "interface", "and", "an", "error", "and", "recovers", "in", "case", "of", "panic" ]

[ "func", "SliceContainsString", "(", "slice", "[", "]", "string", ",", "str", "string", ")", "bool", "{", "for", "_", ",", "value", ":=", "range", "slice", "{", "if", "value", "==", "str", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "SliceContainsString", "returns", "true", "if", "a", "slice", "contains", "the", "string" ]

[ "func", "SerializeOrRaw", "(", "serializer", "serialize", ".", "Serializer", ",", "v", "interface", "{", "}", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "data", ",", "ok", ":=", "v", ".", "(", "[", "]", "byte", ")", ";", "ok", "{", "return", "data", ",", "nil", "\n", "}", "\n", "data", ",", "err", ":=", "serializer", ".", "Marshal", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "data", ",", "nil", "\n", "}" ]

[ "SerializeOrRaw", "serializes", "the", "interface", "if", "its", "not", "an", "array", "of", "bytes", "already" ]

[ "func", "GetErrorPayload", "(", "serializer", "serialize", ".", "Serializer", ",", "err", "error", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "code", ":=", "e", ".", "ErrUnknownCode", "\n", "msg", ":=", "err", ".", "Error", "(", ")", "\n", "metadata", ":=", "map", "[", "string", "]", "string", "{", "}", "\n", "if", "val", ",", "ok", ":=", "err", ".", "(", "*", "e", ".", "Error", ")", ";", "ok", "{", "code", "=", "val", ".", "Code", "\n", "metadata", "=", "val", ".", "Metadata", "\n", "}", "\n", "errPayload", ":=", "&", "protos", ".", "Error", "{", "Code", ":", "code", ",", "Msg", ":", "msg", ",", "}", "\n", "if", "len", "(", "metadata", ")", ">", "0", "{", "errPayload", ".", "Metadata", "=", "metadata", "\n", "}", "\n", "return", "SerializeOrRaw", "(", "serializer", ",", "errPayload", ")", "\n", "}" ]

[ "GetErrorPayload", "creates", "and", "serializes", "an", "error", "payload" ]

[ "func", "ConvertProtoToMessageType", "(", "protoMsgType", "protos", ".", "MsgType", ")", "message", ".", "Type", "{", "var", "msgType", "message", ".", "Type", "\n", "switch", "protoMsgType", "{", "case", "protos", ".", "MsgType_MsgRequest", ":", "msgType", "=", "message", ".", "Request", "\n", "case", "protos", ".", "MsgType_MsgNotify", ":", "msgType", "=", "message", ".", "Notify", "\n", "}", "\n", "return", "msgType", "\n", "}" ]

[ "ConvertProtoToMessageType", "converts", "a", "protos", ".", "MsgType", "to", "a", "message", ".", "Type" ]

[ "func", "CtxWithDefaultLogger", "(", "ctx", "context", ".", "Context", ",", "route", ",", "userID", "string", ")", "context", ".", "Context", "{", "var", "defaultLogger", "logger", ".", "Logger", "\n", "logrusLogger", ",", "ok", ":=", "logger", ".", "Log", ".", "(", "logrus", ".", "FieldLogger", ")", "\n", "if", "ok", "{", "requestID", ":=", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "RequestIDKey", ")", "\n", "if", "rID", ",", "ok", ":=", "requestID", ".", "(", "string", ")", ";", "ok", "{", "if", "rID", "==", "\"", "\"", "{", "requestID", "=", "uuid", ".", "New", "(", ")", "\n", "}", "\n", "}", "else", "{", "requestID", "=", "uuid", ".", "New", "(", ")", "\n", "}", "\n", "defaultLogger", "=", "logrusLogger", ".", "WithFields", "(", "logrus", ".", "Fields", "{", "\"", "\"", ":", "route", ",", "\"", "\"", ":", "requestID", ",", "\"", "\"", ":", "userID", ",", "}", ")", "\n", "}", "else", "{", "defaultLogger", "=", "logger", ".", "Log", "\n", "}", "\n\n", "return", "context", ".", "WithValue", "(", "ctx", ",", "constants", ".", "LoggerCtxKey", ",", "defaultLogger", ")", "\n", "}" ]

[ "CtxWithDefaultLogger", "inserts", "a", "default", "logger", "on", "ctx", "to", "be", "used", "on", "handlers", "and", "remotes", ".", "If", "using", "logrus", "userId", "route", "and", "requestId", "will", "be", "added", "as", "fields", ".", "Otherwise", "the", "pitaya", "logger", "will", "be", "used", "as", "it", "is", "." ]

[ "func", "GetContextFromRequest", "(", "req", "*", "protos", ".", "Request", ",", "serverID", "string", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "ctx", ",", "err", ":=", "pcontext", ".", "Decode", "(", "req", ".", "GetMetadata", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "ctx", "==", "nil", "{", "return", "nil", ",", "constants", ".", "ErrNoContextFound", "\n", "}", "\n", "tags", ":=", "opentracing", ".", "Tags", "{", "\"", "\"", ":", "serverID", ",", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "PeerIDKey", ")", ",", "\"", "\"", ":", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "PeerServiceKey", ")", ",", "\"", "\"", ":", "pcontext", ".", "GetFromPropagateCtx", "(", "ctx", ",", "constants", ".", "RequestIDKey", ")", ",", "}", "\n", "parent", ",", "err", ":=", "tracing", ".", "ExtractSpan", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Log", ".", "Warnf", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "ctx", "=", "tracing", ".", "StartSpan", "(", "ctx", ",", "req", ".", "GetMsg", "(", ")", ".", "GetRoute", "(", ")", ",", "tags", ",", "parent", ")", "\n", "ctx", "=", "CtxWithDefaultLogger", "(", "ctx", ",", "req", ".", "GetMsg", "(", ")", ".", "GetRoute", "(", ")", ",", "\"", "\"", ")", "\n", "return", "ctx", ",", "nil", "\n", "}" ]

[ "GetContextFromRequest", "gets", "the", "context", "from", "a", "request" ]

[ "func", "(", "s", "*", "SessionVars", ")", "SetStatusFlag", "(", "flag", "uint16", ",", "on", "bool", ")", "{", "if", "on", "{", "s", ".", "Status", "|=", "flag", "\n", "return", "\n", "}", "\n", "s", ".", "Status", "&=", "(", "^", "flag", ")", "\n", "}" ]

[ "SetStatusFlag", "sets", "the", "session", "server", "status", "variable", ".", "If", "on", "is", "ture", "sets", "the", "flag", "in", "session", "status", "otherwise", "removes", "the", "flag", "." ]

[ "func", "(", "sc", "*", "StatementContext", ")", "GetWarnings", "(", ")", "[", "]", "error", "{", "sc", ".", "mu", ".", "Lock", "(", ")", "\n", "warns", ":=", "make", "(", "[", "]", "error", ",", "len", "(", "sc", ".", "mu", ".", "warnings", ")", ")", "\n", "copy", "(", "warns", ",", "sc", ".", "mu", ".", "warnings", ")", "\n", "sc", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "warns", "\n", "}" ]

[ "GetWarnings", "gets", "warnings", "." ]

[ "func", "(", "sc", "*", "StatementContext", ")", "AppendWarning", "(", "warn", "error", ")", "{", "sc", ".", "mu", ".", "Lock", "(", ")", "\n", "sc", ".", "mu", ".", "warnings", "=", "append", "(", "sc", ".", "mu", ".", "warnings", ",", "warn", ")", "\n", "sc", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "AppendWarning", "appends", "a", "warning", "." ]

[ "func", "(", "t", "*", "TableInfo", ")", "Clone", "(", ")", "*", "TableInfo", "{", "nt", ":=", "*", "t", "\n", "nt", ".", "Columns", "=", "make", "(", "[", "]", "*", "ColumnInfo", ",", "len", "(", "t", ".", "Columns", ")", ")", "\n", "nt", ".", "Indices", "=", "make", "(", "[", "]", "*", "IndexInfo", ",", "len", "(", "t", ".", "Indices", ")", ")", "\n\n", "for", "i", ":=", "range", "t", ".", "Columns", "{", "nt", ".", "Columns", "[", "i", "]", "=", "t", ".", "Columns", "[", "i", "]", ".", "Clone", "(", ")", "\n", "}", "\n\n", "for", "i", ":=", "range", "t", ".", "Indices", "{", "nt", ".", "Indices", "[", "i", "]", "=", "t", ".", "Indices", "[", "i", "]", ".", "Clone", "(", ")", "\n", "}", "\n\n", "return", "&", "nt", "\n", "}" ]

[ "Clone", "clones", "TableInfo", "." ]

[ "func", "(", "index", "*", "IndexInfo", ")", "Clone", "(", ")", "*", "IndexInfo", "{", "ni", ":=", "*", "index", "\n", "ni", ".", "Columns", "=", "make", "(", "[", "]", "*", "IndexColumn", ",", "len", "(", "index", ".", "Columns", ")", ")", "\n", "for", "i", ":=", "range", "index", ".", "Columns", "{", "ni", ".", "Columns", "[", "i", "]", "=", "index", ".", "Columns", "[", "i", "]", ".", "Clone", "(", ")", "\n", "}", "\n", "return", "&", "ni", "\n", "}" ]

[ "Clone", "clones", "IndexInfo", "." ]

[ "func", "(", "db", "*", "DBInfo", ")", "Clone", "(", ")", "*", "DBInfo", "{", "newInfo", ":=", "*", "db", "\n", "newInfo", ".", "Tables", "=", "make", "(", "[", "]", "*", "TableInfo", ",", "len", "(", "db", ".", "Tables", ")", ")", "\n", "for", "i", ":=", "range", "db", ".", "Tables", "{", "newInfo", ".", "Tables", "[", "i", "]", "=", "db", ".", "Tables", "[", "i", "]", ".", "Clone", "(", ")", "\n", "}", "\n", "return", "&", "newInfo", "\n", "}" ]

[ "Clone", "clones", "DBInfo", "." ]

[ "func", "NewCIStr", "(", "s", "string", ")", "(", "cs", "CIStr", ")", "{", "cs", ".", "O", "=", "s", "\n", "cs", ".", "L", "=", "strings", ".", "ToLower", "(", "s", ")", "\n", "return", "\n", "}" ]

[ "NewCIStr", "creates", "a", "new", "CIStr", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Output", "(", "f", "func", "(", "io", ".", "Reader", ")", "error", ")", "*", "Dataset", "{", "step", ":=", "d", ".", "Flow", ".", "AddAllToOneStep", "(", "d", ",", "nil", ")", "\n", "step", ".", "IsOnDriverSide", "=", "true", "\n", "step", ".", "Name", "=", "\"", "\"", "\n", "step", ".", "Function", "=", "func", "(", "readers", "[", "]", "io", ".", "Reader", ",", "writers", "[", "]", "io", ".", "Writer", ",", "stat", "*", "pb", ".", "InstructionStat", ")", "error", "{", "errChan", ":=", "make", "(", "chan", "error", ",", "len", "(", "readers", ")", ")", "\n", "for", "i", ",", "reader", ":=", "range", "readers", "{", "go", "func", "(", "i", "int", ",", "reader", "io", ".", "Reader", ")", "{", "errChan", "<-", "f", "(", "reader", ")", "\n", "}", "(", "i", ",", "reader", ")", "\n", "}", "\n", "for", "range", "readers", "{", "err", ":=", "<-", "errChan", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n", "return", "d", "\n", "}" ]

[ "Output", "concurrently", "collects", "outputs", "from", "previous", "step", "to", "the", "driver", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Fprintf", "(", "writer", "io", ".", "Writer", ",", "format", "string", ")", "*", "Dataset", "{", "fn", ":=", "func", "(", "r", "io", ".", "Reader", ")", "error", "{", "w", ":=", "bufio", ".", "NewWriter", "(", "writer", ")", "\n", "defer", "w", ".", "Flush", "(", ")", "\n", "return", "util", ".", "Fprintf", "(", "w", ",", "r", ",", "format", ")", "\n", "}", "\n", "return", "d", ".", "Output", "(", "fn", ")", "\n", "}" ]

[ "Fprintf", "formats", "using", "the", "format", "for", "each", "row", "and", "writes", "to", "writer", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Fprintlnf", "(", "writer", "io", ".", "Writer", ",", "format", "string", ")", "*", "Dataset", "{", "return", "d", ".", "Fprintf", "(", "writer", ",", "format", "+", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "Fprintlnf", "add", "\\", "n", "at", "the", "end", "of", "each", "format" ]

[ "func", "(", "d", "*", "Dataset", ")", "Printf", "(", "format", "string", ")", "*", "Dataset", "{", "return", "d", ".", "Fprintf", "(", "os", ".", "Stdout", ",", "format", ")", "\n", "}" ]

[ "Printf", "prints", "to", "os", ".", "Stdout", "in", "the", "specified", "format" ]

[ "func", "(", "d", "*", "Dataset", ")", "Printlnf", "(", "format", "string", ")", "*", "Dataset", "{", "return", "d", ".", "Fprintf", "(", "os", ".", "Stdout", ",", "format", "+", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "Printlnf", "prints", "to", "os", ".", "Stdout", "in", "the", "specified", "format", "adding", "an", "\\", "n", "at", "the", "end", "of", "each", "format" ]

[ "func", "(", "d", "*", "Dataset", ")", "SaveFirstRowTo", "(", "decodedObjects", "...", "interface", "{", "}", ")", "*", "Dataset", "{", "fn", ":=", "func", "(", "reader", "io", ".", "Reader", ")", "error", "{", "return", "util", ".", "TakeMessage", "(", "reader", ",", "1", ",", "func", "(", "encodedBytes", "[", "]", "byte", ")", "error", "{", "row", ",", "err", ":=", "util", ".", "DecodeRow", "(", "encodedBytes", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "var", "counter", "int", "\n", "for", "_", ",", "v", ":=", "range", "row", ".", "K", "{", "if", "err", ":=", "setValueTo", "(", "v", ",", "decodedObjects", "[", "counter", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "counter", "++", "\n", "}", "\n", "for", "_", ",", "v", ":=", "range", "row", ".", "V", "{", "if", "err", ":=", "setValueTo", "(", "v", ",", "decodedObjects", "[", "counter", "]", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "counter", "++", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n", "}", "\n", "return", "d", ".", "Output", "(", "fn", ")", "\n", "}" ]

[ "SaveFirstRowTo", "saves", "the", "first", "row", "s", "values", "into", "the", "operands", "." ]

[ "func", "runStmt", "(", "ctx", "context", ".", "Context", ",", "s", "ast", ".", "Statement", ")", "(", "ast", ".", "RecordSet", ",", "error", ")", "{", "var", "err", "error", "\n", "var", "rs", "ast", ".", "RecordSet", "\n", "rs", ",", "err", "=", "s", ".", "Exec", "(", "ctx", ")", "\n", "return", "rs", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "runStmt", "executes", "the", "ast", ".", "Statement", "and", "commit", "or", "rollback", "the", "current", "transaction", "." ]

[ "func", "(", "this", "*", "Dataset", ")", "CoGroupPartitionedSorted", "(", "name", "string", ",", "that", "*", "Dataset", ",", "indexes", "[", "]", "int", ")", "(", "ret", "*", "Dataset", ")", "{", "ret", "=", "this", ".", "Flow", ".", "NewNextDataset", "(", "len", "(", "this", ".", "Shards", ")", ")", "\n", "ret", ".", "IsPartitionedBy", "=", "indexes", "\n\n", "inputs", ":=", "[", "]", "*", "Dataset", "{", "this", ",", "that", "}", "\n", "step", ":=", "this", ".", "Flow", ".", "MergeDatasets1ShardTo1Step", "(", "inputs", ",", "ret", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewCoGroupPartitionedSorted", "(", "indexes", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "CoGroupPartitionedSorted", "joins", "2", "datasets", "that", "are", "sharded", "by", "the", "same", "key", "and", "already", "locally", "sorted", "within", "each", "shard", "." ]

[ "func", "NewAggFunction", "(", "funcType", "string", ",", "funcArgs", "[", "]", "Expression", ",", "distinct", "bool", ")", "AggregationFunction", "{", "switch", "tp", ":=", "strings", ".", "ToLower", "(", "funcType", ")", ";", "tp", "{", "case", "ast", ".", "AggFuncSum", ":", "return", "&", "sumFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", "}", "\n", "case", "ast", ".", "AggFuncCount", ":", "return", "&", "countFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", "}", "\n", "case", "ast", ".", "AggFuncAvg", ":", "return", "&", "avgFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", "}", "\n", "case", "ast", ".", "AggFuncGroupConcat", ":", "return", "&", "concatFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", "}", "\n", "case", "ast", ".", "AggFuncMax", ":", "return", "&", "maxMinFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", ",", "isMax", ":", "true", "}", "\n", "case", "ast", ".", "AggFuncMin", ":", "return", "&", "maxMinFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", ",", "isMax", ":", "false", "}", "\n", "case", "ast", ".", "AggFuncFirstRow", ":", "return", "&", "firstRowFunction", "{", "aggFunction", ":", "newAggFunc", "(", "tp", ",", "funcArgs", ",", "distinct", ")", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "NewAggFunction", "creates", "a", "new", "AggregationFunction", "." ]

[ "func", "(", "af", "*", "aggFunction", ")", "Equal", "(", "b", "AggregationFunction", ",", "ctx", "context", ".", "Context", ")", "bool", "{", "if", "af", ".", "GetName", "(", ")", "!=", "b", ".", "GetName", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "af", ".", "Distinct", "!=", "b", ".", "IsDistinct", "(", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "af", ".", "GetArgs", "(", ")", ")", "==", "len", "(", "b", ".", "GetArgs", "(", ")", ")", "{", "for", "i", ",", "argA", ":=", "range", "af", ".", "GetArgs", "(", ")", "{", "if", "!", "argA", ".", "Equal", "(", "b", ".", "GetArgs", "(", ")", "[", "i", "]", ",", "ctx", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Equal", "implements", "AggregationFunction", "interface", "." ]

[ "func", "(", "af", "*", "aggFunction", ")", "Clear", "(", ")", "{", "af", ".", "resultMapper", "=", "make", "(", "aggCtxMapper", ",", "0", ")", "\n", "af", ".", "streamCtx", "=", "nil", "\n", "}" ]

[ "Clear", "implements", "AggregationFunction", "interface", "." ]

[ "func", "(", "e", "*", "SQLError", ")", "Error", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "e", ".", "Code", ",", "e", ".", "State", ",", "e", ".", "Message", ")", "\n", "}" ]

[ "Error", "prints", "errors", "with", "a", "formatted", "string", "." ]

[ "func", "NewErr", "(", "errCode", "uint16", ",", "args", "...", "interface", "{", "}", ")", "*", "SQLError", "{", "e", ":=", "&", "SQLError", "{", "Code", ":", "errCode", "}", "\n\n", "if", "s", ",", "ok", ":=", "MySQLState", "[", "errCode", "]", ";", "ok", "{", "e", ".", "State", "=", "s", "\n", "}", "else", "{", "e", ".", "State", "=", "DefaultMySQLState", "\n", "}", "\n\n", "if", "format", ",", "ok", ":=", "MySQLErrName", "[", "errCode", "]", ";", "ok", "{", "e", ".", "Message", "=", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", "\n", "}", "else", "{", "e", ".", "Message", "=", "fmt", ".", "Sprint", "(", "args", "...", ")", "\n", "}", "\n\n", "return", "e", "\n", "}" ]

[ "NewErr", "generates", "a", "SQL", "error", "with", "an", "error", "code", "and", "default", "format", "specifier", "defined", "in", "MySQLErrName", "." ]

[ "func", "NewErrf", "(", "errCode", "uint16", ",", "format", "string", ",", "args", "...", "interface", "{", "}", ")", "*", "SQLError", "{", "e", ":=", "&", "SQLError", "{", "Code", ":", "errCode", "}", "\n\n", "if", "s", ",", "ok", ":=", "MySQLState", "[", "errCode", "]", ";", "ok", "{", "e", ".", "State", "=", "s", "\n", "}", "else", "{", "e", ".", "State", "=", "DefaultMySQLState", "\n", "}", "\n\n", "e", ".", "Message", "=", "fmt", ".", "Sprintf", "(", "format", ",", "args", "...", ")", "\n\n", "return", "e", "\n", "}" ]

[ "NewErrf", "creates", "a", "SQL", "error", "with", "an", "error", "code", "and", "a", "format", "specifier", "." ]

[ "func", "DoLocalLimit", "(", "reader", "io", ".", "Reader", ",", "writer", "io", ".", "Writer", ",", "n", "int", ",", "offset", "int", ",", "stats", "*", "pb", ".", "InstructionStat", ")", "error", "{", "return", "util", ".", "ProcessRow", "(", "reader", ",", "nil", ",", "func", "(", "row", "*", "util", ".", "Row", ")", "error", "{", "stats", ".", "InputCounter", "++", "\n\n", "if", "offset", ">", "0", "{", "offset", "--", "\n", "}", "else", "{", "if", "n", ">", "0", "{", "row", ".", "WriteTo", "(", "writer", ")", "\n", "stats", ".", "OutputCounter", "++", "\n", "}", "\n", "n", "--", "\n", "}", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "}" ]

[ "DoLocalLimit", "streamingly", "get", "the", "n", "items", "starting", "from", "offset" ]

[ "func", "exprHasSetVar", "(", "expr", "expression", ".", "Expression", ")", "bool", "{", "if", "fun", ",", "ok", ":=", "expr", ".", "(", "*", "expression", ".", "ScalarFunction", ")", ";", "ok", "{", "canPrune", ":=", "true", "\n", "if", "fun", ".", "FuncName", ".", "L", "==", "ast", ".", "SetVar", "{", "return", "false", "\n", "}", "\n", "for", "_", ",", "arg", ":=", "range", "fun", ".", "GetArgs", "(", ")", "{", "canPrune", "=", "canPrune", "&&", "exprHasSetVar", "(", "arg", ")", "\n", "if", "!", "canPrune", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "exprHasSetVar", "checks", "if", "the", "expression", "has", "set", "-", "var", "function", ".", "If", "do", "we", "should", "not", "prune", "it", "." ]

[ "func", "NewSegmentMap", "(", "size", "int64", ")", "(", "*", "SegmentMap", ",", "error", ")", "{", "if", "size", "<=", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "size", ")", "\n", "}", "\n\n", "sm", ":=", "&", "SegmentMap", "{", "maps", ":", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "size", ")", ",", "size", ":", "size", ",", "}", "\n", "for", "i", ":=", "int64", "(", "0", ")", ";", "i", "<", "size", ";", "i", "++", "{", "sm", ".", "maps", "[", "i", "]", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n\n", "sm", ".", "crcTable", "=", "crc32", ".", "MakeTable", "(", "crc32", ".", "Castagnoli", ")", "\n", "return", "sm", ",", "nil", "\n", "}" ]

[ "NewSegmentMap", "creates", "a", "new", "SegmentMap", "." ]

[ "func", "(", "sm", "*", "SegmentMap", ")", "GetSegment", "(", "index", "int64", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "if", "index", ">=", "sm", ".", "size", "||", "index", "<", "0", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "index", ")", "\n", "}", "\n\n", "return", "sm", ".", "maps", "[", "index", "]", ",", "nil", "\n", "}" ]

[ "GetSegment", "gets", "the", "map", "specific", "by", "index", "." ]

[ "func", "(", "sm", "*", "SegmentMap", ")", "Set", "(", "key", "[", "]", "byte", ",", "value", "interface", "{", "}", ",", "force", "bool", ")", "bool", "{", "idx", ":=", "int64", "(", "crc32", ".", "Checksum", "(", "key", ",", "sm", ".", "crcTable", ")", ")", "%", "sm", ".", "size", "\n", "k", ":=", "string", "(", "key", ")", "\n", "_", ",", "exist", ":=", "sm", ".", "maps", "[", "idx", "]", "[", "k", "]", "\n", "if", "exist", "&&", "!", "force", "{", "return", "exist", "\n", "}", "\n\n", "sm", ".", "maps", "[", "idx", "]", "[", "k", "]", "=", "value", "\n", "return", "exist", "\n", "}" ]

[ "Set", "if", "key", "not", "exists", "returns", "whether", "already", "exists", "." ]

[ "func", "GetStatusVars", "(", ")", "(", "map", "[", "string", "]", "*", "StatusVal", ",", "error", ")", "{", "statusVars", ":=", "make", "(", "map", "[", "string", "]", "*", "StatusVal", ")", "\n\n", "for", "_", ",", "statistics", ":=", "range", "statisticsList", "{", "vals", ",", "err", ":=", "statistics", ".", "Stats", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "for", "name", ",", "val", ":=", "range", "vals", "{", "scope", ":=", "statistics", ".", "GetScope", "(", "name", ")", "\n", "statusVars", "[", "name", "]", "=", "&", "StatusVal", "{", "Value", ":", "val", ",", "Scope", ":", "scope", "}", "\n", "}", "\n", "}", "\n\n", "return", "statusVars", ",", "nil", "\n", "}" ]

[ "GetStatusVars", "gets", "registered", "statistics", "status", "variables", "." ]

[ "func", "tryToGetJoinGroup", "(", "j", "*", "Join", ")", "(", "[", "]", "LogicalPlan", ",", "bool", ")", "{", "if", "j", ".", "reordered", "||", "!", "j", ".", "cartesianJoin", "{", "return", "nil", ",", "false", "\n", "}", "\n", "lChild", ":=", "j", ".", "GetChildByIndex", "(", "0", ")", ".", "(", "LogicalPlan", ")", "\n", "rChild", ":=", "j", ".", "GetChildByIndex", "(", "1", ")", ".", "(", "LogicalPlan", ")", "\n", "if", "nj", ",", "ok", ":=", "lChild", ".", "(", "*", "Join", ")", ";", "ok", "{", "plans", ",", "valid", ":=", "tryToGetJoinGroup", "(", "nj", ")", "\n", "return", "append", "(", "plans", ",", "rChild", ")", ",", "valid", "\n", "}", "\n", "return", "[", "]", "LogicalPlan", "{", "lChild", ",", "rChild", "}", ",", "true", "\n", "}" ]

[ "tryToGetJoinGroup", "tries", "to", "fetch", "a", "whole", "join", "group", "which", "all", "joins", "is", "cartesian", "join", "." ]

[ "func", "(", "e", "*", "joinReOrderSolver", ")", "walkGraphAndComposeJoin", "(", "u", "int", ")", "{", "e", ".", "visited", "[", "u", "]", "=", "true", "\n", "for", "_", ",", "edge", ":=", "range", "e", ".", "graph", "[", "u", "]", "{", "v", ":=", "edge", ".", "nodeID", "\n", "if", "!", "e", ".", "visited", "[", "v", "]", "{", "e", ".", "resultJoin", "=", "e", ".", "newJoin", "(", "e", ".", "resultJoin", ",", "e", ".", "group", "[", "v", "]", ")", "\n", "e", ".", "walkGraphAndComposeJoin", "(", "v", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "walkGraph", "implements", "a", "dfs", "algorithm", ".", "Each", "time", "it", "picks", "a", "edge", "with", "lowest", "rate", "which", "has", "been", "sorted", "before", "." ]

[ "func", "FindCols", "(", "cols", "[", "]", "*", "Column", ",", "names", "[", "]", "string", ")", "(", "[", "]", "*", "Column", ",", "error", ")", "{", "var", "rcols", "[", "]", "*", "Column", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "col", ":=", "FindCol", "(", "cols", ",", "name", ")", "\n", "if", "col", "!=", "nil", "{", "rcols", "=", "append", "(", "rcols", ",", "col", ")", "\n", "}", "else", "{", "return", "nil", ",", "errUnknownColumn", ".", "Gen", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "}", "\n\n", "return", "rcols", ",", "nil", "\n", "}" ]

[ "FindCols", "finds", "columns", "in", "cols", "by", "names", "." ]

[ "func", "CheckOnce", "(", "cols", "[", "]", "*", "Column", ")", "error", "{", "m", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "}", "\n", "for", "_", ",", "col", ":=", "range", "cols", "{", "name", ":=", "col", ".", "Name", "\n", "_", ",", "ok", ":=", "m", "[", "name", ".", "L", "]", "\n", "if", "ok", "{", "return", "errDuplicateColumn", ".", "Gen", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n\n", "m", "[", "name", ".", "L", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "CheckOnce", "checks", "if", "there", "are", "duplicated", "column", "names", "in", "cols", "." ]

[ "func", "(", "r", "*", "rangeBuilder", ")", "buildIndexRanges", "(", "rangePoints", "[", "]", "rangePoint", ",", "tp", "*", "types", ".", "FieldType", ")", "[", "]", "*", "IndexRange", "{", "indexRanges", ":=", "make", "(", "[", "]", "*", "IndexRange", ",", "0", ",", "len", "(", "rangePoints", ")", "/", "2", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "rangePoints", ")", ";", "i", "+=", "2", "{", "startPoint", ":=", "r", ".", "convertPoint", "(", "rangePoints", "[", "i", "]", ",", "tp", ")", "\n", "endPoint", ":=", "r", ".", "convertPoint", "(", "rangePoints", "[", "i", "+", "1", "]", ",", "tp", ")", "\n", "less", ",", "err", ":=", "rangePointLess", "(", "r", ".", "sc", ",", "startPoint", ",", "endPoint", ")", "\n", "if", "err", "!=", "nil", "{", "r", ".", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "less", "{", "continue", "\n", "}", "\n", "ir", ":=", "&", "IndexRange", "{", "LowVal", ":", "[", "]", "types", ".", "Datum", "{", "startPoint", ".", "value", "}", ",", "LowExclude", ":", "startPoint", ".", "excl", ",", "HighVal", ":", "[", "]", "types", ".", "Datum", "{", "endPoint", ".", "value", "}", ",", "HighExclude", ":", "endPoint", ".", "excl", ",", "}", "\n", "indexRanges", "=", "append", "(", "indexRanges", ",", "ir", ")", "\n", "}", "\n", "return", "indexRanges", "\n", "}" ]

[ "buildIndexRanges", "build", "index", "ranges", "from", "range", "points", ".", "Only", "the", "first", "column", "in", "the", "index", "is", "built", "extra", "column", "ranges", "will", "be", "appended", "by", "appendIndexRanges", "." ]

[ "func", "(", "fs", "*", "FileSorter", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "l", ":=", "fs", ".", "buf", "[", "i", "]", ".", "key", "\n", "r", ":=", "fs", ".", "buf", "[", "j", "]", ".", "key", "\n", "ret", ",", "err", ":=", "lessThan", "(", "fs", ".", "sc", ",", "l", ",", "r", ",", "fs", ".", "byDesc", ")", "\n", "if", "fs", ".", "err", "==", "nil", "{", "fs", ".", "err", "=", "err", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Less", "implements", "sort", ".", "Interface", "Less", "interface", "." ]

[ "func", "(", "fs", "*", "FileSorter", ")", "flushToFile", "(", ")", "error", "{", "var", "(", "err", "error", "\n", "outputFile", "*", "os", ".", "File", "\n", "outputByte", "[", "]", "byte", "\n", ")", "\n\n", "sort", ".", "Sort", "(", "fs", ")", "\n", "if", "fs", ".", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "fs", ".", "err", ")", "\n", "}", "\n\n", "fileName", ":=", "fs", ".", "getUniqueFileName", "(", ")", "\n\n", "outputFile", ",", "err", "=", "os", ".", "OpenFile", "(", "fileName", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", ",", "0600", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "defer", "outputFile", ".", "Close", "(", ")", "\n\n", "for", "_", ",", "row", ":=", "range", "fs", ".", "buf", "{", "var", "body", "[", "]", "byte", "\n", "var", "head", "=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n\n", "body", ",", "err", "=", "codec", ".", "EncodeKey", "(", "body", ",", "row", ".", "key", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "body", ",", "err", "=", "codec", ".", "EncodeKey", "(", "body", ",", "row", ".", "val", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "body", ",", "err", "=", "codec", ".", "EncodeKey", "(", "body", ",", "types", ".", "NewIntDatum", "(", "row", ".", "handle", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "binary", ".", "BigEndian", ".", "PutUint64", "(", "head", ",", "uint64", "(", "len", "(", "body", ")", ")", ")", "\n\n", "outputByte", "=", "append", "(", "outputByte", ",", "head", "...", ")", "\n", "outputByte", "=", "append", "(", "outputByte", ",", "body", "...", ")", "\n", "}", "\n\n", "_", ",", "err", "=", "outputFile", ".", "Write", "(", "outputByte", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "fs", ".", "files", "=", "append", "(", "fs", ".", "files", ",", "fileName", ")", "\n", "fs", ".", "buf", "=", "fs", ".", "buf", "[", ":", "0", "]", "\n", "return", "nil", "\n", "}" ]

[ "Flush", "the", "buffer", "to", "file", "if", "it", "is", "full", "." ]

[ "func", "(", "fs", "*", "FileSorter", ")", "fetchNextRow", "(", "index", "int", ")", "(", "*", "comparableRow", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "n", "int", "\n", "head", "=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "dcod", "=", "make", "(", "[", "]", "types", ".", "Datum", ",", "0", ",", "fs", ".", "keySize", "+", "fs", ".", "valSize", "+", "1", ")", "\n", ")", "\n", "n", ",", "err", "=", "fs", ".", "fds", "[", "index", "]", ".", "Read", "(", "head", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "n", "!=", "8", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "rowSize", ":=", "int", "(", "binary", ".", "BigEndian", ".", "Uint64", "(", "head", ")", ")", "\n\n", "rowBytes", ":=", "make", "(", "[", "]", "byte", ",", "rowSize", ")", "\n\n", "n", ",", "err", "=", "fs", ".", "fds", "[", "index", "]", ".", "Read", "(", "rowBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "n", "!=", "rowSize", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "dcod", ",", "err", "=", "codec", ".", "Decode", "(", "rowBytes", ",", "fs", ".", "keySize", "+", "fs", ".", "valSize", "+", "1", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "comparableRow", "{", "key", ":", "dcod", "[", ":", "fs", ".", "keySize", "]", ",", "val", ":", "dcod", "[", "fs", ".", "keySize", ":", "fs", ".", "keySize", "+", "fs", ".", "valSize", "]", ",", "handle", ":", "dcod", "[", "fs", ".", "keySize", "+", "fs", ".", "valSize", ":", "]", "[", "0", "]", ".", "GetInt64", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "Fetch", "the", "next", "row", "given", "the", "source", "file", "index", "." ]

[ "func", "(", "fs", "*", "FileSorter", ")", "externalSort", "(", ")", "(", "*", "comparableRow", ",", "error", ")", "{", "if", "!", "fs", ".", "fetched", "{", "if", "len", "(", "fs", ".", "buf", ")", ">", "0", "{", "err", ":=", "fs", ".", "flushToFile", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n\n", "heap", ".", "Init", "(", "fs", ".", "rowHeap", ")", "\n", "if", "fs", ".", "rowHeap", ".", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "fs", ".", "rowHeap", ".", "err", ")", "\n", "}", "\n\n", "err", ":=", "fs", ".", "openAllFiles", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n\n", "for", "id", ":=", "range", "fs", ".", "fds", "{", "row", ",", "err", ":=", "fs", ".", "fetchNextRow", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "row", "==", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "im", ":=", "&", "item", "{", "index", ":", "id", ",", "value", ":", "row", ",", "}", "\n\n", "heap", ".", "Push", "(", "fs", ".", "rowHeap", ",", "im", ")", "\n", "if", "fs", ".", "rowHeap", ".", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "fs", ".", "rowHeap", ".", "err", ")", "\n", "}", "\n", "}", "\n\n", "fs", ".", "fetched", "=", "true", "\n", "}", "\n\n", "if", "fs", ".", "rowHeap", ".", "Len", "(", ")", ">", "0", "{", "im", ":=", "heap", ".", "Pop", "(", "fs", ".", "rowHeap", ")", ".", "(", "*", "item", ")", "\n", "if", "fs", ".", "rowHeap", ".", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "fs", ".", "rowHeap", ".", "err", ")", "\n", "}", "\n\n", "row", ",", "err", ":=", "fs", ".", "fetchNextRow", "(", "im", ".", "index", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "row", "!=", "nil", "{", "im", ":=", "&", "item", "{", "index", ":", "im", ".", "index", ",", "value", ":", "row", ",", "}", "\n\n", "heap", ".", "Push", "(", "fs", ".", "rowHeap", ",", "im", ")", "\n", "if", "fs", ".", "rowHeap", ".", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "fs", ".", "rowHeap", ".", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "im", ".", "value", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Perform", "external", "file", "sort", "." ]

[ "func", "(", "h", "Hex", ")", "ToString", "(", ")", "string", "{", "s", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Value", ")", "\n", "if", "len", "(", "s", ")", "%", "2", "!=", "0", "{", "s", "=", "\"", "\"", "+", "s", "\n", "}", "\n\n", "// should never error.", "b", ",", "_", ":=", "hex", ".", "DecodeString", "(", "s", ")", "\n", "return", "string", "(", "b", ")", "\n", "}" ]

[ "ToString", "returns", "the", "string", "representation", "for", "hexadecimal", "literal", "." ]

[ "func", "(", "a", "*", "Statement", ")", "Exec", "(", "ctx", "context", ".", "Context", ")", "(", "*", "flow", ".", "Dataset", ",", "error", ")", "{", "a", ".", "startTime", "=", "time", ".", "Now", "(", ")", "\n\n", "b", ":=", "newExecutorBuilder", "(", "ctx", ",", "a", ".", "InfoSchema", ")", "\n\n", "exe", ":=", "b", ".", "build", "(", "a", ".", "Plan", ")", "\n", "if", "b", ".", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "b", ".", "err", ")", "\n", "}", "\n\n", "if", "exe", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "plan", ".", "ToString", "(", "a", ".", "Plan", ")", ")", "\n", "}", "\n\n", "return", "exe", ".", "Exec", "(", ")", ",", "nil", "\n", "}" ]

[ "Exec", "implements", "the", "ast", ".", "Statement", "Exec", "interface", ".", "This", "function", "builds", "an", "Executor", "from", "a", "plan", ".", "If", "the", "Executor", "doesn", "t", "return", "result", "like", "the", "INSERT", "UPDATE", "statements", "it", "executes", "in", "this", "function", "if", "the", "Executor", "returns", "result", "execution", "is", "done", "after", "this", "function", "returns", "in", "the", "returned", "ast", ".", "RecordSet", "Next", "method", "." ]

[ "func", "(", "this", "*", "Dataset", ")", "Union", "(", "name", "string", ",", "others", "[", "]", "*", "Dataset", ",", "isParallel", "bool", ")", "*", "Dataset", "{", "ret", ":=", "this", ".", "Flow", ".", "NewNextDataset", "(", "len", "(", "this", ".", "Shards", ")", ")", "\n", "inputs", ":=", "[", "]", "*", "Dataset", "{", "this", "}", "\n", "inputs", "=", "append", "(", "inputs", ",", "others", "...", ")", "\n", "step", ":=", "this", ".", "Flow", ".", "MergeDatasets1ShardTo1Step", "(", "inputs", ",", "ret", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewUnion", "(", "isParallel", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "Union", "union", "multiple", "Datasets", "as", "one", "Dataset" ]

[ "func", "(", "as", "*", "AgentServer", ")", "Cleanup", "(", "ctx", "context", ".", "Context", ",", "cleanupRequest", "*", "pb", ".", "CleanupRequest", ")", "(", "*", "pb", ".", "CleanupResponse", ",", "error", ")", "{", "log", ".", "Println", "(", "\"", "\"", ",", "cleanupRequest", ".", "GetFlowHashCode", "(", ")", ")", "\n", "dir", ":=", "path", ".", "Join", "(", "*", "as", ".", "Option", ".", "Dir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "cleanupRequest", ".", "GetFlowHashCode", "(", ")", ")", ")", "\n", "os", ".", "RemoveAll", "(", "dir", ")", "\n\n", "return", "&", "pb", ".", "CleanupResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "Cleanup", "remove", "all", "files", "related", "to", "a", "particular", "flow" ]

[ "func", "(", "as", "*", "AgentServer", ")", "Execute", "(", "request", "*", "pb", ".", "ExecutionRequest", ",", "stream", "pb", ".", "GleamAgent_ExecuteServer", ")", "error", "{", "dir", ":=", "path", ".", "Join", "(", "*", "as", ".", "Option", ".", "Dir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "request", ".", "GetInstructionSet", "(", ")", ".", "GetFlowHashCode", "(", ")", ")", ",", "request", ".", "GetDir", "(", ")", ")", "\n", "os", ".", "MkdirAll", "(", "dir", ",", "0755", ")", "\n\n", "allocated", ":=", "*", "request", ".", "GetResource", "(", ")", "\n\n", "as", ".", "plusAllocated", "(", "allocated", ")", "\n", "defer", "as", ".", "minusAllocated", "(", "allocated", ")", "\n\n", "request", ".", "InstructionSet", ".", "AgentAddress", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "*", "as", ".", "Option", ".", "Host", ",", "*", "as", ".", "Option", ".", "Port", ")", "\n\n", "statsChan", ":=", "createStatsChanByInstructionSet", "(", "request", ".", "InstructionSet", ")", "\n\n", "defer", "deleteStatsChanByInstructionSet", "(", "request", ".", "InstructionSet", ")", "\n\n", "return", "as", ".", "executeCommand", "(", "stream", ",", "request", ",", "dir", ",", "statsChan", ")", "\n\n", "}" ]

[ "Execute", "executes", "a", "request", "and", "stream", "stdout", "and", "stderr", "back" ]

[ "func", "(", "as", "*", "AgentServer", ")", "CollectExecutionStatistics", "(", "stream", "pb", ".", "GleamAgent_CollectExecutionStatisticsServer", ")", "error", "{", "var", "statsChan", "chan", "*", "pb", ".", "ExecutionStat", "\n\n", "for", "{", "stats", ",", "err", ":=", "stream", ".", "Recv", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "statsChan", "==", "nil", "{", "statsChan", "=", "getStatsChan", "(", "stats", ".", "FlowHashCode", ",", "stats", ".", "Stats", "[", "0", "]", ".", "GetStepId", "(", ")", ",", "stats", ".", "Stats", "[", "0", "]", ".", "GetTaskId", "(", ")", ")", "\n", "}", "\n\n", "statsChan", "<-", "stats", "\n", "// fmt.Printf(\"received stats: %+v\\n\", stats)", "}", "\n\n", "}" ]

[ "Collect", "stat", "from", "gleam", "execute", "process" ]

[ "func", "(", "as", "*", "AgentServer", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "deleteRequest", "*", "pb", ".", "DeleteDatasetShardRequest", ")", "(", "*", "pb", ".", "DeleteDatasetShardResponse", ",", "error", ")", "{", "log", ".", "Println", "(", "\"", "\"", ",", "deleteRequest", ".", "Name", ")", "\n", "as", ".", "storageBackend", ".", "DeleteNamedDatasetShard", "(", "deleteRequest", ".", "Name", ")", "\n", "as", ".", "inMemoryChannels", ".", "Cleanup", "(", "deleteRequest", ".", "Name", ")", "\n\n", "return", "&", "pb", ".", "DeleteDatasetShardResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "Delete", "deletes", "a", "particular", "dataset", "shard" ]

[ "func", "collectStepOutputDatasetSize", "(", "status", "*", "pb", ".", "FlowExecutionStatus", ",", "stepId", "int32", ")", "(", "counter", "int64", ")", "{", "for", "_", ",", "tg", ":=", "range", "status", ".", "TaskGroups", "{", "for", "_", ",", "execution", ":=", "range", "tg", ".", "Executions", "{", "if", "execution", ".", "ExecutionStat", "==", "nil", "{", "continue", "\n", "}", "\n", "for", "_", ",", "stat", ":=", "range", "execution", ".", "ExecutionStat", ".", "Stats", "{", "if", "stat", ".", "StepId", "==", "stepId", "{", "counter", "+=", "stat", ".", "OutputCounter", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "counter", "\n", "}" ]

[ "may", "be", "more", "efficient", "to", "map", "stepId", "=", ">", "size" ]

[ "func", "DateDiff", "(", "startTime", ",", "endTime", "TimeInternal", ")", "int", "{", "return", "calcDaynr", "(", "startTime", ".", "Year", "(", ")", ",", "startTime", ".", "Month", "(", ")", ",", "startTime", ".", "Day", "(", ")", ")", "-", "calcDaynr", "(", "endTime", ".", "Year", "(", ")", ",", "endTime", ".", "Month", "(", ")", ",", "endTime", ".", "Day", "(", ")", ")", "\n", "}" ]

[ "DateDiff", "calculates", "number", "of", "days", "between", "two", "days", "." ]

[ "func", "compilePattern", "(", "pattern", "string", ",", "escape", "byte", ")", "(", "patChars", ",", "patTypes", "[", "]", "byte", ")", "{", "var", "lastAny", "bool", "\n", "patChars", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "pattern", ")", ")", "\n", "patTypes", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "pattern", ")", ")", "\n", "patLen", ":=", "0", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "pattern", ")", ";", "i", "++", "{", "var", "tp", "byte", "\n", "var", "c", "=", "pattern", "[", "i", "]", "\n", "switch", "c", "{", "case", "escape", ":", "lastAny", "=", "false", "\n", "tp", "=", "patMatch", "\n", "if", "i", "<", "len", "(", "pattern", ")", "-", "1", "{", "i", "++", "\n", "c", "=", "pattern", "[", "i", "]", "\n", "if", "c", "==", "escape", "||", "c", "==", "'_'", "||", "c", "==", "'%'", "{", "// valid escape.", "}", "else", "{", "// invalid escape, fall back to escape byte", "// mysql will treat escape character as the origin value even", "// the escape sequence is invalid in Go or C.", "// e.g, \\m is invalid in Go, but in MySQL we will get \"m\" for select '\\m'.", "// Following case is correct just for escape \\, not for others like +.", "// TODO: add more checks for other escapes.", "i", "--", "\n", "c", "=", "escape", "\n", "}", "\n", "}", "\n", "case", "'_'", ":", "lastAny", "=", "false", "\n", "tp", "=", "patOne", "\n", "case", "'%'", ":", "if", "lastAny", "{", "continue", "\n", "}", "\n", "lastAny", "=", "true", "\n", "tp", "=", "patAny", "\n", "default", ":", "lastAny", "=", "false", "\n", "tp", "=", "patMatch", "\n", "}", "\n", "patChars", "[", "patLen", "]", "=", "c", "\n", "patTypes", "[", "patLen", "]", "=", "tp", "\n", "patLen", "++", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "patLen", "-", "1", ";", "i", "++", "{", "if", "(", "patTypes", "[", "i", "]", "==", "patAny", ")", "&&", "(", "patTypes", "[", "i", "+", "1", "]", "==", "patOne", ")", "{", "patTypes", "[", "i", "]", "=", "patOne", "\n", "patTypes", "[", "i", "+", "1", "]", "=", "patAny", "\n", "}", "\n", "}", "\n", "patChars", "=", "patChars", "[", ":", "patLen", "]", "\n", "patTypes", "=", "patTypes", "[", ":", "patLen", "]", "\n", "return", "\n", "}" ]

[ "Handle", "escapes", "and", "wild", "cards", "convert", "pattern", "characters", "and", "pattern", "types", "." ]

[ "func", "peek", "(", "b", "[", "]", "byte", ")", "(", "length", "int", ",", "err", "error", ")", "{", "if", "len", "(", "b", ")", "<", "1", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "flag", ":=", "b", "[", "0", "]", "\n", "length", "++", "\n", "b", "=", "b", "[", "1", ":", "]", "\n", "var", "l", "int", "\n", "switch", "flag", "{", "case", "NilFlag", ":", "case", "intFlag", ",", "uintFlag", ",", "floatFlag", ",", "durationFlag", ":", "// Those types are stored in 8 bytes.", "l", "=", "8", "\n", "case", "bytesFlag", ":", "l", ",", "err", "=", "peekBytes", "(", "b", ",", "false", ")", "\n", "case", "compactBytesFlag", ":", "l", ",", "err", "=", "peekCompactBytes", "(", "b", ")", "\n", "case", "decimalFlag", ":", "l", ",", "err", "=", "types", ".", "DecimalPeak", "(", "b", ")", "\n", "case", "varintFlag", ":", "l", ",", "err", "=", "peekVarint", "(", "b", ")", "\n", "case", "uvarintFlag", ":", "l", ",", "err", "=", "peekUvarint", "(", "b", ")", "\n", "default", ":", "return", "0", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "flag", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "length", "+=", "l", "\n", "return", "\n", "}" ]

[ "peeks", "the", "first", "encoded", "value", "from", "b", "and", "returns", "its", "length", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Hint", "(", "options", "...", "DasetsetHint", ")", "*", "Dataset", "{", "for", "_", ",", "option", ":=", "range", "options", "{", "option", "(", "d", ")", "\n", "}", "\n", "return", "d", "\n", "}" ]

[ "Hint", "adds", "options", "for", "previous", "dataset", "." ]

[ "func", "TotalSize", "(", "n", "int64", ")", "DasetsetHint", "{", "return", "func", "(", "d", "*", "Dataset", ")", "{", "d", ".", "Meta", ".", "TotalSize", "=", "n", "\n", "}", "\n", "}" ]

[ "TotalSize", "hints", "the", "total", "size", "in", "MB", "for", "all", "the", "partitions", ".", "This", "is", "usually", "used", "when", "sorting", "is", "needed", "." ]

[ "func", "PartitionSize", "(", "n", "int64", ")", "DasetsetHint", "{", "return", "func", "(", "d", "*", "Dataset", ")", "{", "d", ".", "Meta", ".", "TotalSize", "=", "n", "*", "int64", "(", "len", "(", "d", ".", "GetShards", "(", ")", ")", ")", "\n", "}", "\n", "}" ]

[ "PartitionSize", "hints", "the", "partition", "size", "in", "MB", ".", "This", "is", "usually", "used", "when", "sorting", "is", "needed", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "OnDisk", "(", "fn", "func", "(", "*", "Dataset", ")", "*", "Dataset", ")", "*", "Dataset", "{", "ret", ":=", "fn", "(", "d", ")", "\n\n", "var", "parents", ",", "currents", "[", "]", "*", "Dataset", "\n", "currents", "=", "append", "(", "currents", ",", "ret", ")", "\n", "for", "{", "for", "_", ",", "t", ":=", "range", "currents", "{", "isFirstDataset", ",", "isLastDataset", ":=", "false", ",", "false", "\n", "if", "t", "==", "ret", "{", "isLastDataset", "=", "true", "\n", "}", "else", "if", "t", ".", "Step", ".", "OutputDataset", "!=", "nil", "{", "t", ".", "Step", ".", "OutputDataset", ".", "Meta", ".", "OnDisk", "=", "ModeOnDisk", "\n", "}", "\n", "for", "_", ",", "p", ":=", "range", "t", ".", "Step", ".", "InputDatasets", "{", "if", "p", "!=", "d", "{", "parents", "=", "append", "(", "parents", ",", "p", ")", "\n", "}", "else", "{", "isFirstDataset", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "isFirstDataset", "&&", "!", "isLastDataset", "{", "t", ".", "Step", ".", "Meta", ".", "IsRestartable", "=", "true", "\n", "}", "\n", "}", "\n", "if", "len", "(", "parents", ")", "==", "0", "{", "break", "\n", "}", "\n", "currents", "=", "parents", "\n", "parents", "=", "nil", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "OnDisk", "ensure", "the", "intermediate", "dataset", "are", "persisted", "to", "disk", ".", "This", "allows", "executors", "to", "run", "not", "in", "parallel", "if", "executors", "are", "limited", "." ]

[ "func", "(", "n", "*", "AdminStmt", ")", "Accept", "(", "v", "Visitor", ")", "(", "Node", ",", "bool", ")", "{", "newNode", ",", "skipChildren", ":=", "v", ".", "Enter", "(", "n", ")", "\n", "if", "skipChildren", "{", "return", "v", ".", "Leave", "(", "newNode", ")", "\n", "}", "\n\n", "n", "=", "newNode", ".", "(", "*", "AdminStmt", ")", "\n", "for", "i", ",", "val", ":=", "range", "n", ".", "Tables", "{", "node", ",", "ok", ":=", "val", ".", "Accept", "(", "v", ")", "\n", "if", "!", "ok", "{", "return", "n", ",", "false", "\n", "}", "\n", "n", ".", "Tables", "[", "i", "]", "=", "node", ".", "(", "*", "TableName", ")", "\n", "}", "\n\n", "return", "v", ".", "Leave", "(", "n", ")", "\n", "}" ]

[ "Accept", "implements", "Node", "Accpet", "interface", "." ]

[ "func", "(", "i", "Ident", ")", "Full", "(", "ctx", "context", ".", "Context", ")", "(", "full", "Ident", ")", "{", "full", ".", "Name", "=", "i", ".", "Name", "\n", "if", "i", ".", "Schema", ".", "O", "!=", "\"", "\"", "{", "full", ".", "Schema", "=", "i", ".", "Schema", "\n", "}", "else", "{", "full", ".", "Schema", "=", "model", ".", "NewCIStr", "(", "ctx", ".", "GetSessionVars", "(", ")", ".", "CurrentDB", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "Full", "returns", "an", "Ident", "which", "set", "schema", "to", "the", "current", "schema", "if", "it", "is", "empty", "." ]