Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "vtg", "*", "VTGate", ")", "MessageAck", "(", "ctx", "context", ".", "Context", ",", "request", "*", "vtgatepb", ".", "MessageAckRequest", ")", "(", "response", "*", "querypb", ".", "MessageAckResponse", ",", "err", "error", ")", "{", "defer", "vtg", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "withCallerIDContext", "(", "ctx", ",", "request", ".", "CallerId", ")", "\n", "count", ",", "vtgErr", ":=", "vtg", ".", "server", ".", "MessageAck", "(", "ctx", ",", "request", ".", "Keyspace", ",", "request", ".", "Name", ",", "request", ".", "Ids", ")", "\n", "if", "vtgErr", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "vtgErr", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "MessageAckResponse", "{", "Result", ":", "&", "querypb", ".", "QueryResult", "{", "RowsAffected", ":", "uint64", "(", "count", ")", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "MessageAck", "is", "the", "RPC", "version", "of", "vtgateservice", ".", "VTGateService", "method" ]

[ "func", "(", "vtg", "*", "VTGate", ")", "SplitQuery", "(", "ctx", "context", ".", "Context", ",", "request", "*", "vtgatepb", ".", "SplitQueryRequest", ")", "(", "response", "*", "vtgatepb", ".", "SplitQueryResponse", ",", "err", "error", ")", "{", "defer", "vtg", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "withCallerIDContext", "(", "ctx", ",", "request", ".", "CallerId", ")", "\n", "splits", ",", "vtgErr", ":=", "vtg", ".", "server", ".", "SplitQuery", "(", "ctx", ",", "request", ".", "Keyspace", ",", "request", ".", "Query", ".", "Sql", ",", "request", ".", "Query", ".", "BindVariables", ",", "request", ".", "SplitColumn", ",", "request", ".", "SplitCount", ",", "request", ".", "NumRowsPerQueryPart", ",", "request", ".", "Algorithm", ")", "\n", "if", "vtgErr", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "vtgErr", ")", "\n", "}", "\n", "return", "&", "vtgatepb", ".", "SplitQueryResponse", "{", "Splits", ":", "splits", ",", "}", ",", "nil", "\n", "}" ]

[ "SplitQuery", "is", "the", "RPC", "version", "of", "vtgateservice", ".", "VTGateService", "method" ]

[ "func", "(", "vtg", "*", "VTGate", ")", "GetSrvKeyspace", "(", "ctx", "context", ".", "Context", ",", "request", "*", "vtgatepb", ".", "GetSrvKeyspaceRequest", ")", "(", "response", "*", "vtgatepb", ".", "GetSrvKeyspaceResponse", ",", "err", "error", ")", "{", "defer", "vtg", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "sk", ",", "vtgErr", ":=", "vtg", ".", "server", ".", "GetSrvKeyspace", "(", "ctx", ",", "request", ".", "Keyspace", ")", "\n", "if", "vtgErr", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "vtgErr", ")", "\n", "}", "\n", "return", "&", "vtgatepb", ".", "GetSrvKeyspaceResponse", "{", "SrvKeyspace", ":", "sk", ",", "}", ",", "nil", "\n", "}" ]

[ "GetSrvKeyspace", "is", "the", "RPC", "version", "of", "vtgateservice", ".", "VTGateService", "method" ]

[ "func", "(", "vtg", "*", "VTGate", ")", "UpdateStream", "(", "request", "*", "vtgatepb", ".", "UpdateStreamRequest", ",", "stream", "vtgateservicepb", ".", "Vitess_UpdateStreamServer", ")", "(", "err", "error", ")", "{", "defer", "vtg", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "withCallerIDContext", "(", "stream", ".", "Context", "(", ")", ",", "request", ".", "CallerId", ")", "\n", "vtgErr", ":=", "vtg", ".", "server", ".", "UpdateStream", "(", "ctx", ",", "request", ".", "Keyspace", ",", "request", ".", "Shard", ",", "request", ".", "KeyRange", ",", "request", ".", "TabletType", ",", "request", ".", "Timestamp", ",", "request", ".", "Event", ",", "func", "(", "event", "*", "querypb", ".", "StreamEvent", ",", "resumeTimestamp", "int64", ")", "error", "{", "// Send is not safe to call concurrently, but vtgate", "// guarantees that it's not.", "return", "stream", ".", "Send", "(", "&", "vtgatepb", ".", "UpdateStreamResponse", "{", "Event", ":", "event", ",", "ResumeTimestamp", ":", "resumeTimestamp", ",", "}", ")", "\n", "}", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "vtgErr", ")", "\n", "}" ]

[ "UpdateStream", "is", "the", "RPC", "version", "of", "vtgateservice", ".", "VTGateService", "method" ]

[ "func", "(", "dbc", "*", "DBConnection", ")", "ExecuteFetch", "(", "query", "string", ",", "maxrows", "int", ",", "wantfields", "bool", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "defer", "dbc", ".", "mysqlStats", ".", "Record", "(", "\"", "\"", ",", "time", ".", "Now", "(", ")", ")", "\n", "mqr", ",", "err", ":=", "dbc", ".", "Conn", ".", "ExecuteFetch", "(", "query", ",", "maxrows", ",", "wantfields", ")", "\n", "if", "err", "!=", "nil", "{", "dbc", ".", "handleError", "(", "err", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "mqr", ",", "nil", "\n", "}" ]

[ "ExecuteFetch", "overwrites", "mysql", ".", "Conn", ".", "ExecuteFetch", "." ]

[ "func", "(", "dbc", "*", "DBConnection", ")", "ExecuteStreamFetch", "(", "query", "string", ",", "callback", "func", "(", "*", "sqltypes", ".", "Result", ")", "error", ",", "streamBufferSize", "int", ")", "error", "{", "defer", "dbc", ".", "mysqlStats", ".", "Record", "(", "\"", "\"", ",", "time", ".", "Now", "(", ")", ")", "\n\n", "err", ":=", "dbc", ".", "Conn", ".", "ExecuteStreamFetch", "(", "query", ")", "\n", "if", "err", "!=", "nil", "{", "dbc", ".", "handleError", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "defer", "dbc", ".", "CloseResult", "(", ")", "\n\n", "// first call the callback with the fields", "flds", ",", "err", ":=", "dbc", ".", "Fields", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "err", "=", "callback", "(", "&", "sqltypes", ".", "Result", "{", "Fields", ":", "flds", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "// then get all the rows, sending them as we reach a decent packet size", "// start with a pre-allocated array of 256 rows capacity", "qr", ":=", "&", "sqltypes", ".", "Result", "{", "Rows", ":", "make", "(", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "0", ",", "256", ")", "}", "\n", "byteCount", ":=", "0", "\n", "for", "{", "row", ",", "err", ":=", "dbc", ".", "FetchNext", "(", ")", "\n", "if", "err", "!=", "nil", "{", "dbc", ".", "handleError", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "if", "row", "==", "nil", "{", "break", "\n", "}", "\n", "qr", ".", "Rows", "=", "append", "(", "qr", ".", "Rows", ",", "row", ")", "\n", "for", "_", ",", "s", ":=", "range", "row", "{", "byteCount", "+=", "s", ".", "Len", "(", ")", "\n", "}", "\n\n", "if", "byteCount", ">=", "streamBufferSize", "{", "err", "=", "callback", "(", "qr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// empty the rows so we start over, but we keep the", "// same capacity", "qr", ".", "Rows", "=", "qr", ".", "Rows", "[", ":", "0", "]", "\n", "byteCount", "=", "0", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "qr", ".", "Rows", ")", ">", "0", "{", "err", "=", "callback", "(", "qr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ExecuteStreamFetch", "overwrites", "mysql", ".", "Conn", ".", "ExecuteStreamFetch", "." ]

[ "func", "NewDBConnection", "(", "info", "*", "mysql", ".", "ConnParams", ",", "mysqlStats", "*", "stats", ".", "Timings", ")", "(", "*", "DBConnection", ",", "error", ")", "{", "start", ":=", "time", ".", "Now", "(", ")", "\n", "defer", "mysqlStats", ".", "Record", "(", "\"", "\"", ",", "start", ")", "\n", "params", ",", "err", ":=", "dbconfigs", ".", "WithCredentials", "(", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ctx", ":=", "context", ".", "Background", "(", ")", "\n", "c", ",", "err", ":=", "mysql", ".", "Connect", "(", "ctx", ",", "params", ")", "\n", "if", "err", "!=", "nil", "{", "mysqlStats", ".", "Record", "(", "\"", "\"", ",", "start", ")", "\n", "}", "\n", "return", "&", "DBConnection", "{", "c", ",", "mysqlStats", "}", ",", "err", "\n", "}" ]

[ "NewDBConnection", "returns", "a", "new", "DBConnection", "based", "on", "the", "ConnParams", "and", "will", "use", "the", "provided", "stats", "to", "collect", "timing", "." ]

[ "func", "(", "tt", "*", "timeoutThread", ")", "waitForEntry", "(", "e", "*", "entry", ")", "bool", "{", "windowExceeded", ":=", "time", ".", "NewTimer", "(", "time", ".", "Until", "(", "e", ".", "deadline", ")", ")", "\n", "defer", "windowExceeded", ".", "Stop", "(", ")", "\n\n", "select", "{", "// a) Always check these channels, regardless of the state.", "case", "<-", "tt", ".", "maxDuration", ".", "C", ":", "// Max duration is up. Stop buffering. Do not error out entries explicitly.", "tt", ".", "sb", ".", "stopBufferingDueToMaxDuration", "(", ")", "\n", "return", "true", "\n", "case", "<-", "tt", ".", "stopChan", ":", "// Failover ended before timeout. Do nothing.", "return", "true", "\n", "// b) Entry-specific checks.", "case", "<-", "e", ".", "done", ":", "// Entry was drained or evicted. Get the next entry.", "return", "false", "\n", "// NOTE: We're not waiting for e.bufferCtx here (which triggers when the", "// request was externally aborted e.g. due to context canceled) because then", "// this thread would race with the request thread which runs", "// shardBuffer.remove(). Instead, remove() will notify us here eventually by", "// closing \"e.done\".", "case", "<-", "windowExceeded", ".", "C", ":", "// Entry expired. Evict it and then get the next entry.", "tt", ".", "sb", ".", "evictOldestEntry", "(", "e", ")", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "waitForEntry", "blocks", "until", "e", "exceeds", "its", "buffering", "window", "or", "buffering", "stops", "in", "general", ".", "It", "returns", "true", "if", "the", "timeout", "thread", "should", "stop", "." ]

[ "func", "(", "tt", "*", "timeoutThread", ")", "waitForNonEmptyQueue", "(", ")", "bool", "{", "tt", ".", "mu", ".", "Lock", "(", ")", "\n", "queueNotEmpty", ":=", "tt", ".", "queueNotEmpty", "\n", "tt", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "select", "{", "// a) Always check these channels, regardless of the state.", "case", "<-", "tt", ".", "maxDuration", ".", "C", ":", "// Max duration is up. Stop buffering. Do not error out entries explicitly.", "tt", ".", "sb", ".", "stopBufferingDueToMaxDuration", "(", ")", "\n", "return", "true", "\n", "case", "<-", "tt", ".", "stopChan", ":", "// Failover ended before timeout. Do nothing.", "return", "true", "\n", "// b) State-specific check.", "case", "<-", "queueNotEmpty", ":", "// At least one entry present. Check its timeout in the next iteration.", "return", "false", "\n", "}", "\n", "}" ]

[ "waitForNonEmptyQueue", "blocks", "until", "the", "buffer", "queue", "gets", "a", "new", "element", "or", "the", "timeout", "thread", "should", "be", "stopped", ".", "It", "returns", "true", "if", "the", "timeout", "thread", "should", "stop", "." ]

[ "func", "NewInterval", "(", "earliest", ",", "latest", "time", ".", "Time", ")", "(", "Interval", ",", "error", ")", "{", "if", "latest", ".", "Sub", "(", "earliest", ")", "<", "0", "{", "return", "Interval", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "earliest", ",", "latest", ")", "\n", "}", "\n", "return", "Interval", "{", "earliest", ":", "earliest", ",", "latest", ":", "latest", ",", "}", ",", "nil", "\n", "}" ]

[ "NewInterval", "creates", "a", "new", "Interval", "from", "the", "provided", "times", ".", "earliest", "has", "to", "be", "smaller", "or", "equal", "to", "latest", "or", "an", "error", "is", "returned", "." ]

[ "func", "(", "i", "Interval", ")", "Less", "(", "other", "Interval", ")", "bool", "{", "return", "i", ".", "latest", ".", "Sub", "(", "other", ".", "earliest", ")", "<", "0", "\n", "}" ]

[ "Less", "returns", "true", "if", "the", "provided", "interval", "is", "earlier", "than", "the", "parameter", ".", "Since", "both", "intervals", "are", "inclusive", "comparison", "has", "to", "be", "strict", "." ]

[ "func", "(", "sa", "*", "StaticAuthPlugin", ")", "Authenticate", "(", "ctx", "context", ".", "Context", ",", "fullMethod", "string", ")", "(", "context", ".", "Context", ",", "error", ")", "{", "if", "md", ",", "ok", ":=", "metadata", ".", "FromIncomingContext", "(", "ctx", ")", ";", "ok", "{", "if", "len", "(", "md", "[", "\"", "\"", "]", ")", "==", "0", "||", "len", "(", "md", "[", "\"", "\"", "]", ")", "==", "0", "{", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Unauthenticated", ",", "\"", "\"", ")", "\n", "}", "\n", "username", ":=", "md", "[", "\"", "\"", "]", "[", "0", "]", "\n", "password", ":=", "md", "[", "\"", "\"", "]", "[", "0", "]", "\n", "for", "_", ",", "authEntry", ":=", "range", "sa", ".", "entries", "{", "if", "username", "==", "authEntry", ".", "Username", "&&", "password", "==", "authEntry", ".", "Password", "{", "return", "ctx", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "PermissionDenied", ",", "\"", "\"", ",", "username", ")", "\n", "}", "\n", "return", "nil", ",", "status", ".", "Errorf", "(", "codes", ".", "Unauthenticated", ",", "\"", "\"", ")", "\n", "}" ]

[ "Authenticate", "implements", "AuthPlugin", "interface", ".", "This", "method", "will", "be", "used", "inside", "a", "middleware", "in", "grpc_server", "to", "authenticate", "incoming", "requests", "." ]

[ "func", "purgeLogsOnce", "(", "now", "time", ".", "Time", ",", "dir", ",", "program", "string", ",", "keep", "time", ".", "Duration", ")", "{", "current", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "_", ",", "level", ":=", "range", "levels", "{", "c", ",", "err", ":=", "os", ".", "Readlink", "(", "path", ".", "Join", "(", "dir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "program", ",", "level", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "current", "[", "c", "]", "=", "true", "\n", "}", "\n\n", "files", ",", "err", ":=", "filepath", ".", "Glob", "(", "path", ".", "Join", "(", "dir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "program", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "for", "_", ",", "file", ":=", "range", "files", "{", "if", "current", "[", "file", "]", "{", "continue", "\n", "}", "\n", "created", ",", "err", ":=", "parseTimestamp", "(", "file", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "if", "now", ".", "Sub", "(", "created", ")", ">", "keep", "{", "os", ".", "Remove", "(", "file", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "purgeLogsOnce", "removes", "logfiles", "for", "program", "for", "dir", "if", "their", "age", "relative", "to", "now", "is", "greater", "than", "keep", "." ]

[ "func", "PurgeLogs", "(", ")", "{", "f", ":=", "flag", ".", "Lookup", "(", "\"", "\"", ")", "\n", "if", "f", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "*", "keepLogs", "==", "0", "*", "time", ".", "Second", "{", "return", "\n", "}", "\n", "logDir", ":=", "f", ".", "Value", ".", "String", "(", ")", "\n", "program", ":=", "filepath", ".", "Base", "(", "os", ".", "Args", "[", "0", "]", ")", "\n\n", "timer", ":=", "time", ".", "NewTimer", "(", "*", "purgeLogsInterval", ")", "\n", "for", "range", "timer", ".", "C", "{", "purgeLogsOnce", "(", "time", ".", "Now", "(", ")", ",", "logDir", ",", "program", ",", "*", "keepLogs", ")", "\n", "}", "\n", "}" ]

[ "PurgeLogs", "removes", "any", "log", "files", "that", "were", "started", "more", "than", "keepLogs", "ago", "and", "that", "aren", "t", "the", "current", "log", "." ]

[ "func", "ToVTRPC", "(", "err", "error", ")", "*", "vtrpcpb", ".", "RPCError", "{", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "code", ":=", "Code", "(", "err", ")", "\n", "return", "&", "vtrpcpb", ".", "RPCError", "{", "LegacyCode", ":", "CodeToLegacyErrorCode", "(", "code", ")", ",", "Code", ":", "code", ",", "Message", ":", "err", ".", "Error", "(", ")", ",", "}", "\n", "}" ]

[ "ToVTRPC", "converts", "from", "vtError", "to", "a", "vtrpcpb", ".", "RPCError", "." ]

[ "func", "HasWildcard", "(", "path", "string", ")", "bool", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "path", ")", ";", "i", "++", "{", "switch", "path", "[", "i", "]", "{", "case", "'\\\\'", ":", "if", "i", "+", "1", ">=", "len", "(", "path", ")", "{", "return", "true", "\n", "}", "\n", "i", "++", "\n", "case", "'*'", ",", "'?'", ",", "'['", ":", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HasWildcard", "checks", "if", "a", "string", "has", "a", "wildcard", "in", "it", ".", "In", "the", "cases", "where", "we", "detect", "a", "bad", "pattern", "we", "return", "true", "and", "let", "the", "path", ".", "Match", "function", "find", "it", "." ]

[ "func", "(", "h", "*", "Hooks", ")", "Add", "(", "f", "func", "(", ")", ")", "{", "h", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "h", ".", "mu", ".", "Unlock", "(", ")", "\n", "h", ".", "funcs", "=", "append", "(", "h", ".", "funcs", ",", "f", ")", "\n", "}" ]

[ "Add", "appends", "the", "given", "function", "to", "the", "list", "to", "be", "triggered", "." ]

[ "func", "NewLegacySplitCloneWorker", "(", "wr", "*", "wrangler", ".", "Wrangler", ",", "cell", ",", "keyspace", ",", "shard", "string", ",", "excludeTables", "[", "]", "string", ",", "sourceReaderCount", ",", "destinationPackCount", ",", "destinationWriterCount", ",", "minHealthyRdonlyTablets", "int", ",", "maxTPS", "int64", ")", "(", "Worker", ",", "error", ")", "{", "if", "maxTPS", "!=", "throttler", ".", "MaxRateModuleDisabled", "{", "wr", ".", "Logger", "(", ")", ".", "Infof", "(", "\"", "\"", ",", "maxTPS", ")", "\n", "}", "\n", "if", "maxTPS", "!=", "throttler", ".", "MaxRateModuleDisabled", "&&", "maxTPS", "<", "int64", "(", "destinationWriterCount", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "maxTPS", ",", "destinationWriterCount", ")", "\n", "}", "\n", "return", "&", "LegacySplitCloneWorker", "{", "StatusWorker", ":", "NewStatusWorker", "(", ")", ",", "wr", ":", "wr", ",", "cell", ":", "cell", ",", "keyspace", ":", "keyspace", ",", "shard", ":", "shard", ",", "excludeTables", ":", "excludeTables", ",", "sourceReaderCount", ":", "sourceReaderCount", ",", "destinationPackCount", ":", "destinationPackCount", ",", "destinationWriterCount", ":", "destinationWriterCount", ",", "minHealthyRdonlyTablets", ":", "minHealthyRdonlyTablets", ",", "maxTPS", ":", "maxTPS", ",", "cleaner", ":", "&", "wrangler", ".", "Cleaner", "{", "}", ",", "destinationDbNames", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "destinationThrottlers", ":", "make", "(", "map", "[", "string", "]", "*", "throttler", ".", "Throttler", ")", ",", "ev", ":", "&", "events", ".", "SplitClone", "{", "Cell", ":", "cell", ",", "Keyspace", ":", "keyspace", ",", "Shard", ":", "shard", ",", "ExcludeTables", ":", "excludeTables", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "NewLegacySplitCloneWorker", "returns", "a", "new", "LegacySplitCloneWorker", "object", "." ]

[ "func", "(", "scw", "*", "LegacySplitCloneWorker", ")", "Run", "(", "ctx", "context", ".", "Context", ")", "error", "{", "resetVars", "(", ")", "\n\n", "// Run the command.", "err", ":=", "scw", ".", "run", "(", "ctx", ")", "\n\n", "// Cleanup.", "scw", ".", "setState", "(", "WorkerStateCleanUp", ")", "\n", "// Reverse any changes e.g. setting the tablet type of a source RDONLY tablet.", "cerr", ":=", "scw", ".", "cleaner", ".", "CleanUp", "(", "scw", ".", "wr", ")", "\n", "if", "cerr", "!=", "nil", "{", "if", "err", "!=", "nil", "{", "scw", ".", "wr", ".", "Logger", "(", ")", ".", "Errorf2", "(", "cerr", ",", "\"", "\"", ")", "\n", "}", "else", "{", "err", "=", "cerr", "\n", "}", "\n", "}", "\n\n", "// Stop Throttlers.", "for", "_", ",", "throttler", ":=", "range", "scw", ".", "destinationThrottlers", "{", "throttler", ".", "Close", "(", ")", "\n", "}", "\n", "// Stop healthcheck.", "for", "_", ",", "watcher", ":=", "range", "scw", ".", "destinationShardWatchers", "{", "watcher", ".", "Stop", "(", ")", "\n", "}", "\n", "if", "scw", ".", "healthCheck", "!=", "nil", "{", "if", "err", ":=", "scw", ".", "healthCheck", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "scw", ".", "wr", ".", "Logger", "(", ")", ".", "Errorf2", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "scw", ".", "setErrorState", "(", "err", ")", "\n", "return", "err", "\n", "}", "\n", "scw", ".", "setState", "(", "WorkerStateDone", ")", "\n", "return", "nil", "\n", "}" ]

[ "Run", "implements", "the", "Worker", "interface" ]

[ "func", "(", "scw", "*", "LegacySplitCloneWorker", ")", "processData", "(", "ctx", "context", ".", "Context", ",", "dbNames", "[", "]", "string", ",", "td", "*", "tabletmanagerdatapb", ".", "TableDefinition", ",", "tableIndex", "int", ",", "rr", "ResultReader", ",", "rowSplitter", "*", "RowSplitter", ",", "insertChannels", "[", "]", "chan", "string", ",", "destinationPackCount", "int", ")", "error", "{", "// Store the baseCmd per destination shard because each tablet may have a", "// different dbName.", "baseCmds", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "dbNames", ")", ")", "\n", "for", "i", ",", "dbName", ":=", "range", "dbNames", "{", "baseCmds", "[", "i", "]", "=", "\"", "\"", "+", "sqlescape", ".", "EscapeID", "(", "dbName", ")", "+", "\"", "\"", "+", "sqlescape", ".", "EscapeID", "(", "td", ".", "Name", ")", "+", "\"", "\"", "+", "strings", ".", "Join", "(", "escapeAll", "(", "td", ".", "Columns", ")", ",", "\"", "\"", ")", "+", "\"", "\"", "\n", "}", "\n", "sr", ":=", "rowSplitter", ".", "StartSplit", "(", ")", "\n", "packCount", ":=", "0", "\n\n", "fields", ":=", "rr", ".", "Fields", "(", ")", "\n", "for", "{", "r", ",", "err", ":=", "rr", ".", "Next", "(", ")", "\n", "if", "err", "!=", "nil", "{", "// we are done, see if there was an error", "if", "err", "!=", "io", ".", "EOF", "{", "return", "err", "\n", "}", "\n\n", "// send the remainder if any (ignoring", "// the return value, we don't care", "// here if we're aborted)", "if", "packCount", ">", "0", "{", "rowSplitter", ".", "Send", "(", "fields", ",", "sr", ",", "baseCmds", ",", "insertChannels", ",", "ctx", ".", "Done", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "// Split the rows by keyspace ID, and insert each chunk into each destination", "if", "err", ":=", "rowSplitter", ".", "Split", "(", "sr", ",", "r", ".", "Rows", ")", ";", "err", "!=", "nil", "{", "return", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "td", ".", "Name", ")", "\n", "}", "\n", "scw", ".", "tableStatusList", ".", "addCopiedRows", "(", "tableIndex", ",", "len", "(", "r", ".", "Rows", ")", ")", "\n\n", "// see if we reach the destination pack count", "packCount", "++", "\n", "if", "packCount", "<", "destinationPackCount", "{", "continue", "\n", "}", "\n\n", "// send the rows to be inserted", "if", "aborted", ":=", "rowSplitter", ".", "Send", "(", "fields", ",", "sr", ",", "baseCmds", ",", "insertChannels", ",", "ctx", ".", "Done", "(", ")", ")", ";", "aborted", "{", "return", "nil", "\n", "}", "\n\n", "// and reset our row buffer", "sr", "=", "rowSplitter", ".", "StartSplit", "(", ")", "\n", "packCount", "=", "0", "\n", "}", "\n", "}" ]

[ "processData", "pumps", "the", "data", "out", "of", "the", "provided", "QueryResultReader", ".", "It", "returns", "any", "error", "the", "source", "encounters", "." ]

[ "func", "(", "t", "*", "Throttler", ")", "updateMaxRate", "(", ")", "{", "// Set it to infinite initially.", "maxRate", ":=", "int64", "(", "math", ".", "MaxInt64", ")", "\n\n", "// Find out the new max rate (minimum among all modules).", "for", "_", ",", "m", ":=", "range", "t", ".", "modules", "{", "if", "moduleMaxRate", ":=", "m", ".", "MaxRate", "(", ")", ";", "moduleMaxRate", "<", "maxRate", "{", "maxRate", "=", "moduleMaxRate", "\n", "}", "\n", "}", "\n\n", "// Set the new max rate on each thread.", "t", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "t", ".", "mu", ".", "Unlock", "(", ")", "\n", "threadsRunning", ":=", "len", "(", "t", ".", "runningThreads", ")", "\n", "if", "threadsRunning", "==", "0", "{", "// Throttler is done. Set rates don't matter anymore.", "return", "\n", "}", "\n\n", "if", "maxRate", "!=", "ZeroRateNoProgess", "&&", "maxRate", "<", "int64", "(", "threadsRunning", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "threadsRunning", ",", "maxRate", ",", "threadsRunning", ")", "\n", "maxRate", "=", "int64", "(", "threadsRunning", ")", "\n", "}", "\n", "maxRatePerThread", ":=", "maxRate", "/", "int64", "(", "threadsRunning", ")", "\n", "// Distribute the remainder of the division across all threads.", "remainder", ":=", "maxRate", "%", "int64", "(", "threadsRunning", ")", "\n", "remainderPerThread", ":=", "make", "(", "map", "[", "int", "]", "int64", ",", "threadsRunning", ")", "\n", "for", "id", ":=", "0", ";", "remainder", ">", "0", ";", "{", "remainderPerThread", "[", "id", "]", "++", "\n", "remainder", "--", "\n", "id", "++", "\n", "}", "\n\n", "for", "threadID", ":=", "range", "t", ".", "runningThreads", "{", "t", ".", "threadThrottlers", "[", "threadID", "]", ".", "setMaxRate", "(", "maxRatePerThread", "+", "remainderPerThread", "[", "threadID", "]", ")", "\n", "}", "\n", "t", ".", "threadRunningsLastUpdate", "=", "threadsRunning", "\n", "}" ]

[ "updateMaxRate", "recalculates", "the", "current", "max", "rate", "and", "updates", "all", "threadThrottlers", "accordingly", ".", "The", "rate", "changes", "when", "the", "number", "of", "thread", "changes", "or", "a", "module", "updated", "its", "max", "rate", "." ]

[ "func", "(", "t", "*", "Throttler", ")", "UpdateConfiguration", "(", "configuration", "*", "throttlerdatapb", ".", "Configuration", ",", "copyZeroValues", "bool", ")", "error", "{", "return", "t", ".", "maxReplicationLagModule", ".", "updateConfiguration", "(", "configuration", ",", "copyZeroValues", ")", "\n", "}" ]

[ "UpdateConfiguration", "updates", "the", "configuration", "of", "the", "MaxReplicationLag", "module", "." ]

[ "func", "newLimit", "(", "bldr", "builder", ")", "*", "limit", "{", "return", "&", "limit", "{", "order", ":", "bldr", ".", "Order", "(", ")", "+", "1", ",", "resultColumns", ":", "bldr", ".", "ResultColumns", "(", ")", ",", "input", ":", "bldr", ",", "elimit", ":", "&", "engine", ".", "Limit", "{", "}", ",", "}", "\n", "}" ]

[ "newLimit", "builds", "a", "new", "limit", "." ]

[ "func", "(", "l", "*", "limit", ")", "SetLimit", "(", "limit", "*", "sqlparser", ".", "Limit", ")", "error", "{", "count", ",", "ok", ":=", "limit", ".", "Rowcount", ".", "(", "*", "sqlparser", ".", "SQLVal", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sqlparser", ".", "String", "(", "limit", ")", ")", "\n", "}", "\n", "pv", ",", "err", ":=", "sqlparser", ".", "NewPlanValue", "(", "count", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "l", ".", "elimit", ".", "Count", "=", "pv", "\n\n", "switch", "offset", ":=", "limit", ".", "Offset", ".", "(", "type", ")", "{", "case", "*", "sqlparser", ".", "SQLVal", ":", "pv", ",", "err", "=", "sqlparser", ".", "NewPlanValue", "(", "offset", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "l", ".", "elimit", ".", "Offset", "=", "pv", "\n", "case", "nil", ":", "// NOOP", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "sqlparser", ".", "String", "(", "limit", ")", ")", "\n", "}", "\n\n", "l", ".", "input", ".", "SetUpperLimit", "(", "sqlparser", ".", "NewValArg", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "SetLimit", "sets", "the", "limit", "for", "the", "primitive", ".", "It", "calls", "the", "underlying", "primitive", "s", "SetUpperLimit", "which", "is", "an", "optimization", "hint", "that", "informs", "the", "underlying", "primitive", "that", "it", "doesn", "t", "need", "to", "return", "more", "rows", "than", "specified", "." ]

[ "func", "(", "c", "*", "counters", ")", "ResetAll", "(", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "c", ".", "counts", "=", "make", "(", "map", "[", "string", "]", "*", "int64", ")", "\n", "}" ]

[ "ResetAll", "resets", "all", "counter", "values", "and", "clears", "all", "keys", "." ]

[ "func", "(", "c", "*", "counters", ")", "ZeroAll", "(", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "_", ",", "a", ":=", "range", "c", ".", "counts", "{", "atomic", ".", "StoreInt64", "(", "a", ",", "int64", "(", "0", ")", ")", "\n", "}", "\n", "}" ]

[ "ZeroAll", "resets", "all", "counter", "values", "to", "zero" ]

[ "func", "(", "c", "*", "counters", ")", "Reset", "(", "name", "string", ")", "{", "a", ":=", "c", ".", "getValueAddr", "(", "name", ")", "\n", "atomic", ".", "StoreInt64", "(", "a", ",", "int64", "(", "0", ")", ")", "\n", "}" ]

[ "Reset", "resets", "a", "specific", "counter", "value", "to", "0", "." ]

[ "func", "NewCountersWithSingleLabel", "(", "name", ",", "help", ",", "label", "string", ",", "tags", "...", "string", ")", "*", "CountersWithSingleLabel", "{", "c", ":=", "&", "CountersWithSingleLabel", "{", "counters", ":", "counters", "{", "counts", ":", "make", "(", "map", "[", "string", "]", "*", "int64", ")", ",", "help", ":", "help", ",", "}", ",", "label", ":", "label", ",", "}", "\n\n", "for", "_", ",", "tag", ":=", "range", "tags", "{", "c", ".", "counts", "[", "tag", "]", "=", "new", "(", "int64", ")", "\n", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "c", ")", "\n", "}", "\n", "return", "c", "\n", "}" ]

[ "NewCountersWithSingleLabel", "create", "a", "new", "Counters", "instance", ".", "If", "name", "is", "set", "the", "variable", "gets", "published", ".", "The", "function", "also", "accepts", "an", "optional", "list", "of", "tags", "that", "pre", "-", "creates", "them", "initialized", "to", "0", ".", "label", "is", "a", "category", "name", "used", "to", "organize", "the", "tags", ".", "It", "is", "currently", "only", "used", "by", "Prometheus", "but", "not", "by", "the", "expvar", "package", "." ]

[ "func", "NewCountersWithMultiLabels", "(", "name", ",", "help", "string", ",", "labels", "[", "]", "string", ")", "*", "CountersWithMultiLabels", "{", "t", ":=", "&", "CountersWithMultiLabels", "{", "counters", ":", "counters", "{", "counts", ":", "make", "(", "map", "[", "string", "]", "*", "int64", ")", ",", "help", ":", "help", "}", ",", "labels", ":", "labels", ",", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "t", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "NewCountersWithMultiLabels", "creates", "a", "new", "CountersWithMultiLabels", "instance", "and", "publishes", "it", "if", "name", "is", "set", "." ]

[ "func", "NewCountersFuncWithMultiLabels", "(", "name", ",", "help", "string", ",", "labels", "[", "]", "string", ",", "f", "func", "(", ")", "map", "[", "string", "]", "int64", ")", "*", "CountersFuncWithMultiLabels", "{", "t", ":=", "&", "CountersFuncWithMultiLabels", "{", "f", ":", "f", ",", "help", ":", "help", ",", "labels", ":", "labels", ",", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "t", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "NewCountersFuncWithMultiLabels", "creates", "a", "new", "CountersFuncWithMultiLabels", "mapping", "to", "the", "provided", "function", "." ]

[ "func", "NewGaugesWithSingleLabel", "(", "name", ",", "help", ",", "label", "string", ",", "tags", "...", "string", ")", "*", "GaugesWithSingleLabel", "{", "g", ":=", "&", "GaugesWithSingleLabel", "{", "CountersWithSingleLabel", ":", "CountersWithSingleLabel", "{", "counters", ":", "counters", "{", "counts", ":", "make", "(", "map", "[", "string", "]", "*", "int64", ")", ",", "help", ":", "help", ",", "}", ",", "label", ":", "label", ",", "}", ",", "}", "\n\n", "for", "_", ",", "tag", ":=", "range", "tags", "{", "g", ".", "counts", "[", "tag", "]", "=", "new", "(", "int64", ")", "\n", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "g", ")", "\n", "}", "\n", "return", "g", "\n", "}" ]

[ "NewGaugesWithSingleLabel", "creates", "a", "new", "GaugesWithSingleLabel", "and", "publishes", "it", "if", "the", "name", "is", "set", "." ]

[ "func", "(", "g", "*", "GaugesWithSingleLabel", ")", "Set", "(", "name", "string", ",", "value", "int64", ")", "{", "a", ":=", "g", ".", "getValueAddr", "(", "name", ")", "\n", "atomic", ".", "StoreInt64", "(", "a", ",", "value", ")", "\n", "}" ]

[ "Set", "sets", "the", "value", "of", "a", "named", "gauge", "." ]

[ "func", "(", "g", "*", "GaugesWithSingleLabel", ")", "Add", "(", "name", "string", ",", "value", "int64", ")", "{", "a", ":=", "g", ".", "getValueAddr", "(", "name", ")", "\n", "atomic", ".", "AddInt64", "(", "a", ",", "value", ")", "\n", "}" ]

[ "Add", "adds", "a", "value", "to", "a", "named", "gauge", "." ]

[ "func", "NewGaugesWithMultiLabels", "(", "name", ",", "help", "string", ",", "labels", "[", "]", "string", ")", "*", "GaugesWithMultiLabels", "{", "t", ":=", "&", "GaugesWithMultiLabels", "{", "CountersWithMultiLabels", ":", "CountersWithMultiLabels", "{", "counters", ":", "counters", "{", "counts", ":", "make", "(", "map", "[", "string", "]", "*", "int64", ")", ",", "help", ":", "help", ",", "}", ",", "labels", ":", "labels", ",", "}", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "t", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "NewGaugesWithMultiLabels", "creates", "a", "new", "GaugesWithMultiLabels", "instance", "and", "publishes", "it", "if", "name", "is", "set", "." ]

[ "func", "NewGaugesFuncWithMultiLabels", "(", "name", ",", "help", "string", ",", "labels", "[", "]", "string", ",", "f", "func", "(", ")", "map", "[", "string", "]", "int64", ")", "*", "GaugesFuncWithMultiLabels", "{", "t", ":=", "&", "GaugesFuncWithMultiLabels", "{", "CountersFuncWithMultiLabels", ":", "CountersFuncWithMultiLabels", "{", "f", ":", "f", ",", "help", ":", "help", ",", "labels", ":", "labels", ",", "}", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "t", ")", "\n", "}", "\n\n", "return", "t", "\n", "}" ]

[ "NewGaugesFuncWithMultiLabels", "creates", "a", "new", "GaugesFuncWithMultiLabels", "mapping", "to", "the", "provided", "function", "." ]

[ "func", "FindTabletByHostAndPort", "(", "tabletMap", "map", "[", "string", "]", "*", "topo", ".", "TabletInfo", ",", "addr", ",", "portName", "string", ",", "port", "int32", ")", "(", "*", "topodatapb", ".", "TabletAlias", ",", "error", ")", "{", "for", "_", ",", "ti", ":=", "range", "tabletMap", "{", "if", "ti", ".", "Hostname", "==", "addr", "&&", "ti", ".", "PortMap", "[", "portName", "]", "==", "port", "{", "return", "ti", ".", "Alias", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "topo", ".", "NewError", "(", "topo", ".", "NoNode", ",", "addr", "+", "\"", "\"", "+", "portName", ")", "\n", "}" ]

[ "FindTabletByHostAndPort", "searches", "within", "a", "tablet", "map", "for", "tablets", "." ]

[ "func", "GetAllTablets", "(", "ctx", "context", ".", "Context", ",", "ts", "*", "topo", ".", "Server", ",", "cell", "string", ")", "(", "[", "]", "*", "topo", ".", "TabletInfo", ",", "error", ")", "{", "aliases", ",", "err", ":=", "ts", ".", "GetTabletsByCell", "(", "ctx", ",", "cell", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "sort", ".", "Sort", "(", "topoproto", ".", "TabletAliasList", "(", "aliases", ")", ")", "\n\n", "tabletMap", ",", "err", ":=", "ts", ".", "GetTabletMap", "(", "ctx", ",", "aliases", ")", "\n", "if", "err", "!=", "nil", "{", "// we got another error than topo.ErrNoNode", "return", "nil", ",", "err", "\n", "}", "\n", "tablets", ":=", "make", "(", "[", "]", "*", "topo", ".", "TabletInfo", ",", "0", ",", "len", "(", "aliases", ")", ")", "\n", "for", "_", ",", "tabletAlias", ":=", "range", "aliases", "{", "tabletInfo", ",", "ok", ":=", "tabletMap", "[", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", "]", "\n", "if", "!", "ok", "{", "// tablet disappeared on us (GetTabletMap ignores", "// topo.ErrNoNode), just echo a warning", "log", ".", "Warningf", "(", "\"", "\"", ",", "tabletAlias", ")", "\n", "}", "else", "{", "tablets", "=", "append", "(", "tablets", ",", "tabletInfo", ")", "\n", "}", "\n", "}", "\n\n", "return", "tablets", ",", "nil", "\n", "}" ]

[ "GetAllTablets", "returns", "a", "sorted", "list", "of", "tablets", "." ]

[ "func", "GetAllTabletsAcrossCells", "(", "ctx", "context", ".", "Context", ",", "ts", "*", "topo", ".", "Server", ")", "(", "[", "]", "*", "topo", ".", "TabletInfo", ",", "error", ")", "{", "cells", ",", "err", ":=", "ts", ".", "GetKnownCells", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "results", ":=", "make", "(", "[", "]", "[", "]", "*", "topo", ".", "TabletInfo", ",", "len", "(", "cells", ")", ")", "\n", "errors", ":=", "make", "(", "[", "]", "error", ",", "len", "(", "cells", ")", ")", "\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "len", "(", "cells", ")", ")", "\n", "for", "i", ",", "cell", ":=", "range", "cells", "{", "go", "func", "(", "i", "int", ",", "cell", "string", ")", "{", "results", "[", "i", "]", ",", "errors", "[", "i", "]", "=", "GetAllTablets", "(", "ctx", ",", "ts", ",", "cell", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", "i", ",", "cell", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "err", "=", "nil", "\n", "var", "allTablets", "[", "]", "*", "topo", ".", "TabletInfo", "\n", "for", "i", ":=", "range", "cells", "{", "if", "errors", "[", "i", "]", "==", "nil", "{", "allTablets", "=", "append", "(", "allTablets", ",", "results", "[", "i", "]", "...", ")", "\n", "}", "else", "{", "err", "=", "topo", ".", "NewError", "(", "topo", ".", "PartialResult", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "allTablets", ",", "err", "\n", "}" ]

[ "GetAllTabletsAcrossCells", "returns", "all", "tablets", "from", "known", "cells", ".", "If", "it", "returns", "topo", ".", "ErrPartialResult", "then", "the", "list", "is", "valid", "but", "partial", "." ]

[ "func", "CopyMapKeys", "(", "m", "interface", "{", "}", ",", "typeHint", "interface", "{", "}", ")", "interface", "{", "}", "{", "mapVal", ":=", "reflect", ".", "ValueOf", "(", "m", ")", "\n", "keys", ":=", "reflect", ".", "MakeSlice", "(", "reflect", ".", "TypeOf", "(", "typeHint", ")", ",", "0", ",", "mapVal", ".", "Len", "(", ")", ")", "\n", "for", "_", ",", "k", ":=", "range", "mapVal", ".", "MapKeys", "(", ")", "{", "keys", "=", "reflect", ".", "Append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "return", "keys", ".", "Interface", "(", ")", "\n", "}" ]

[ "CopyMapKeys", "copies", "keys", "from", "from", "map", "m", "into", "a", "new", "slice", "with", "the", "type", "specified", "by", "typeHint", ".", "Reflection", "can", "t", "make", "a", "new", "slice", "type", "just", "based", "on", "the", "key", "type", "AFAICT", "." ]

[ "func", "CopyMapValues", "(", "m", "interface", "{", "}", ",", "typeHint", "interface", "{", "}", ")", "interface", "{", "}", "{", "mapVal", ":=", "reflect", ".", "ValueOf", "(", "m", ")", "\n", "vals", ":=", "reflect", ".", "MakeSlice", "(", "reflect", ".", "TypeOf", "(", "typeHint", ")", ",", "0", ",", "mapVal", ".", "Len", "(", ")", ")", "\n", "for", "_", ",", "k", ":=", "range", "mapVal", ".", "MapKeys", "(", ")", "{", "vals", "=", "reflect", ".", "Append", "(", "vals", ",", "mapVal", ".", "MapIndex", "(", "k", ")", ")", "\n", "}", "\n", "return", "vals", ".", "Interface", "(", ")", "\n", "}" ]

[ "CopyMapValues", "copies", "values", "from", "from", "map", "m", "into", "a", "new", "slice", "with", "the", "type", "specified", "by", "typeHint", ".", "Reflection", "can", "t", "make", "a", "new", "slice", "type", "just", "based", "on", "the", "key", "type", "AFAICT", "." ]

[ "func", "MapKeys", "(", "m", "interface", "{", "}", ")", "[", "]", "interface", "{", "}", "{", "keys", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "16", ")", "\n", "mapVal", ":=", "reflect", ".", "ValueOf", "(", "m", ")", "\n", "for", "_", ",", "kv", ":=", "range", "mapVal", ".", "MapKeys", "(", ")", "{", "keys", "=", "append", "(", "keys", ",", "kv", ".", "Interface", "(", ")", ")", "\n", "}", "\n", "return", "keys", "\n", "}" ]

[ "MapKeys", "returns", "an", "array", "with", "th", "provided", "map", "keys", "." ]

[ "func", "NewEngine", "(", "ts", "*", "topo", ".", "Server", ",", "cell", "string", ",", "mysqld", "mysqlctl", ".", "MysqlDaemon", ",", "dbClientFactory", "func", "(", ")", "binlogplayer", ".", "DBClient", ",", "dbName", "string", ")", "*", "Engine", "{", "vre", ":=", "&", "Engine", "{", "controllers", ":", "make", "(", "map", "[", "int", "]", "*", "controller", ")", ",", "ts", ":", "ts", ",", "cell", ":", "cell", ",", "mysqld", ":", "mysqld", ",", "dbClientFactory", ":", "dbClientFactory", ",", "dbName", ":", "dbName", ",", "}", "\n", "return", "vre", "\n", "}" ]

[ "NewEngine", "creates", "a", "new", "Engine", ".", "A", "nil", "ts", "means", "that", "the", "Engine", "is", "disabled", "." ]

[ "func", "(", "vre", "*", "Engine", ")", "executeFetchMaybeCreateTable", "(", "dbClient", "binlogplayer", ".", "DBClient", ",", "query", "string", ",", "maxrows", "int", ")", "(", "qr", "*", "sqltypes", ".", "Result", ",", "err", "error", ")", "{", "qr", ",", "err", "=", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "maxrows", ")", "\n\n", "if", "err", "==", "nil", "{", "return", "\n", "}", "\n\n", "// If it's a bad table or db, it could be because _vt.vreplication wasn't created.", "// In that case we can try creating it again.", "merr", ",", "isSQLErr", ":=", "err", ".", "(", "*", "mysql", ".", "SQLError", ")", "\n", "if", "!", "isSQLErr", "||", "!", "(", "merr", ".", "Num", "==", "mysql", ".", "ERNoSuchTable", "||", "merr", ".", "Num", "==", "mysql", ".", "ERBadDb", "||", "merr", ".", "Num", "==", "mysql", ".", "ERBadFieldError", ")", "{", "return", "qr", ",", "err", "\n", "}", "\n\n", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "if", "merr", ".", "Num", "==", "mysql", ".", "ERNoSuchTable", "||", "merr", ".", "Num", "==", "mysql", ".", "ERBadDb", "{", "for", "_", ",", "query", ":=", "range", "binlogplayer", ".", "CreateVReplicationTable", "(", ")", "{", "if", "_", ",", "merr", ":=", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "0", ")", ";", "merr", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "merr", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "merr", ".", "Num", "==", "mysql", ".", "ERBadFieldError", "{", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "for", "_", ",", "query", ":=", "range", "binlogplayer", ".", "AlterVReplicationTable", "(", ")", "{", "if", "_", ",", "merr", ":=", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "0", ")", ";", "merr", "!=", "nil", "{", "merr", ",", "isSQLErr", ":=", "err", ".", "(", "*", "mysql", ".", "SQLError", ")", "\n", "if", "!", "isSQLErr", "||", "!", "(", "merr", ".", "Num", "==", "mysql", ".", "ERDupFieldName", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "merr", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "dbClient", ".", "ExecuteFetch", "(", "query", ",", "maxrows", ")", "\n", "}" ]

[ "executeFetchMaybeCreateTable", "calls", "DBClient", ".", "ExecuteFetch", "and", "does", "one", "retry", "if", "there", "s", "a", "failure", "due", "to", "mysql", ".", "ERNoSuchTable", "or", "mysql", ".", "ERBadDb", "which", "can", "be", "fixed", "by", "re", "-", "creating", "the", "_vt", ".", "vreplication", "table", "." ]

[ "func", "(", "vre", "*", "Engine", ")", "IsOpen", "(", ")", "bool", "{", "vre", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "vre", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "vre", ".", "isOpen", "\n", "}" ]

[ "IsOpen", "returns", "true", "if", "Engine", "is", "open", "." ]

[ "func", "(", "vre", "*", "Engine", ")", "WaitForPos", "(", "ctx", "context", ".", "Context", ",", "id", "int", ",", "pos", "string", ")", "error", "{", "mPos", ",", "err", ":=", "mysql", ".", "DecodePosition", "(", "pos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "func", "(", ")", "error", "{", "vre", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "vre", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "!", "vre", ".", "isOpen", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Ensure that the engine won't be closed while this is running.", "vre", ".", "wg", ".", "Add", "(", "1", ")", "\n", "return", "nil", "\n", "}", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "vre", ".", "wg", ".", "Done", "(", ")", "\n\n", "dbClient", ":=", "vre", ".", "dbClientFactory", "(", ")", "\n", "if", "err", ":=", "dbClient", ".", "Connect", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "dbClient", ".", "Close", "(", ")", "\n\n", "for", "{", "qr", ",", "err", ":=", "dbClient", ".", "ExecuteFetch", "(", "binlogplayer", ".", "ReadVReplicationStatus", "(", "uint32", "(", "id", ")", ")", ",", "10", ")", "\n", "switch", "{", "case", "err", "!=", "nil", ":", "return", "err", "\n", "case", "len", "(", "qr", ".", "Rows", ")", "==", "0", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "id", ")", "\n", "case", "len", "(", "qr", ".", "Rows", ")", ">", "1", "||", "len", "(", "qr", ".", "Rows", "[", "0", "]", ")", "!=", "3", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "qr", ")", "\n", "}", "\n", "current", ",", "err", ":=", "mysql", ".", "DecodePosition", "(", "qr", ".", "Rows", "[", "0", "]", "[", "0", "]", ".", "ToString", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "current", ".", "AtLeast", "(", "mPos", ")", "{", "return", "nil", "\n", "}", "\n\n", "if", "qr", ".", "Rows", "[", "0", "]", "[", "1", "]", ".", "ToString", "(", ")", "==", "binlogplayer", ".", "BlpStopped", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "current", ",", "mPos", ",", "qr", ".", "Rows", "[", "0", "]", "[", "2", "]", ".", "ToString", "(", ")", ")", "\n", "}", "\n\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "case", "<-", "vre", ".", "ctx", ".", "Done", "(", ")", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vre", ".", "ctx", ".", "Err", "(", ")", ")", "\n", "case", "<-", "time", ".", "After", "(", "waitRetryTime", ")", ":", "}", "\n", "}", "\n", "}" ]

[ "WaitForPos", "waits", "for", "the", "replication", "to", "reach", "the", "specified", "position", "." ]

[ "func", "(", "vre", "*", "Engine", ")", "updateStats", "(", ")", "{", "globalStats", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "globalStats", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "globalStats", ".", "isOpen", "=", "vre", ".", "isOpen", "\n", "globalStats", ".", "controllers", "=", "make", "(", "map", "[", "int", "]", "*", "controller", ",", "len", "(", "vre", ".", "controllers", ")", ")", "\n", "for", "id", ",", "ct", ":=", "range", "vre", ".", "controllers", "{", "globalStats", ".", "controllers", "[", "id", "]", "=", "ct", "\n", "}", "\n", "}" ]

[ "UpdateStats", "must", "be", "called", "with", "lock", "held", "." ]

[ "func", "rowToMap", "(", "qr", "*", "sqltypes", ".", "Result", ",", "rownum", "int", ")", "(", "map", "[", "string", "]", "string", ",", "error", ")", "{", "row", ":=", "qr", ".", "Rows", "[", "rownum", "]", "\n", "m", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "row", ")", ")", "\n", "for", "i", ",", "fld", ":=", "range", "qr", ".", "Fields", "{", "if", "row", "[", "i", "]", ".", "IsNull", "(", ")", "{", "continue", "\n", "}", "\n", "m", "[", "fld", ".", "Name", "]", "=", "row", "[", "i", "]", ".", "ToString", "(", ")", "\n", "}", "\n", "return", "m", ",", "nil", "\n", "}" ]

[ "rowToMap", "converts", "a", "row", "into", "a", "map", "for", "easier", "processing", "." ]

[ "func", "NewQueryInsert", "(", "opcode", "InsertOpcode", ",", "keyspace", "*", "vindexes", ".", "Keyspace", ",", "query", "string", ")", "*", "Insert", "{", "return", "&", "Insert", "{", "Opcode", ":", "opcode", ",", "Keyspace", ":", "keyspace", ",", "Query", ":", "query", ",", "}", "\n", "}" ]

[ "NewQueryInsert", "creates", "an", "Insert", "with", "a", "query", "string", "." ]

[ "func", "NewSimpleInsert", "(", "opcode", "InsertOpcode", ",", "table", "*", "vindexes", ".", "Table", ",", "keyspace", "*", "vindexes", ".", "Keyspace", ")", "*", "Insert", "{", "return", "&", "Insert", "{", "Opcode", ":", "opcode", ",", "Table", ":", "table", ",", "Keyspace", ":", "keyspace", ",", "}", "\n", "}" ]

[ "NewSimpleInsert", "creates", "an", "Insert", "for", "a", "Table", "." ]

[ "func", "NewInsert", "(", "opcode", "InsertOpcode", ",", "keyspace", "*", "vindexes", ".", "Keyspace", ",", "vindexValues", "[", "]", "sqltypes", ".", "PlanValue", ",", "table", "*", "vindexes", ".", "Table", ",", "prefix", "string", ",", "mid", "[", "]", "string", ",", "suffix", "string", ")", "*", "Insert", "{", "return", "&", "Insert", "{", "Opcode", ":", "opcode", ",", "Keyspace", ":", "keyspace", ",", "VindexValues", ":", "vindexValues", ",", "Table", ":", "table", ",", "Prefix", ":", "prefix", ",", "Mid", ":", "mid", ",", "Suffix", ":", "suffix", ",", "}", "\n", "}" ]

[ "NewInsert", "creates", "a", "new", "Insert", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "tname", "string", "\n", "if", "ins", ".", "Table", "!=", "nil", "{", "tname", "=", "ins", ".", "Table", ".", "Name", ".", "String", "(", ")", "\n", "}", "\n", "marshalInsert", ":=", "struct", "{", "Opcode", "InsertOpcode", "\n", "Keyspace", "*", "vindexes", ".", "Keyspace", "`json:\",omitempty\"`", "\n", "Query", "string", "`json:\",omitempty\"`", "\n", "Values", "[", "]", "sqltypes", ".", "PlanValue", "`json:\",omitempty\"`", "\n", "Table", "string", "`json:\",omitempty\"`", "\n", "Generate", "*", "Generate", "`json:\",omitempty\"`", "\n", "Prefix", "string", "`json:\",omitempty\"`", "\n", "Mid", "[", "]", "string", "`json:\",omitempty\"`", "\n", "Suffix", "string", "`json:\",omitempty\"`", "\n", "MultiShardAutocommit", "bool", "`json:\",omitempty\"`", "\n", "QueryTimeout", "int", "`json:\",omitempty\"`", "\n", "}", "{", "Opcode", ":", "ins", ".", "Opcode", ",", "Keyspace", ":", "ins", ".", "Keyspace", ",", "Query", ":", "ins", ".", "Query", ",", "Values", ":", "ins", ".", "VindexValues", ",", "Table", ":", "tname", ",", "Generate", ":", "ins", ".", "Generate", ",", "Prefix", ":", "ins", ".", "Prefix", ",", "Mid", ":", "ins", ".", "Mid", ",", "Suffix", ":", "ins", ".", "Suffix", ",", "MultiShardAutocommit", ":", "ins", ".", "MultiShardAutocommit", ",", "QueryTimeout", ":", "ins", ".", "QueryTimeout", ",", "}", "\n", "return", "jsonutil", ".", "MarshalNoEscape", "(", "marshalInsert", ")", "\n", "}" ]

[ "MarshalJSON", "serializes", "the", "Insert", "into", "a", "JSON", "representation", ".", "It", "s", "used", "for", "testing", "and", "diagnostics", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "processGenerate", "(", "vcursor", "VCursor", ",", "bindVars", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ")", "(", "insertID", "int64", ",", "err", "error", ")", "{", "if", "ins", ".", "Generate", "==", "nil", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "// Scan input values to compute the number of values to generate, and", "// keep track of where they should be filled.", "resolved", ",", "err", ":=", "ins", ".", "Generate", ".", "Values", ".", "ResolveList", "(", "bindVars", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "count", ":=", "int64", "(", "0", ")", "\n", "for", "_", ",", "val", ":=", "range", "resolved", "{", "if", "val", ".", "IsNull", "(", ")", "{", "count", "++", "\n", "}", "\n", "}", "\n\n", "// If generation is needed, generate the requested number of values (as one call).", "if", "count", "!=", "0", "{", "rss", ",", "_", ",", "err", ":=", "vcursor", ".", "ResolveDestinations", "(", "ins", ".", "Generate", ".", "Keyspace", ".", "Name", ",", "nil", ",", "[", "]", "key", ".", "Destination", "{", "key", ".", "DestinationAnyShard", "{", "}", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "rss", ")", "!=", "1", "{", "return", "0", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "len", "(", "rss", ")", ")", "\n", "}", "\n", "bindVars", ":=", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", "{", "\"", "\"", ":", "sqltypes", ".", "Int64BindVariable", "(", "count", ")", "}", "\n", "qr", ",", "err", ":=", "vcursor", ".", "ExecuteStandalone", "(", "ins", ".", "Generate", ".", "Query", ",", "bindVars", ",", "rss", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "// If no rows are returned, it's an internal error, and the code", "// must panic, which will be caught and reported.", "insertID", ",", "err", "=", "sqltypes", ".", "ToInt64", "(", "qr", ".", "Rows", "[", "0", "]", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "}", "\n\n", "// Fill the holes where no value was supplied.", "cur", ":=", "insertID", "\n", "for", "i", ",", "v", ":=", "range", "resolved", "{", "if", "v", ".", "IsNull", "(", ")", "{", "bindVars", "[", "SeqVarName", "+", "strconv", ".", "Itoa", "(", "i", ")", "]", "=", "sqltypes", ".", "Int64BindVariable", "(", "cur", ")", "\n", "cur", "++", "\n", "}", "else", "{", "bindVars", "[", "SeqVarName", "+", "strconv", ".", "Itoa", "(", "i", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "v", ")", "\n", "}", "\n", "}", "\n", "return", "insertID", ",", "nil", "\n", "}" ]

[ "processGenerate", "generates", "new", "values", "using", "a", "sequence", "if", "necessary", ".", "If", "no", "value", "was", "generated", "it", "returns", "0", ".", "Values", "are", "generated", "only", "for", "cases", "where", "none", "are", "supplied", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "processPrimary", "(", "vcursor", "VCursor", ",", "vindexKeys", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "colVindex", "*", "vindexes", ".", "ColumnVindex", ",", "bv", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ")", "(", "[", "]", "[", "]", "byte", ",", "error", ")", "{", "var", "flattenedVindexKeys", "[", "]", "sqltypes", ".", "Value", "\n", "// TODO: @rafael - this will change once vindex Primary keys also support multicolumns", "for", "_", ",", "val", ":=", "range", "vindexKeys", "{", "flattenedVindexKeys", "=", "append", "(", "flattenedVindexKeys", ",", "val", "...", ")", "\n", "}", "\n\n", "destinations", ",", "err", ":=", "colVindex", ".", "Vindex", ".", "Map", "(", "vcursor", ",", "flattenedVindexKeys", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "keyspaceIDs", ":=", "make", "(", "[", "]", "[", "]", "byte", ",", "len", "(", "destinations", ")", ")", "\n", "for", "i", ",", "destination", ":=", "range", "destinations", "{", "switch", "d", ":=", "destination", ".", "(", "type", ")", "{", "case", "key", ".", "DestinationKeyspaceID", ":", "// This is a single keyspace id, we're good.", "keyspaceIDs", "[", "i", "]", "=", "d", "\n", "case", "key", ".", "DestinationNone", ":", "// No valid keyspace id, we may return an error.", "if", "ins", ".", "Opcode", "!=", "InsertShardedIgnore", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "flattenedVindexKeys", "[", "i", "]", ")", "\n", "}", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "flattenedVindexKeys", "[", "i", "]", ",", "destination", ")", "\n", "}", "\n", "}", "\n\n", "for", "rowNum", ",", "vindexKey", ":=", "range", "flattenedVindexKeys", "{", "if", "keyspaceIDs", "[", "rowNum", "]", "==", "nil", "{", "// InsertShardedIgnore: skip the row.", "continue", "\n", "}", "\n", "for", "_", ",", "col", ":=", "range", "colVindex", ".", "Columns", "{", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "vindexKey", ")", "\n", "}", "\n", "}", "\n", "return", "keyspaceIDs", ",", "nil", "\n", "}" ]

[ "processPrimary", "maps", "the", "primary", "vindex", "values", "to", "the", "kesypace", "ids", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "processOwned", "(", "vcursor", "VCursor", ",", "vindexColumnsKeys", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "colVindex", "*", "vindexes", ".", "ColumnVindex", ",", "bv", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "ksids", "[", "]", "[", "]", "byte", ")", "error", "{", "for", "rowNum", ",", "rowColumnKeys", ":=", "range", "vindexColumnsKeys", "{", "for", "colIdx", ",", "vindexKey", ":=", "range", "rowColumnKeys", "{", "col", ":=", "colVindex", ".", "Columns", "[", "colIdx", "]", "\n", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "vindexKey", ")", "\n", "}", "\n", "}", "\n", "return", "colVindex", ".", "Vindex", ".", "(", "vindexes", ".", "Lookup", ")", ".", "Create", "(", "vcursor", ",", "vindexColumnsKeys", ",", "ksids", ",", "false", "/* ignoreMode */", ")", "\n", "}" ]

[ "processOwned", "creates", "vindex", "entries", "for", "the", "values", "of", "an", "owned", "column", "for", "InsertSharded", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "processOwnedIgnore", "(", "vcursor", "VCursor", ",", "vindexColumnsKeys", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "colVindex", "*", "vindexes", ".", "ColumnVindex", ",", "bv", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "ksids", "[", "]", "[", "]", "byte", ")", "error", "{", "var", "createIndexes", "[", "]", "int", "\n", "var", "createKeys", "[", "]", "[", "]", "sqltypes", ".", "Value", "\n", "var", "createKsids", "[", "]", "[", "]", "byte", "\n\n", "for", "rowNum", ",", "rowColumnKeys", ":=", "range", "vindexColumnsKeys", "{", "var", "rowKeys", "[", "]", "sqltypes", ".", "Value", "\n", "if", "ksids", "[", "rowNum", "]", "==", "nil", "{", "continue", "\n", "}", "\n", "createIndexes", "=", "append", "(", "createIndexes", ",", "rowNum", ")", "\n", "createKsids", "=", "append", "(", "createKsids", ",", "ksids", "[", "rowNum", "]", ")", "\n\n", "for", "colIdx", ",", "vindexKey", ":=", "range", "rowColumnKeys", "{", "rowKeys", "=", "append", "(", "rowKeys", ",", "vindexKey", ")", "\n", "col", ":=", "colVindex", ".", "Columns", "[", "colIdx", "]", "\n", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "vindexKey", ")", "\n", "}", "\n", "createKeys", "=", "append", "(", "createKeys", ",", "rowKeys", ")", "\n", "}", "\n", "if", "createKeys", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "err", ":=", "colVindex", ".", "Vindex", ".", "(", "vindexes", ".", "Lookup", ")", ".", "Create", "(", "vcursor", ",", "createKeys", ",", "createKsids", ",", "true", "/* ignoreMode */", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// After creation, verify that the keys map to the keyspace ids. If not, remove", "// those that don't map.", "// If values were supplied, we validate against keyspace id.", "var", "ids", "[", "]", "sqltypes", ".", "Value", "\n", "for", "_", ",", "vindexValues", ":=", "range", "createKeys", "{", "ids", "=", "append", "(", "ids", ",", "vindexValues", "[", "0", "]", ")", "\n", "}", "\n", "verified", ",", "err", ":=", "colVindex", ".", "Vindex", ".", "Verify", "(", "vcursor", ",", "ids", ",", "createKsids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "verified", "{", "if", "!", "v", "{", "ksids", "[", "createIndexes", "[", "i", "]", "]", "=", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processOwnedIgnore", "creates", "vindex", "entries", "for", "the", "values", "of", "an", "owned", "column", "for", "InsertShardedIgnore", "." ]

[ "func", "(", "ins", "*", "Insert", ")", "processUnowned", "(", "vcursor", "VCursor", ",", "vindexColumnsKeys", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "colVindex", "*", "vindexes", ".", "ColumnVindex", ",", "bv", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "ksids", "[", "]", "[", "]", "byte", ")", "error", "{", "var", "reverseIndexes", "[", "]", "int", "\n", "var", "reverseKsids", "[", "]", "[", "]", "byte", "\n", "var", "verifyIndexes", "[", "]", "int", "\n", "var", "verifyKeys", "[", "]", "sqltypes", ".", "Value", "\n", "var", "verifyKsids", "[", "]", "[", "]", "byte", "\n\n", "for", "rowNum", ",", "rowColumnKeys", ":=", "range", "vindexColumnsKeys", "{", "// Right now, we only validate against the first column of a colvindex.", "// TODO(sougou): address this when we add multicolumn Map support.", "vindexKey", ":=", "rowColumnKeys", "[", "0", "]", "\n", "if", "ksids", "[", "rowNum", "]", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "vindexKey", ".", "IsNull", "(", ")", "{", "reverseIndexes", "=", "append", "(", "reverseIndexes", ",", "rowNum", ")", "\n", "reverseKsids", "=", "append", "(", "reverseKsids", ",", "ksids", "[", "rowNum", "]", ")", "\n", "}", "else", "{", "verifyIndexes", "=", "append", "(", "verifyIndexes", ",", "rowNum", ")", "\n", "verifyKeys", "=", "append", "(", "verifyKeys", ",", "vindexKey", ")", "\n", "verifyKsids", "=", "append", "(", "verifyKsids", ",", "ksids", "[", "rowNum", "]", ")", "\n", "}", "\n", "}", "\n\n", "// For cases where a value was not supplied, we reverse map it", "// from the keyspace id, if possible.", "if", "reverseKsids", "!=", "nil", "{", "reversible", ",", "ok", ":=", "colVindex", ".", "Vindex", ".", "(", "vindexes", ".", "Reversible", ")", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "colVindex", ".", "Columns", ")", "\n", "}", "\n", "reverseKeys", ",", "err", ":=", "reversible", ".", "ReverseMap", "(", "vcursor", ",", "reverseKsids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "i", ",", "reverseKey", ":=", "range", "reverseKeys", "{", "rowNum", ":=", "reverseIndexes", "[", "i", "]", "\n", "for", "colIdx", ",", "col", ":=", "range", "colVindex", ".", "Columns", "{", "if", "colIdx", "==", "0", "{", "// Fill the first column with the reverse-mapped value.", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "reverseKey", ")", "\n", "}", "else", "{", "// Fill other columns with supplied values.", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "vindexColumnsKeys", "[", "rowNum", "]", "[", "colIdx", "]", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "verifyKsids", "!=", "nil", "{", "// If values were supplied, we validate against keyspace id.", "verified", ",", "err", ":=", "colVindex", ".", "Vindex", ".", "Verify", "(", "vcursor", ",", "verifyKeys", ",", "verifyKsids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "i", ",", "v", ":=", "range", "verified", "{", "rowNum", ":=", "verifyIndexes", "[", "i", "]", "\n", "if", "!", "v", "{", "if", "ins", ".", "Opcode", "!=", "InsertShardedIgnore", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "vindexColumnsKeys", ",", "colVindex", ".", "Columns", ")", "\n", "}", "\n", "// InsertShardedIgnore: skip the row.", "ksids", "[", "rowNum", "]", "=", "nil", "\n", "continue", "\n", "}", "\n", "for", "colIdx", ",", "col", ":=", "range", "colVindex", ".", "Columns", "{", "bv", "[", "insertVarName", "(", "col", ",", "rowNum", ")", "]", "=", "sqltypes", ".", "ValueBindVariable", "(", "vindexColumnsKeys", "[", "rowNum", "]", "[", "colIdx", "]", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "processUnowned", "either", "reverse", "maps", "or", "validates", "the", "values", "for", "an", "unowned", "column", "." ]

[ "func", "installSignalHandlers", "(", "cancel", "func", "(", ")", ")", "{", "sigChan", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "sigChan", ",", "syscall", ".", "SIGTERM", ",", "syscall", ".", "SIGINT", ")", "\n", "go", "func", "(", ")", "{", "<-", "sigChan", "\n", "// we got a signal, cancel the current ctx", "cancel", "(", ")", "\n", "}", "(", ")", "\n", "}" ]

[ "signal", "handling", "centralized", "here" ]

[ "func", "NewError", "(", "code", "ErrorCode", ",", "node", "string", ")", "error", "{", "var", "message", "string", "\n", "switch", "code", "{", "case", "NodeExists", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "NoNode", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "NodeNotEmpty", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "Timeout", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "Interrupted", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "BadVersion", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "PartialResult", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "NoUpdateNeeded", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "case", "NoImplementation", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "default", ":", "message", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ")", "\n", "}", "\n", "return", "Error", "{", "code", ":", "code", ",", "message", ":", "message", ",", "}", "\n", "}" ]

[ "NewError", "creates", "a", "new", "topo", "error", "." ]

[ "func", "IsErrType", "(", "err", "error", ",", "code", "ErrorCode", ")", "bool", "{", "if", "e", ",", "ok", ":=", "err", ".", "(", "Error", ")", ";", "ok", "{", "return", "e", ".", "code", "==", "code", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsErrType", "returns", "true", "if", "the", "error", "has", "the", "specified", "ErrorCode", "." ]

[ "func", "newJoin", "(", "lpb", ",", "rpb", "*", "primitiveBuilder", ",", "ajoin", "*", "sqlparser", ".", "JoinTableExpr", ")", "error", "{", "// This function converts ON clauses to WHERE clauses. The WHERE clause", "// scope can see all tables, whereas the ON clause can only see the", "// participants of the JOIN. However, since the ON clause doesn't allow", "// external references, and the FROM clause doesn't allow duplicates,", "// it's safe to perform this conversion and still expect the same behavior.", "opcode", ":=", "engine", ".", "NormalJoin", "\n", "if", "ajoin", "!=", "nil", "{", "switch", "{", "case", "ajoin", ".", "Join", "==", "sqlparser", ".", "LeftJoinStr", ":", "opcode", "=", "engine", ".", "LeftJoin", "\n\n", "// For left joins, we have to push the ON clause into the RHS.", "// We do this before creating the join primitive.", "// However, variables of LHS need to be visible. To allow this,", "// we mark the LHS symtab as outer scope to the RHS, just like", "// a subquery. This make the RHS treat the LHS symbols as external.", "// This will prevent constructs from escaping out of the rpb scope.", "// At this point, the LHS symtab also contains symbols of the RHS.", "// But the RHS will hide those, as intended.", "rpb", ".", "st", ".", "Outer", "=", "lpb", ".", "st", "\n", "if", "err", ":=", "rpb", ".", "pushFilter", "(", "ajoin", ".", "Condition", ".", "On", ",", "sqlparser", ".", "WhereStr", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "ajoin", ".", "Condition", ".", "Using", "!=", "nil", ":", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "lpb", ".", "bldr", "=", "&", "join", "{", "Left", ":", "lpb", ".", "bldr", ",", "Right", ":", "rpb", ".", "bldr", ",", "ejoin", ":", "&", "engine", ".", "Join", "{", "Opcode", ":", "opcode", ",", "Vars", ":", "make", "(", "map", "[", "string", "]", "int", ")", ",", "}", ",", "}", "\n", "lpb", ".", "bldr", ".", "Reorder", "(", "0", ")", "\n", "if", "ajoin", "==", "nil", "||", "opcode", "==", "engine", ".", "LeftJoin", "{", "return", "nil", "\n", "}", "\n", "return", "lpb", ".", "pushFilter", "(", "ajoin", ".", "Condition", ".", "On", ",", "sqlparser", ".", "WhereStr", ")", "\n", "}" ]

[ "newJoin", "makes", "a", "new", "join", "using", "the", "two", "planBuilder", ".", "ajoin", "can", "be", "nil", "if", "the", "join", "is", "on", "a", "operator", ".", "lpb", "will", "contain", "the", "resulting", "join", ".", "rpb", "will", "be", "discarded", "." ]

[ "func", "NewManager", "(", "ts", "*", "topo", ".", "Server", ")", "*", "Manager", "{", "return", "&", "Manager", "{", "ts", ":", "ts", ",", "nodeManager", ":", "NewNodeManager", "(", ")", ",", "started", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "workflows", ":", "make", "(", "map", "[", "string", "]", "*", "runningWorkflow", ")", ",", "}", "\n", "}" ]

[ "NewManager", "creates", "an", "initialized", "Manager", "." ]

[ "func", "(", "m", "*", "Manager", ")", "Run", "(", "ctx", "context", ".", "Context", ")", "{", "// Save the context for all other jobs usage, and to indicate", "// the manager is running.", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "m", ".", "ctx", "!=", "nil", "{", "m", ".", "mu", ".", "Unlock", "(", ")", "\n", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "m", ".", "ctx", "=", "ctx", "\n", "m", ".", "loadAndStartJobsLocked", "(", ")", "\n", "// Signal the successful startup.", "close", "(", "m", ".", "started", ")", "\n", "m", ".", "started", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Wait for the context to be canceled.", "<-", "ctx", ".", "Done", "(", ")", "\n\n", "// Clear context and get a copy of the running jobs.", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "m", ".", "ctx", "=", "nil", "\n", "runningWorkflows", ":=", "m", ".", "workflows", "\n", "m", ".", "workflows", "=", "make", "(", "map", "[", "string", "]", "*", "runningWorkflow", ")", "\n", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Abort the running jobs. They won't save their state as", "// m.ctx is nil and they know it means we're shutting down.", "for", "_", ",", "rw", ":=", "range", "runningWorkflows", "{", "rw", ".", "cancel", "(", ")", "\n", "}", "\n", "for", "_", ",", "rw", ":=", "range", "runningWorkflows", "{", "<-", "rw", ".", "done", "\n", "}", "\n", "}" ]

[ "Run", "is", "the", "main", "entry", "point", "for", "the", "Manager", ".", "It", "will", "read", "each", "checkpoint", "from", "the", "topo", "Server", "and", "for", "the", "ones", "that", "are", "in", "the", "Running", "state", "will", "load", "them", "in", "memory", "and", "run", "them", ".", "It", "will", "not", "return", "until", "ctx", "is", "canceled", "." ]

[ "func", "(", "m", "*", "Manager", ")", "loadAndStartJobsLocked", "(", ")", "{", "uuids", ",", "err", ":=", "m", ".", "ts", ".", "GetWorkflowNames", "(", "m", ".", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "for", "_", ",", "uuid", ":=", "range", "uuids", "{", "// Load workflows from the topo server, only look at", "// 'Running' ones.", "wi", ",", "err", ":=", "m", ".", "ts", ".", "GetWorkflow", "(", "m", ".", "ctx", ",", "uuid", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "rw", ",", "err", ":=", "m", ".", "instantiateWorkflow", "(", "wi", ".", "Workflow", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ",", "wi", ".", "FactoryName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "rw", ".", "wi", "=", "wi", "\n\n", "if", "rw", ".", "wi", ".", "State", "==", "workflowpb", ".", "WorkflowState_Running", "{", "m", ".", "runWorkflow", "(", "rw", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "loadAndStartJobsLocked", "will", "try", "to", "load", "and", "start", "all", "existing", "jobs", "in", "the", "topo", "Server", ".", "It", "needs", "to", "be", "run", "holding", "m", ".", "mu", "." ]

[ "func", "(", "m", "*", "Manager", ")", "Create", "(", "ctx", "context", ".", "Context", ",", "factoryName", "string", ",", "args", "[", "]", "string", ")", "(", "string", ",", "error", ")", "{", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Find the factory.", "factory", ",", "ok", ":=", "factories", "[", "factoryName", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "factoryName", ")", "\n", "}", "\n\n", "// Create the initial workflowpb.Workflow object.", "w", ":=", "&", "workflowpb", ".", "Workflow", "{", "Uuid", ":", "gouuid", ".", "NewUUID", "(", ")", ".", "String", "(", ")", ",", "CreateTime", ":", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ",", "FactoryName", ":", "factoryName", ",", "State", ":", "workflowpb", ".", "WorkflowState_NotStarted", ",", "}", "\n\n", "// Let the factory parse the parameters and initialize the", "// object.", "if", "err", ":=", "factory", ".", "Init", "(", "m", ",", "w", ",", "args", ")", ";", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "rw", ",", "err", ":=", "m", ".", "instantiateWorkflow", "(", "w", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// Now save the workflow in the topo server.", "rw", ".", "wi", ",", "err", "=", "m", ".", "ts", ".", "CreateWorkflow", "(", "ctx", ",", "w", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "// And we're done.", "log", ".", "Infof", "(", "\"", "\"", ",", "w", ".", "Uuid", ",", "factoryName", ",", "w", ".", "Name", ")", "\n", "return", "w", ".", "Uuid", ",", "nil", "\n", "}" ]

[ "Create", "creates", "a", "workflow", "from", "the", "given", "factory", "name", "with", "the", "provided", "args", ".", "Returns", "the", "unique", "UUID", "of", "the", "workflow", ".", "The", "workflowpb", ".", "Workflow", "object", "is", "saved", "in", "the", "topo", "server", "after", "creation", "." ]

[ "func", "(", "m", "*", "Manager", ")", "Stop", "(", "ctx", "context", ".", "Context", ",", "uuid", "string", ")", "error", "{", "// Find the workflow, mark it as stopped.", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "rw", ",", "ok", ":=", "m", ".", "workflows", "[", "uuid", "]", "\n", "if", "!", "ok", "{", "m", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n", "rw", ".", "stopped", "=", "true", "\n", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "// Cancel the running guy, and waits for it.", "rw", ".", "cancel", "(", ")", "\n", "select", "{", "case", "<-", "rw", ".", "done", ":", "break", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Stop", "stops", "the", "running", "workflow", ".", "It", "will", "cancel", "its", "context", "and", "wait", "for", "it", "to", "exit", "." ]

[ "func", "(", "m", "*", "Manager", ")", "Delete", "(", "ctx", "context", ".", "Context", ",", "uuid", "string", ")", "error", "{", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "rw", ",", "ok", ":=", "m", ".", "workflows", "[", "uuid", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n", "if", "rw", ".", "wi", ".", "State", "==", "workflowpb", ".", "WorkflowState_Running", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "err", ":=", "m", ".", "ts", ".", "DeleteWorkflow", "(", "m", ".", "ctx", ",", "rw", ".", "wi", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "rw", ".", "wi", ",", "err", ")", "\n", "}", "\n", "m", ".", "nodeManager", ".", "RemoveRootNode", "(", "rw", ".", "rootNode", ")", "\n", "delete", "(", "m", ".", "workflows", ",", "uuid", ")", "\n", "return", "nil", "\n", "}" ]

[ "Delete", "deletes", "the", "finished", "or", "not", "started", "workflow", "." ]

[ "func", "(", "m", "*", "Manager", ")", "Wait", "(", "ctx", "context", ".", "Context", ",", "uuid", "string", ")", "error", "{", "// Find the workflow.", "rw", ",", "err", ":=", "m", ".", "runningWorkflow", "(", "uuid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Just wait for it.", "select", "{", "case", "<-", "rw", ".", "done", ":", "break", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Wait", "waits", "for", "the", "provided", "workflow", "to", "end", "." ]

[ "func", "(", "m", "*", "Manager", ")", "runningWorkflow", "(", "uuid", "string", ")", "(", "*", "runningWorkflow", ",", "error", ")", "{", "m", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "m", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "rw", ",", "ok", ":=", "m", ".", "workflows", "[", "uuid", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "uuid", ")", "\n", "}", "\n", "return", "rw", ",", "nil", "\n", "}" ]

[ "runningWorkflow", "returns", "a", "runningWorkflow", "by", "uuid", "." ]

[ "func", "Unregister", "(", "name", "string", ")", "{", "if", "_", ",", "ok", ":=", "factories", "[", "name", "]", ";", "!", "ok", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "else", "{", "delete", "(", "factories", ",", "name", ")", "\n", "}", "\n", "}" ]

[ "Unregister", "removes", "a", "factory", "object", ".", "Typically", "called", "from", "a", "flag", "to", "remove", "dangerous", "workflows", "." ]

[ "func", "AvailableFactories", "(", ")", "map", "[", "string", "]", "bool", "{", "result", ":=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n", "for", "n", ":=", "range", "factories", "{", "result", "[", "n", "]", "=", "true", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "AvailableFactories", "returns", "a", "map", "with", "the", "names", "of", "the", "available", "factories", "as", "keys", "and", "true", "as", "value", "." ]

[ "func", "StartManager", "(", "m", "*", "Manager", ")", "(", "*", "sync", ".", "WaitGroup", ",", "context", ".", "Context", ",", "context", ".", "CancelFunc", ")", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "wg", ":=", "&", "sync", ".", "WaitGroup", "{", "}", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "m", ".", "Run", "(", "ctx", ")", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", ")", "\n\n", "m", ".", "WaitUntilRunning", "(", ")", "\n\n", "return", "wg", ",", "ctx", ",", "cancel", "\n", "}" ]

[ "StartManager", "starts", "a", "manager", ".", "This", "function", "should", "only", "be", "used", "for", "tests", "purposes", "." ]

[ "func", "(", "ev", "*", "SplitClone", ")", "Syslog", "(", ")", "(", "syslog", ".", "Priority", ",", "string", ")", "{", "return", "syslog", ".", "LOG_INFO", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ev", ".", "Keyspace", ",", "ev", ".", "Shard", ",", "ev", ".", "Cell", ",", "ev", ".", "Status", ")", "\n", "}" ]

[ "Syslog", "writes", "a", "SplitClone", "event", "to", "syslog", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "Stream", "(", "callback", "func", "(", "*", "sqltypes", ".", "Result", ")", "error", ")", "error", "{", "qre", ".", "logStats", ".", "OriginalSQL", "=", "qre", ".", "query", "\n", "qre", ".", "logStats", ".", "PlanType", "=", "qre", ".", "plan", ".", "PlanID", ".", "String", "(", ")", "\n\n", "defer", "func", "(", "start", "time", ".", "Time", ")", "{", "tabletenv", ".", "QueryStats", ".", "Record", "(", "qre", ".", "plan", ".", "PlanID", ".", "String", "(", ")", ",", "start", ")", "\n", "tabletenv", ".", "RecordUserQuery", "(", "qre", ".", "ctx", ",", "qre", ".", "plan", ".", "TableName", "(", ")", ",", "\"", "\"", ",", "int64", "(", "time", ".", "Since", "(", "start", ")", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "if", "err", ":=", "qre", ".", "checkPermissions", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// if we have a transaction id, let's use the txPool for this query", "var", "conn", "*", "connpool", ".", "DBConn", "\n", "if", "qre", ".", "transactionID", "!=", "0", "{", "txConn", ",", "err", ":=", "qre", ".", "tsv", ".", "te", ".", "txPool", ".", "Get", "(", "qre", ".", "transactionID", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "txConn", ".", "Recycle", "(", ")", "\n", "conn", "=", "txConn", ".", "DBConn", "\n", "}", "else", "{", "dbConn", ",", "err", ":=", "qre", ".", "getStreamConn", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "dbConn", ".", "Recycle", "(", ")", "\n", "conn", "=", "dbConn", "\n", "}", "\n\n", "qd", ":=", "NewQueryDetail", "(", "qre", ".", "logStats", ".", "Ctx", ",", "conn", ")", "\n", "qre", ".", "tsv", ".", "qe", ".", "streamQList", ".", "Add", "(", "qd", ")", "\n", "defer", "qre", ".", "tsv", ".", "qe", ".", "streamQList", ".", "Remove", "(", "qd", ")", "\n\n", "return", "qre", ".", "streamFetch", "(", "conn", ",", "qre", ".", "plan", ".", "FullQuery", ",", "qre", ".", "bindVars", ",", "\"", "\"", ",", "callback", ")", "\n", "}" ]

[ "Stream", "performs", "a", "streaming", "query", "execution", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "MessageStream", "(", "callback", "func", "(", "*", "sqltypes", ".", "Result", ")", "error", ")", "error", "{", "qre", ".", "logStats", ".", "OriginalSQL", "=", "qre", ".", "query", "\n", "qre", ".", "logStats", ".", "PlanType", "=", "qre", ".", "plan", ".", "PlanID", ".", "String", "(", ")", "\n\n", "defer", "func", "(", "start", "time", ".", "Time", ")", "{", "tabletenv", ".", "QueryStats", ".", "Record", "(", "qre", ".", "plan", ".", "PlanID", ".", "String", "(", ")", ",", "start", ")", "\n", "tabletenv", ".", "RecordUserQuery", "(", "qre", ".", "ctx", ",", "qre", ".", "plan", ".", "TableName", "(", ")", ",", "\"", "\"", ",", "int64", "(", "time", ".", "Since", "(", "start", ")", ")", ")", "\n", "}", "(", "time", ".", "Now", "(", ")", ")", "\n\n", "if", "err", ":=", "qre", ".", "checkPermissions", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "done", ",", "err", ":=", "qre", ".", "tsv", ".", "messager", ".", "Subscribe", "(", "qre", ".", "ctx", ",", "qre", ".", "plan", ".", "TableName", "(", ")", ".", "String", "(", ")", ",", "func", "(", "r", "*", "sqltypes", ".", "Result", ")", "error", "{", "select", "{", "case", "<-", "qre", ".", "ctx", ".", "Done", "(", ")", ":", "return", "io", ".", "EOF", "\n", "default", ":", "}", "\n", "return", "callback", "(", "r", ")", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "<-", "done", "\n", "return", "nil", "\n", "}" ]

[ "MessageStream", "streams", "messages", "from", "a", "message", "table", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "execDirect", "(", "conn", "*", "TxConnection", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "if", "qre", ".", "plan", ".", "Fields", "!=", "nil", "{", "result", ",", "err", ":=", "qre", ".", "txFetch", "(", "conn", ",", "qre", ".", "plan", ".", "FullQuery", ",", "qre", ".", "bindVars", ",", "nil", ",", "\"", "\"", ",", "true", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "result", ".", "Fields", "=", "qre", ".", "plan", ".", "Fields", "\n", "return", "result", ",", "nil", "\n", "}", "\n", "return", "qre", ".", "txFetch", "(", "conn", ",", "qre", ".", "plan", ".", "FullQuery", ",", "qre", ".", "bindVars", ",", "nil", ",", "\"", "\"", ",", "true", ",", "false", ")", "\n", "}" ]

[ "execDirect", "is", "for", "reads", "inside", "transactions", ".", "Always", "send", "to", "MySQL", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "execSelect", "(", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "if", "qre", ".", "plan", ".", "Fields", "!=", "nil", "{", "result", ",", "err", ":=", "qre", ".", "qFetch", "(", "qre", ".", "logStats", ",", "qre", ".", "plan", ".", "FullQuery", ",", "qre", ".", "bindVars", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// result is read-only. So, let's copy it before modifying.", "newResult", ":=", "*", "result", "\n", "newResult", ".", "Fields", "=", "qre", ".", "plan", ".", "Fields", "\n", "return", "&", "newResult", ",", "nil", "\n", "}", "\n", "conn", ",", "err", ":=", "qre", ".", "getConn", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "conn", ".", "Recycle", "(", ")", "\n", "return", "qre", ".", "dbConnFetch", "(", "conn", ",", "qre", ".", "plan", ".", "FullQuery", ",", "qre", ".", "bindVars", ",", "\"", "\"", ",", "true", ")", "\n", "}" ]

[ "execSelect", "sends", "a", "query", "to", "mysql", "only", "if", "another", "identical", "query", "is", "not", "running", ".", "Otherwise", "it", "waits", "and", "reuses", "the", "result", ".", "If", "the", "plan", "is", "missng", "field", "info", "it", "sends", "the", "query", "to", "mysql", "requesting", "full", "info", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "txFetch", "(", "conn", "*", "TxConnection", ",", "parsedQuery", "*", "sqlparser", ".", "ParsedQuery", ",", "bindVars", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "extras", "map", "[", "string", "]", "sqlparser", ".", "Encodable", ",", "buildStreamComment", "string", ",", "wantfields", ",", "record", "bool", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "sql", ",", "_", ",", "err", ":=", "qre", ".", "generateFinalSQL", "(", "parsedQuery", ",", "bindVars", ",", "extras", ",", "buildStreamComment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "qr", ",", "err", ":=", "qre", ".", "execSQL", "(", "conn", ",", "sql", ",", "wantfields", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// Only record successful queries.", "if", "record", "{", "conn", ".", "RecordQuery", "(", "sql", ")", "\n", "}", "\n", "return", "qr", ",", "nil", "\n", "}" ]

[ "txFetch", "fetches", "from", "a", "TxConnection", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "dbConnFetch", "(", "conn", "*", "connpool", ".", "DBConn", ",", "parsedQuery", "*", "sqlparser", ".", "ParsedQuery", ",", "bindVars", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "buildStreamComment", "string", ",", "wantfields", "bool", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "sql", ",", "_", ",", "err", ":=", "qre", ".", "generateFinalSQL", "(", "parsedQuery", ",", "bindVars", ",", "nil", ",", "buildStreamComment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "qre", ".", "execSQL", "(", "conn", ",", "sql", ",", "wantfields", ")", "\n", "}" ]

[ "dbConnFetch", "fetches", "from", "a", "connpool", ".", "DBConn", "." ]

[ "func", "(", "qre", "*", "QueryExecutor", ")", "streamFetch", "(", "conn", "*", "connpool", ".", "DBConn", ",", "parsedQuery", "*", "sqlparser", ".", "ParsedQuery", ",", "bindVars", "map", "[", "string", "]", "*", "querypb", ".", "BindVariable", ",", "buildStreamComment", "string", ",", "callback", "func", "(", "*", "sqltypes", ".", "Result", ")", "error", ")", "error", "{", "sql", ",", "_", ",", "err", ":=", "qre", ".", "generateFinalSQL", "(", "parsedQuery", ",", "bindVars", ",", "nil", ",", "buildStreamComment", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "qre", ".", "execStreamSQL", "(", "conn", ",", "sql", ",", "callback", ")", "\n", "}" ]

[ "streamFetch", "performs", "a", "streaming", "fetch", "." ]

[ "func", "(", "f", "*", "FakeVtctlClient", ")", "FakeVtctlClientFactory", "(", "addr", "string", ")", "(", "vtctlclient", ".", "VtctlClient", ",", "error", ")", "{", "return", "f", ",", "nil", "\n", "}" ]

[ "FakeVtctlClientFactory", "always", "returns", "the", "current", "instance", "." ]

[ "func", "(", "f", "*", "FakeVtctlClient", ")", "ExecuteVtctlCommand", "(", "ctx", "context", ".", "Context", ",", "args", "[", "]", "string", ",", "actionTimeout", "time", ".", "Duration", ")", "(", "logutil", ".", "EventStream", ",", "error", ")", "{", "return", "f", ".", "FakeLoggerEventStreamingClient", ".", "StreamResult", "(", "\"", "\"", "/* addr */", ",", "args", ")", "\n", "}" ]

[ "ExecuteVtctlCommand", "is", "part", "of", "the", "vtctlclient", "interface", "." ]

[ "func", "(", "rp", "*", "ReplicatorPlan", ")", "buildExecutionPlan", "(", "fieldEvent", "*", "binlogdatapb", ".", "FieldEvent", ")", "(", "*", "TablePlan", ",", "error", ")", "{", "prelim", ":=", "rp", ".", "TablePlans", "[", "fieldEvent", ".", "TableName", "]", "\n", "if", "prelim", "==", "nil", "{", "// Unreachable code.", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fieldEvent", ".", "TableName", ")", "\n", "}", "\n", "if", "prelim", ".", "Insert", "!=", "nil", "{", "tplanv", ":=", "*", "prelim", "\n", "tplanv", ".", "Fields", "=", "fieldEvent", ".", "Fields", "\n", "return", "&", "tplanv", ",", "nil", "\n", "}", "\n", "// select * construct was used. We need to use the field names.", "tplan", ",", "err", ":=", "rp", ".", "buildFromFields", "(", "prelim", ".", "TargetName", ",", "fieldEvent", ".", "Fields", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tplan", ".", "Fields", "=", "fieldEvent", ".", "Fields", "\n", "return", "tplan", ",", "nil", "\n", "}" ]

[ "buildExecution", "plan", "uses", "the", "field", "info", "as", "input", "and", "the", "partially", "built", "TablePlan", "for", "that", "table", "to", "build", "a", "full", "plan", "." ]

[ "func", "(", "qzs", "*", "queryzRow", ")", "MysqlTimePQ", "(", ")", "string", "{", "val", ":=", "float64", "(", "qzs", ".", "mysqlTime", ")", "/", "(", "1e9", "*", "float64", "(", "qzs", ".", "Count", ")", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ")", "\n", "}" ]

[ "MysqlTimePQ", "returns", "the", "time", "per", "query", "as", "a", "string", "." ]

[ "func", "(", "qzs", "*", "queryzRow", ")", "RowsPQ", "(", ")", "string", "{", "val", ":=", "float64", "(", "qzs", ".", "Rows", ")", "/", "float64", "(", "qzs", ".", "Count", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ")", "\n", "}" ]

[ "RowsPQ", "returns", "the", "row", "count", "per", "query", "as", "a", "string", "." ]

[ "func", "(", "qzs", "*", "queryzRow", ")", "ErrorsPQ", "(", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "float64", "(", "qzs", ".", "Errors", ")", "/", "float64", "(", "qzs", ".", "Count", ")", ")", "\n", "}" ]

[ "ErrorsPQ", "returns", "the", "error", "count", "per", "query", "as", "a", "string", "." ]

[ "func", "(", "t", "*", "tableStatusList", ")", "format", "(", ")", "(", "[", "]", "string", ",", "time", ".", "Time", ")", "{", "if", "!", "t", ".", "isInitialized", "(", ")", "{", "return", "nil", ",", "time", ".", "Now", "(", ")", "\n", "}", "\n\n", "copiedRows", ":=", "uint64", "(", "0", ")", "\n", "rowCount", ":=", "uint64", "(", "0", ")", "\n", "result", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "t", ".", "tableStatuses", ")", ")", "\n", "for", "i", ",", "ts", ":=", "range", "t", ".", "tableStatuses", "{", "ts", ".", "mu", ".", "Lock", "(", ")", "\n", "if", "ts", ".", "isView", "{", "// views are not copied", "result", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ".", "name", ")", "\n", "}", "else", "if", "ts", ".", "threadsStarted", "==", "0", "{", "// we haven't started yet", "result", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ".", "name", ",", "ts", ".", "rowCount", ")", "\n", "}", "else", "if", "ts", ".", "threadsDone", "==", "ts", ".", "threadCount", "{", "// we are done with the copy", "result", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ".", "name", ",", "ts", ".", "copiedRows", ")", "\n", "}", "else", "{", "// copy is running", "// Display 0% if rowCount is 0 because the actual number of rows can be > 0", "// due to InnoDB's imperfect statistics.", "percentage", ":=", "0.0", "\n", "if", "ts", ".", "rowCount", ">", "0", "{", "percentage", "=", "float64", "(", "ts", ".", "copiedRows", ")", "/", "float64", "(", "ts", ".", "rowCount", ")", "*", "100.0", "\n", "}", "\n", "result", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ts", ".", "name", ",", "ts", ".", "threadsStarted", "-", "ts", ".", "threadsDone", ",", "ts", ".", "copiedRows", ",", "ts", ".", "rowCount", ",", "percentage", ")", "\n", "}", "\n", "copiedRows", "+=", "ts", ".", "copiedRows", "\n", "rowCount", "+=", "ts", ".", "rowCount", "\n", "ts", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "if", "rowCount", "==", "0", "||", "copiedRows", "==", "0", "{", "return", "result", ",", "now", "\n", "}", "\n", "eta", ":=", "now", ".", "Add", "(", "time", ".", "Duration", "(", "float64", "(", "now", ".", "Sub", "(", "t", ".", "startTime", ")", ")", "*", "float64", "(", "rowCount", ")", "/", "float64", "(", "copiedRows", ")", ")", ")", "\n", "return", "result", ",", "eta", "\n", "}" ]

[ "format", "returns", "a", "status", "for", "each", "table", "and", "the", "overall", "ETA", "." ]

[ "func", "NewCheckpointWriter", "(", "ts", "*", "topo", ".", "Server", ",", "checkpoint", "*", "workflowpb", ".", "WorkflowCheckpoint", ",", "wi", "*", "topo", ".", "WorkflowInfo", ")", "*", "CheckpointWriter", "{", "return", "&", "CheckpointWriter", "{", "topoServer", ":", "ts", ",", "checkpoint", ":", "checkpoint", ",", "wi", ":", "wi", ",", "}", "\n", "}" ]

[ "NewCheckpointWriter", "creates", "a", "CheckpointWriter", "." ]

[ "func", "(", "c", "*", "CheckpointWriter", ")", "UpdateTask", "(", "taskID", "string", ",", "status", "workflowpb", ".", "TaskState", ",", "err", "error", ")", "error", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "errorMessage", ":=", "\"", "\"", "\n", "if", "err", "!=", "nil", "{", "errorMessage", "=", "err", ".", "Error", "(", ")", "\n", "}", "\n\n", "t", ":=", "c", ".", "checkpoint", ".", "Tasks", "[", "taskID", "]", "\n", "t", ".", "State", "=", "status", "\n", "t", ".", "Error", "=", "errorMessage", "\n", "return", "c", ".", "saveLocked", "(", ")", "\n", "}" ]

[ "UpdateTask", "updates", "the", "task", "status", "in", "the", "checkpointing", "copy", "and", "saves", "the", "full", "checkpoint", "to", "the", "topology", "server", "." ]

[ "func", "activateTopoCustomRules", "(", "qsc", "tabletserver", ".", "Controller", ")", "{", "if", "*", "rulePath", "!=", "\"", "\"", "{", "qsc", ".", "RegisterQueryRuleSource", "(", "topoCustomRuleSource", ")", "\n\n", "cr", ",", "err", ":=", "newTopoCustomRule", "(", "qsc", ",", "*", "ruleCell", ",", "*", "rulePath", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "cr", ".", "start", "(", ")", "\n\n", "servenv", ".", "OnTerm", "(", "cr", ".", "stop", ")", "\n", "}", "\n", "}" ]

[ "activateTopoCustomRules", "activates", "topo", "dynamic", "custom", "rule", "mechanism", "." ]

[ "func", "(", "t", "*", "explainTablet", ")", "CreateTransaction", "(", "ctx", "context", ".", "Context", ",", "target", "*", "querypb", ".", "Target", ",", "dtid", "string", ",", "participants", "[", "]", "*", "querypb", ".", "Target", ")", "(", "err", "error", ")", "{", "t", ".", "mu", ".", "Lock", "(", ")", "\n", "t", ".", "currentTime", "=", "batchTime", ".", "Wait", "(", ")", "\n", "t", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "t", ".", "tsv", ".", "CreateTransaction", "(", "ctx", ",", "target", ",", "dtid", ",", "participants", ")", "\n", "}" ]

[ "CreateTransaction", "is", "part", "of", "the", "QueryService", "interface", "." ]

[ "func", "(", "t", "*", "explainTablet", ")", "Close", "(", "ctx", "context", ".", "Context", ")", "error", "{", "return", "t", ".", "tsv", ".", "Close", "(", "ctx", ")", "\n", "}" ]

[ "Close", "is", "part", "of", "the", "QueryService", "interface", "." ]

[ "func", "NewCellTabletsWatcher", "(", "ctx", "context", ".", "Context", ",", "topoServer", "*", "topo", ".", "Server", ",", "tr", "TabletRecorder", ",", "cell", "string", ",", "refreshInterval", "time", ".", "Duration", ",", "refreshKnownTablets", "bool", ",", "topoReadConcurrency", "int", ")", "*", "TopologyWatcher", "{", "return", "NewTopologyWatcher", "(", "ctx", ",", "topoServer", ",", "tr", ",", "cell", ",", "refreshInterval", ",", "refreshKnownTablets", ",", "topoReadConcurrency", ",", "func", "(", "tw", "*", "TopologyWatcher", ")", "(", "[", "]", "*", "topodatapb", ".", "TabletAlias", ",", "error", ")", "{", "return", "tw", ".", "topoServer", ".", "GetTabletsByCell", "(", "ctx", ",", "tw", ".", "cell", ")", "\n", "}", ")", "\n", "}" ]

[ "NewCellTabletsWatcher", "returns", "a", "TopologyWatcher", "that", "monitors", "all", "the", "tablets", "in", "a", "cell", "and", "starts", "refreshing", "." ]

[ "func", "NewTopologyWatcher", "(", "ctx", "context", ".", "Context", ",", "topoServer", "*", "topo", ".", "Server", ",", "tr", "TabletRecorder", ",", "cell", "string", ",", "refreshInterval", "time", ".", "Duration", ",", "refreshKnownTablets", "bool", ",", "topoReadConcurrency", "int", ",", "getTablets", "func", "(", "tw", "*", "TopologyWatcher", ")", "(", "[", "]", "*", "topodatapb", ".", "TabletAlias", ",", "error", ")", ")", "*", "TopologyWatcher", "{", "tw", ":=", "&", "TopologyWatcher", "{", "topoServer", ":", "topoServer", ",", "tr", ":", "tr", ",", "cell", ":", "cell", ",", "refreshInterval", ":", "refreshInterval", ",", "refreshKnownTablets", ":", "refreshKnownTablets", ",", "getTablets", ":", "getTablets", ",", "sem", ":", "make", "(", "chan", "int", ",", "topoReadConcurrency", ")", ",", "tablets", ":", "make", "(", "map", "[", "string", "]", "*", "tabletInfo", ")", ",", "}", "\n", "tw", ".", "firstLoadChan", "=", "make", "(", "chan", "struct", "{", "}", ")", "\n\n", "// We want the span from the context, but not the cancelation that comes with it", "spanContext", ":=", "trace", ".", "CopySpan", "(", "context", ".", "Background", "(", ")", ",", "ctx", ")", "\n", "tw", ".", "ctx", ",", "tw", ".", "cancelFunc", "=", "context", ".", "WithCancel", "(", "spanContext", ")", "\n", "tw", ".", "wg", ".", "Add", "(", "1", ")", "\n", "go", "tw", ".", "watch", "(", ")", "\n", "return", "tw", "\n", "}" ]

[ "NewTopologyWatcher", "returns", "a", "TopologyWatcher", "that", "monitors", "all", "the", "tablets", "in", "a", "cell", "and", "starts", "refreshing", "." ]

[ "func", "(", "tw", "*", "TopologyWatcher", ")", "RefreshLag", "(", ")", "time", ".", "Duration", "{", "tw", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "tw", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "time", ".", "Since", "(", "tw", ".", "lastRefresh", ")", "\n", "}" ]

[ "RefreshLag", "returns", "the", "time", "since", "the", "last", "refresh" ]

[ "func", "(", "tw", "*", "TopologyWatcher", ")", "TopoChecksum", "(", ")", "uint32", "{", "tw", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "tw", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "return", "tw", ".", "topoChecksum", "\n", "}" ]

[ "TopoChecksum", "returns", "the", "checksum", "of", "the", "current", "state", "of", "the", "topo" ]

[ "func", "NewFilterByShard", "(", "tr", "TabletRecorder", ",", "filters", "[", "]", "string", ")", "(", "*", "FilterByShard", ",", "error", ")", "{", "m", ":=", "make", "(", "map", "[", "string", "]", "[", "]", "*", "filterShard", ")", "\n", "for", "_", ",", "filter", ":=", "range", "filters", "{", "parts", ":=", "strings", ".", "Split", "(", "filter", ",", "\"", "\"", ")", "\n", "if", "len", "(", "parts", ")", "!=", "2", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "filter", ")", "\n", "}", "\n\n", "keyspace", ":=", "parts", "[", "0", "]", "\n", "shard", ":=", "parts", "[", "1", "]", "\n\n", "// extract keyrange if it's a range", "canonical", ",", "kr", ",", "err", ":=", "topo", ".", "ValidateShardName", "(", "shard", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "shard", ",", "err", ")", "\n", "}", "\n\n", "// check for duplicates", "for", "_", ",", "c", ":=", "range", "m", "[", "keyspace", "]", "{", "if", "c", ".", "shard", "==", "canonical", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyspace", ",", "shard", ")", "\n", "}", "\n", "}", "\n\n", "m", "[", "keyspace", "]", "=", "append", "(", "m", "[", "keyspace", "]", ",", "&", "filterShard", "{", "keyspace", ":", "keyspace", ",", "shard", ":", "canonical", ",", "keyRange", ":", "kr", ",", "}", ")", "\n", "}", "\n\n", "return", "&", "FilterByShard", "{", "tr", ":", "tr", ",", "filters", ":", "m", ",", "}", ",", "nil", "\n", "}" ]

[ "NewFilterByShard", "creates", "a", "new", "FilterByShard", "on", "top", "of", "an", "existing", "TabletRecorder", ".", "Each", "filter", "is", "a", "keyspace|shard", "entry", "where", "shard", "can", "either", "be", "a", "shard", "name", "or", "a", "keyrange", ".", "All", "tablets", "that", "match", "at", "least", "one", "keyspace|shard", "tuple", "will", "be", "forwarded", "to", "the", "underlying", "TabletRecorder", "." ]

[ "func", "(", "fbs", "*", "FilterByShard", ")", "AddTablet", "(", "tablet", "*", "topodatapb", ".", "Tablet", ",", "name", "string", ")", "{", "if", "fbs", ".", "isIncluded", "(", "tablet", ")", "{", "fbs", ".", "tr", ".", "AddTablet", "(", "tablet", ",", "name", ")", "\n", "}", "\n", "}" ]

[ "AddTablet", "is", "part", "of", "the", "TabletRecorder", "interface", "." ]

[ "func", "(", "fbs", "*", "FilterByShard", ")", "RemoveTablet", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "{", "if", "fbs", ".", "isIncluded", "(", "tablet", ")", "{", "fbs", ".", "tr", ".", "RemoveTablet", "(", "tablet", ")", "\n", "}", "\n", "}" ]

[ "RemoveTablet", "is", "part", "of", "the", "TabletRecorder", "interface", "." ]

[ "func", "(", "fbs", "*", "FilterByShard", ")", "ReplaceTablet", "(", "old", ",", "new", "*", "topodatapb", ".", "Tablet", ",", "name", "string", ")", "{", "if", "fbs", ".", "isIncluded", "(", "old", ")", "&&", "fbs", ".", "isIncluded", "(", "new", ")", "{", "fbs", ".", "tr", ".", "ReplaceTablet", "(", "old", ",", "new", ",", "name", ")", "\n", "}", "\n", "}" ]

[ "ReplaceTablet", "is", "part", "of", "the", "TabletRecorder", "interface", "." ]

[ "func", "(", "fbs", "*", "FilterByShard", ")", "isIncluded", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "bool", "{", "canonical", ",", "kr", ",", "err", ":=", "topo", ".", "ValidateShardName", "(", "tablet", ".", "Shard", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "tablet", ".", "Shard", ",", "err", ")", "\n", "return", "false", "\n", "}", "\n\n", "for", "_", ",", "c", ":=", "range", "fbs", ".", "filters", "[", "tablet", ".", "Keyspace", "]", "{", "if", "canonical", "==", "c", ".", "shard", "{", "// Exact match (probably a non-sharded keyspace).", "return", "true", "\n", "}", "\n", "if", "kr", "!=", "nil", "&&", "c", ".", "keyRange", "!=", "nil", "&&", "key", ".", "KeyRangeIncludes", "(", "c", ".", "keyRange", ",", "kr", ")", "{", "// Our filter's KeyRange includes the provided KeyRange", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "isIncluded", "returns", "true", "iff", "the", "tablet", "s", "keyspace", "and", "shard", "should", "be", "forwarded", "to", "the", "underlying", "TabletRecorder", "." ]