Datasets:

---

google

/

code_x_glue_ct_code_to_text

like 69

Follow

Google 13.1k

[ "func", "(", "client", "*", "gRPCVtworkerClient", ")", "ExecuteVtworkerCommand", "(", "ctx", "context", ".", "Context", ",", "args", "[", "]", "string", ")", "(", "logutil", ".", "EventStream", ",", "error", ")", "{", "query", ":=", "&", "vtworkerdatapb", ".", "ExecuteVtworkerCommandRequest", "{", "Args", ":", "args", ",", "}", "\n\n", "stream", ",", "err", ":=", "client", ".", "c", ".", "ExecuteVtworkerCommand", "(", "ctx", ",", "query", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "FromGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "eventStreamAdapter", "{", "stream", "}", ",", "nil", "\n", "}" ]

[ "ExecuteVtworkerCommand", "is", "part", "of", "the", "VtworkerClient", "interface", "." ]

[ "func", "NewClusterOperationInstance", "(", "clusterOpID", "string", ",", "initialTask", "*", "automationpb", ".", "TaskContainer", ",", "taskIDGenerator", "*", "IDGenerator", ")", "ClusterOperationInstance", "{", "c", ":=", "ClusterOperationInstance", "{", "automationpb", ".", "ClusterOperation", "{", "Id", ":", "clusterOpID", ",", "SerialTasks", ":", "[", "]", "*", "automationpb", ".", "TaskContainer", "{", "}", ",", "State", ":", "automationpb", ".", "ClusterOperationState_CLUSTER_OPERATION_NOT_STARTED", ",", "}", ",", "taskIDGenerator", ",", "}", "\n", "c", ".", "InsertTaskContainers", "(", "[", "]", "*", "automationpb", ".", "TaskContainer", "{", "initialTask", "}", ",", "0", ")", "\n", "return", "c", "\n", "}" ]

[ "NewClusterOperationInstance", "creates", "a", "new", "cluster", "operation", "instance", "with", "one", "initial", "task", "." ]

[ "func", "(", "c", "*", "ClusterOperationInstance", ")", "InsertTaskContainers", "(", "newTaskContainers", "[", "]", "*", "automationpb", ".", "TaskContainer", ",", "pos", "int", ")", "{", "AddMissingTaskID", "(", "newTaskContainers", ",", "c", ".", "taskIDGenerator", ")", "\n\n", "newSerialTasks", ":=", "make", "(", "[", "]", "*", "automationpb", ".", "TaskContainer", ",", "len", "(", "c", ".", "SerialTasks", ")", "+", "len", "(", "newTaskContainers", ")", ")", "\n", "copy", "(", "newSerialTasks", ",", "c", ".", "SerialTasks", "[", ":", "pos", "]", ")", "\n", "copy", "(", "newSerialTasks", "[", "pos", ":", "]", ",", "newTaskContainers", ")", "\n", "copy", "(", "newSerialTasks", "[", "pos", "+", "len", "(", "newTaskContainers", ")", ":", "]", ",", "c", ".", "SerialTasks", "[", "pos", ":", "]", ")", "\n", "c", ".", "SerialTasks", "=", "newSerialTasks", "\n", "}" ]

[ "InsertTaskContainers", "inserts", "newTaskContainers", "at", "pos", "in", "the", "current", "list", "of", "task", "containers", ".", "Existing", "task", "containers", "will", "be", "moved", "after", "the", "new", "task", "containers", "." ]

[ "func", "Init", "(", "path", "string", ")", "(", "FileLogger", ",", "error", ")", "{", "log", ".", "Info", "(", "\"", "\"", ",", "path", ")", "\n", "logChan", ",", "err", ":=", "tabletenv", ".", "StatsLogger", ".", "LogToFile", "(", "path", ",", "streamlog", ".", "GetFormatter", "(", "tabletenv", ".", "StatsLogger", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "fileLogger", "{", "logChan", ":", "logChan", ",", "}", ",", "nil", "\n", "}" ]

[ "Init", "starts", "logging", "to", "the", "given", "file", "path", "." ]

[ "func", "Aggregate", "(", "errors", "[", "]", "error", ")", "error", "{", "if", "len", "(", "errors", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n", "return", "New", "(", "aggregateCodes", "(", "errors", ")", ",", "aggregateErrors", "(", "errors", ")", ")", "\n", "}" ]

[ "Aggregate", "aggregates", "several", "errors", "into", "a", "single", "one", ".", "The", "resulting", "error", "code", "will", "be", "the", "one", "with", "the", "highest", "priority", "as", "defined", "by", "the", "priority", "constants", "in", "this", "package", "." ]

[ "func", "aggregateErrors", "(", "errs", "[", "]", "error", ")", "string", "{", "errStrs", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "errs", ")", ")", "\n", "for", "_", ",", "e", ":=", "range", "errs", "{", "errStrs", "=", "append", "(", "errStrs", ",", "e", ".", "Error", "(", ")", ")", "\n", "}", "\n", "// sort the error strings so we always have deterministic ordering", "sort", ".", "Strings", "(", "errStrs", ")", "\n", "return", "strings", ".", "Join", "(", "errStrs", ",", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "ConcatenateErrors", "aggregates", "an", "array", "of", "errors", "into", "a", "single", "error", "by", "string", "concatenation", "." ]

[ "func", "NewTrackedBuffer", "(", "nodeFormatter", "NodeFormatter", ")", "*", "TrackedBuffer", "{", "return", "&", "TrackedBuffer", "{", "Builder", ":", "new", "(", "strings", ".", "Builder", ")", ",", "nodeFormatter", ":", "nodeFormatter", ",", "}", "\n", "}" ]

[ "NewTrackedBuffer", "creates", "a", "new", "TrackedBuffer", "." ]

[ "func", "(", "buf", "*", "TrackedBuffer", ")", "WriteNode", "(", "node", "SQLNode", ")", "*", "TrackedBuffer", "{", "buf", ".", "Myprintf", "(", "\"", "\"", ",", "node", ")", "\n", "return", "buf", "\n", "}" ]

[ "WriteNode", "function", "initiates", "the", "writing", "of", "a", "single", "SQLNode", "tree", "by", "passing", "through", "to", "Myprintf", "with", "a", "default", "format", "string" ]

[ "func", "(", "buf", "*", "TrackedBuffer", ")", "ParsedQuery", "(", ")", "*", "ParsedQuery", "{", "return", "&", "ParsedQuery", "{", "Query", ":", "buf", ".", "String", "(", ")", ",", "bindLocations", ":", "buf", ".", "bindLocations", "}", "\n", "}" ]

[ "ParsedQuery", "returns", "a", "ParsedQuery", "that", "contains", "bind", "locations", "for", "easy", "substitution", "." ]

[ "func", "BuildParsedQuery", "(", "in", "string", ",", "vars", "...", "interface", "{", "}", ")", "*", "ParsedQuery", "{", "buf", ":=", "NewTrackedBuffer", "(", "nil", ")", "\n", "buf", ".", "Myprintf", "(", "in", ",", "vars", "...", ")", "\n", "return", "buf", ".", "ParsedQuery", "(", ")", "\n", "}" ]

[ "BuildParsedQuery", "builds", "a", "ParsedQuery", "from", "the", "input", "." ]

[ "func", "(", "q", "*", "query", ")", "Execute", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "ExecuteRequest", ")", "(", "response", "*", "querypb", ".", "ExecuteResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "result", ",", "err", ":=", "q", ".", "server", ".", "Execute", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Query", ".", "Sql", ",", "request", ".", "Query", ".", "BindVariables", ",", "request", ".", "TransactionId", ",", "request", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "ExecuteResponse", "{", "Result", ":", "sqltypes", ".", "ResultToProto3", "(", "result", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "Execute", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "ExecuteBatch", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "ExecuteBatchRequest", ")", "(", "response", "*", "querypb", ".", "ExecuteBatchResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "results", ",", "err", ":=", "q", ".", "server", ".", "ExecuteBatch", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Queries", ",", "request", ".", "AsTransaction", ",", "request", ".", "TransactionId", ",", "request", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "ExecuteBatchResponse", "{", "Results", ":", "sqltypes", ".", "ResultsToProto3", "(", "results", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "ExecuteBatch", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "StreamExecute", "(", "request", "*", "querypb", ".", "StreamExecuteRequest", ",", "stream", "queryservicepb", ".", "Query_StreamExecuteServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "stream", ".", "Context", "(", ")", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "err", "=", "q", ".", "server", ".", "StreamExecute", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Query", ".", "Sql", ",", "request", ".", "Query", ".", "BindVariables", ",", "request", ".", "TransactionId", ",", "request", ".", "Options", ",", "func", "(", "reply", "*", "sqltypes", ".", "Result", ")", "error", "{", "return", "stream", ".", "Send", "(", "&", "querypb", ".", "StreamExecuteResponse", "{", "Result", ":", "sqltypes", ".", "ResultToProto3", "(", "reply", ")", ",", "}", ")", "\n", "}", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "StreamExecute", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "Begin", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "BeginRequest", ")", "(", "response", "*", "querypb", ".", "BeginResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "transactionID", ",", "err", ":=", "q", ".", "server", ".", "Begin", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "BeginResponse", "{", "TransactionId", ":", "transactionID", ",", "}", ",", "nil", "\n", "}" ]

[ "Begin", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "Commit", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "CommitRequest", ")", "(", "response", "*", "querypb", ".", "CommitResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "Commit", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "TransactionId", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "CommitResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "Commit", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "Rollback", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "RollbackRequest", ")", "(", "response", "*", "querypb", ".", "RollbackResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "Rollback", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "TransactionId", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "RollbackResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "Rollback", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "CommitPrepared", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "CommitPreparedRequest", ")", "(", "response", "*", "querypb", ".", "CommitPreparedResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "CommitPrepared", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Dtid", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "CommitPreparedResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "CommitPrepared", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "CreateTransaction", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "CreateTransactionRequest", ")", "(", "response", "*", "querypb", ".", "CreateTransactionResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "CreateTransaction", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Dtid", ",", "request", ".", "Participants", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "CreateTransactionResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "CreateTransaction", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "StartCommit", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "StartCommitRequest", ")", "(", "response", "*", "querypb", ".", "StartCommitResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "StartCommit", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "TransactionId", ",", "request", ".", "Dtid", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "StartCommitResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "StartCommit", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "ConcludeTransaction", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "ConcludeTransactionRequest", ")", "(", "response", "*", "querypb", ".", "ConcludeTransactionResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "if", "err", ":=", "q", ".", "server", ".", "ConcludeTransaction", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Dtid", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "ConcludeTransactionResponse", "{", "}", ",", "nil", "\n", "}" ]

[ "ConcludeTransaction", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "ReadTransaction", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "ReadTransactionRequest", ")", "(", "response", "*", "querypb", ".", "ReadTransactionResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "result", ",", "err", ":=", "q", ".", "server", ".", "ReadTransaction", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Dtid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n\n", "return", "&", "querypb", ".", "ReadTransactionResponse", "{", "Metadata", ":", "result", "}", ",", "nil", "\n", "}" ]

[ "ReadTransaction", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "BeginExecute", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "BeginExecuteRequest", ")", "(", "response", "*", "querypb", ".", "BeginExecuteResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n\n", "result", ",", "transactionID", ",", "err", ":=", "q", ".", "server", ".", "BeginExecute", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Query", ".", "Sql", ",", "request", ".", "Query", ".", "BindVariables", ",", "request", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "// if we have a valid transactionID, return the error in-band", "if", "transactionID", "!=", "0", "{", "return", "&", "querypb", ".", "BeginExecuteResponse", "{", "Error", ":", "vterrors", ".", "ToVTRPC", "(", "err", ")", ",", "TransactionId", ":", "transactionID", ",", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "BeginExecuteResponse", "{", "Result", ":", "sqltypes", ".", "ResultToProto3", "(", "result", ")", ",", "TransactionId", ":", "transactionID", ",", "}", ",", "nil", "\n", "}" ]

[ "BeginExecute", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "BeginExecuteBatch", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "BeginExecuteBatchRequest", ")", "(", "response", "*", "querypb", ".", "BeginExecuteBatchResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n\n", "results", ",", "transactionID", ",", "err", ":=", "q", ".", "server", ".", "BeginExecuteBatch", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Queries", ",", "request", ".", "AsTransaction", ",", "request", ".", "Options", ")", "\n", "if", "err", "!=", "nil", "{", "// if we have a valid transactionID, return the error in-band", "if", "transactionID", "!=", "0", "{", "return", "&", "querypb", ".", "BeginExecuteBatchResponse", "{", "Error", ":", "vterrors", ".", "ToVTRPC", "(", "err", ")", ",", "TransactionId", ":", "transactionID", ",", "}", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "BeginExecuteBatchResponse", "{", "Results", ":", "sqltypes", ".", "ResultsToProto3", "(", "results", ")", ",", "TransactionId", ":", "transactionID", ",", "}", ",", "nil", "\n", "}" ]

[ "BeginExecuteBatch", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "MessageStream", "(", "request", "*", "querypb", ".", "MessageStreamRequest", ",", "stream", "queryservicepb", ".", "Query_MessageStreamServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "stream", ".", "Context", "(", ")", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "err", "=", "q", ".", "server", ".", "MessageStream", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Name", ",", "func", "(", "qr", "*", "sqltypes", ".", "Result", ")", "error", "{", "return", "stream", ".", "Send", "(", "&", "querypb", ".", "MessageStreamResponse", "{", "Result", ":", "sqltypes", ".", "ResultToProto3", "(", "qr", ")", ",", "}", ")", "\n", "}", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "MessageStream", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "MessageAck", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "MessageAckRequest", ")", "(", "response", "*", "querypb", ".", "MessageAckResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "count", ",", "err", ":=", "q", ".", "server", ".", "MessageAck", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Name", ",", "request", ".", "Ids", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "MessageAckResponse", "{", "Result", ":", "&", "querypb", ".", "QueryResult", "{", "RowsAffected", ":", "uint64", "(", "count", ")", ",", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "MessageAck", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "SplitQuery", "(", "ctx", "context", ".", "Context", ",", "request", "*", "querypb", ".", "SplitQueryRequest", ")", "(", "response", "*", "querypb", ".", "SplitQueryResponse", ",", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", "=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "ctx", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "splits", ",", "err", ":=", "q", ".", "server", ".", "SplitQuery", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Query", ",", "request", ".", "SplitColumn", ",", "request", ".", "SplitCount", ",", "request", ".", "NumRowsPerQueryPart", ",", "request", ".", "Algorithm", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}", "\n", "return", "&", "querypb", ".", "SplitQueryResponse", "{", "Queries", ":", "splits", "}", ",", "nil", "\n", "}" ]

[ "SplitQuery", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "StreamHealth", "(", "request", "*", "querypb", ".", "StreamHealthRequest", ",", "stream", "queryservicepb", ".", "Query_StreamHealthServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "err", "=", "q", ".", "server", ".", "StreamHealth", "(", "stream", ".", "Context", "(", ")", ",", "stream", ".", "Send", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "StreamHealth", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "UpdateStream", "(", "request", "*", "querypb", ".", "UpdateStreamRequest", ",", "stream", "queryservicepb", ".", "Query_UpdateStreamServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "stream", ".", "Context", "(", ")", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "err", "=", "q", ".", "server", ".", "UpdateStream", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Position", ",", "request", ".", "Timestamp", ",", "func", "(", "reply", "*", "querypb", ".", "StreamEvent", ")", "error", "{", "return", "stream", ".", "Send", "(", "&", "querypb", ".", "UpdateStreamResponse", "{", "Event", ":", "reply", ",", "}", ")", "\n", "}", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "UpdateStream", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "VStream", "(", "request", "*", "binlogdatapb", ".", "VStreamRequest", ",", "stream", "queryservicepb", ".", "Query_VStreamServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "stream", ".", "Context", "(", ")", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "err", "=", "q", ".", "server", ".", "VStream", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Position", ",", "request", ".", "Filter", ",", "func", "(", "events", "[", "]", "*", "binlogdatapb", ".", "VEvent", ")", "error", "{", "return", "stream", ".", "Send", "(", "&", "binlogdatapb", ".", "VStreamResponse", "{", "Events", ":", "events", ",", "}", ")", "\n", "}", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "VStream", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "(", "q", "*", "query", ")", "VStreamRows", "(", "request", "*", "binlogdatapb", ".", "VStreamRowsRequest", ",", "stream", "queryservicepb", ".", "Query_VStreamRowsServer", ")", "(", "err", "error", ")", "{", "defer", "q", ".", "server", ".", "HandlePanic", "(", "&", "err", ")", "\n", "ctx", ":=", "callerid", ".", "NewContext", "(", "callinfo", ".", "GRPCCallInfo", "(", "stream", ".", "Context", "(", ")", ")", ",", "request", ".", "EffectiveCallerId", ",", "request", ".", "ImmediateCallerId", ",", ")", "\n", "err", "=", "q", ".", "server", ".", "VStreamRows", "(", "ctx", ",", "request", ".", "Target", ",", "request", ".", "Query", ",", "request", ".", "Lastpk", ",", "stream", ".", "Send", ")", "\n", "return", "vterrors", ".", "ToGRPC", "(", "err", ")", "\n", "}" ]

[ "VStreamRows", "is", "part", "of", "the", "queryservice", ".", "QueryServer", "interface" ]

[ "func", "Register", "(", "s", "*", "grpc", ".", "Server", ",", "server", "queryservice", ".", "QueryService", ")", "{", "queryservicepb", ".", "RegisterQueryServer", "(", "s", ",", "&", "query", "{", "server", "}", ")", "\n", "}" ]

[ "Register", "registers", "the", "implementation", "on", "the", "provide", "gRPC", "Server", "." ]

[ "func", "NewCounter", "(", "name", "string", ",", "help", "string", ")", "*", "Counter", "{", "v", ":=", "&", "Counter", "{", "help", ":", "help", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "v", ")", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "NewCounter", "returns", "a", "new", "Counter", "." ]

[ "func", "(", "v", "*", "Counter", ")", "Add", "(", "delta", "int64", ")", "{", "if", "delta", "<", "0", "{", "logCounterNegative", ".", "Warningf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "v", ".", "i", ".", "Add", "(", "delta", ")", "\n", "}" ]

[ "Add", "adds", "the", "provided", "value", "to", "the", "Counter", "." ]

[ "func", "NewCounterFunc", "(", "name", "string", ",", "help", "string", ",", "f", "func", "(", ")", "int64", ")", "*", "CounterFunc", "{", "c", ":=", "&", "CounterFunc", "{", "F", ":", "f", ",", "help", ":", "help", ",", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "c", ")", "\n", "}", "\n", "return", "c", "\n", "}" ]

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

[ "func", "NewGauge", "(", "name", "string", ",", "help", "string", ")", "*", "Gauge", "{", "v", ":=", "&", "Gauge", "{", "Counter", ":", "Counter", "{", "help", ":", "help", "}", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "v", ")", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "NewGauge", "creates", "a", "new", "Gauge", "and", "publishes", "it", "if", "name", "is", "set", "." ]

[ "func", "(", "v", "*", "Gauge", ")", "Set", "(", "value", "int64", ")", "{", "v", ".", "Counter", ".", "i", ".", "Set", "(", "value", ")", "\n", "}" ]

[ "Set", "overwrites", "the", "current", "value", "." ]

[ "func", "(", "v", "*", "Gauge", ")", "Add", "(", "delta", "int64", ")", "{", "v", ".", "Counter", ".", "i", ".", "Add", "(", "delta", ")", "\n", "}" ]

[ "Add", "adds", "the", "provided", "value", "to", "the", "Gauge", "." ]

[ "func", "NewGaugeFunc", "(", "name", "string", ",", "help", "string", ",", "f", "func", "(", ")", "int64", ")", "*", "GaugeFunc", "{", "i", ":=", "&", "GaugeFunc", "{", "CounterFunc", ":", "CounterFunc", "{", "F", ":", "f", ",", "help", ":", "help", ",", "}", "}", "\n\n", "if", "name", "!=", "\"", "\"", "{", "publish", "(", "name", ",", "i", ")", "\n", "}", "\n", "return", "i", "\n", "}" ]

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

[ "func", "RegisterDebugHealthHandler", "(", "ts", "*", "topo", ".", "Server", ")", "{", "http", ".", "HandleFunc", "(", "\"", "\"", ",", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "if", "err", ":=", "acl", ".", "CheckAccessHTTP", "(", "r", ",", "acl", ".", "MONITORING", ")", ";", "err", "!=", "nil", "{", "acl", ".", "SendError", "(", "w", ",", "err", ")", "\n", "return", "\n", "}", "\n", "w", ".", "Header", "(", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", ":=", "isHealthy", "(", "ts", ")", ";", "err", "!=", "nil", "{", "w", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "return", "\n", "}", "\n", "w", ".", "Write", "(", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "}", ")", "\n", "}" ]

[ "RegisterDebugHealthHandler", "register", "a", "debug", "health", "http", "endpoint", "for", "a", "vtcld", "server" ]

[ "func", "LoadTable", "(", "conn", "*", "connpool", ".", "DBConn", ",", "tableName", "string", ",", "tableType", "string", ",", "comment", "string", ")", "(", "*", "Table", ",", "error", ")", "{", "ta", ":=", "NewTable", "(", "tableName", ")", "\n", "sqlTableName", ":=", "sqlparser", ".", "String", "(", "ta", ".", "Name", ")", "\n", "if", "err", ":=", "fetchColumns", "(", "ta", ",", "conn", ",", "sqlTableName", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "fetchIndexes", "(", "ta", ",", "conn", ",", "sqlTableName", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "switch", "{", "case", "strings", ".", "Contains", "(", "comment", ",", "\"", "\"", ")", ":", "ta", ".", "Type", "=", "Sequence", "\n", "ta", ".", "SequenceInfo", "=", "&", "SequenceInfo", "{", "}", "\n", "case", "strings", ".", "Contains", "(", "comment", ",", "\"", "\"", ")", ":", "if", "err", ":=", "loadMessageInfo", "(", "ta", ",", "comment", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "ta", ".", "Type", "=", "Message", "\n", "}", "\n", "return", "ta", ",", "nil", "\n", "}" ]

[ "LoadTable", "creates", "a", "Table", "from", "the", "schema", "info", "in", "the", "database", "." ]

[ "func", "(", "qri", "*", "Map", ")", "RegisterSource", "(", "ruleSource", "string", ")", "{", "qri", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "qri", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "existed", ":=", "qri", ".", "queryRulesMap", "[", "ruleSource", "]", ";", "existed", "{", "log", ".", "Errorf", "(", "\"", "\"", "+", "ruleSource", "+", "\"", "\"", ")", "\n", "panic", "(", "\"", "\"", "+", "ruleSource", "+", "\"", "\"", ")", "\n", "}", "\n", "qri", ".", "queryRulesMap", "[", "ruleSource", "]", "=", "New", "(", ")", "\n", "}" ]

[ "RegisterSource", "registers", "a", "query", "rule", "source", "name", "with", "Map", "." ]

[ "func", "(", "qri", "*", "Map", ")", "UnRegisterSource", "(", "ruleSource", "string", ")", "{", "qri", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "qri", ".", "mu", ".", "Unlock", "(", ")", "\n", "delete", "(", "qri", ".", "queryRulesMap", ",", "ruleSource", ")", "\n", "}" ]

[ "UnRegisterSource", "removes", "a", "registered", "query", "rule", "source", "name", "." ]

[ "func", "(", "qri", "*", "Map", ")", "SetRules", "(", "ruleSource", "string", ",", "newRules", "*", "Rules", ")", "error", "{", "if", "newRules", "==", "nil", "{", "newRules", "=", "New", "(", ")", "\n", "}", "\n", "qri", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "qri", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "_", ",", "ok", ":=", "qri", ".", "queryRulesMap", "[", "ruleSource", "]", ";", "ok", "{", "qri", ".", "queryRulesMap", "[", "ruleSource", "]", "=", "newRules", ".", "Copy", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", "+", "ruleSource", "+", "\"", "\"", ")", "\n", "}" ]

[ "SetRules", "takes", "an", "external", "Rules", "structure", "and", "overwrite", "one", "of", "the", "internal", "Rules", "as", "designated", "by", "ruleSource", "parameter", "." ]

[ "func", "(", "qri", "*", "Map", ")", "Get", "(", "ruleSource", "string", ")", "(", "*", "Rules", ",", "error", ")", "{", "qri", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "qri", ".", "mu", ".", "Unlock", "(", ")", "\n", "if", "ruleset", ",", "ok", ":=", "qri", ".", "queryRulesMap", "[", "ruleSource", "]", ";", "ok", "{", "return", "ruleset", ".", "Copy", "(", ")", ",", "nil", "\n", "}", "\n", "return", "New", "(", ")", ",", "errors", ".", "New", "(", "\"", "\"", "+", "ruleSource", "+", "\"", "\"", ")", "\n", "}" ]

[ "Get", "returns", "the", "corresponding", "Rules", "as", "designated", "by", "ruleSource", "parameter", "." ]

[ "func", "(", "qri", "*", "Map", ")", "FilterByPlan", "(", "query", "string", ",", "planid", "planbuilder", ".", "PlanType", ",", "tableName", "string", ")", "(", "newqrs", "*", "Rules", ")", "{", "qri", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "qri", ".", "mu", ".", "Unlock", "(", ")", "\n", "newqrs", "=", "New", "(", ")", "\n", "for", "_", ",", "rules", ":=", "range", "qri", ".", "queryRulesMap", "{", "newqrs", ".", "Append", "(", "rules", ".", "FilterByPlan", "(", "query", ",", "planid", ",", "tableName", ")", ")", "\n", "}", "\n", "return", "newqrs", "\n", "}" ]

[ "FilterByPlan", "creates", "a", "new", "Rules", "by", "prefiltering", "on", "all", "query", "rules", "that", "are", "contained", "in", "internal", "Rules", "structures", "in", "other", "words", "query", "rules", "from", "all", "predefined", "sources", "will", "be", "applied", "." ]

[ "func", "ConfigureTabletHook", "(", "hk", "*", "hook", ".", "Hook", ",", "tabletAlias", "*", "topodatapb", ".", "TabletAlias", ")", "{", "if", "hk", ".", "ExtraEnv", "==", "nil", "{", "hk", ".", "ExtraEnv", "=", "make", "(", "map", "[", "string", "]", "string", ",", "1", ")", "\n", "}", "\n", "hk", ".", "ExtraEnv", "[", "\"", "\"", "]", "=", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", "\n", "}" ]

[ "ConfigureTabletHook", "configures", "the", "right", "parameters", "for", "a", "hook", "running", "locally", "on", "a", "tablet", "." ]

[ "func", "ChangeType", "(", "ctx", "context", ".", "Context", ",", "ts", "*", "topo", ".", "Server", ",", "tabletAlias", "*", "topodatapb", ".", "TabletAlias", ",", "newType", "topodatapb", ".", "TabletType", ")", "(", "*", "topodatapb", ".", "Tablet", ",", "error", ")", "{", "return", "ts", ".", "UpdateTabletFields", "(", "ctx", ",", "tabletAlias", ",", "func", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "error", "{", "tablet", ".", "Type", "=", "newType", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "ChangeType", "changes", "the", "type", "of", "the", "tablet", ".", "Make", "this", "external", "since", "these", "transitions", "need", "to", "be", "forced", "from", "time", "to", "time", ".", "If", "successful", "the", "updated", "tablet", "record", "is", "returned", "." ]

[ "func", "CheckOwnership", "(", "oldTablet", ",", "newTablet", "*", "topodatapb", ".", "Tablet", ")", "error", "{", "if", "oldTablet", "==", "nil", "||", "newTablet", "==", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "oldTablet", ".", "Hostname", "!=", "newTablet", ".", "Hostname", "||", "oldTablet", ".", "PortMap", "[", "\"", "\"", "]", "!=", "newTablet", ".", "PortMap", "[", "\"", "\"", "]", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", "+", "\"", "\"", ",", "oldTablet", ".", "Hostname", ",", "oldTablet", ".", "PortMap", "[", "\"", "\"", "]", ",", "newTablet", ".", "Hostname", ",", "newTablet", ".", "PortMap", "[", "\"", "\"", "]", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckOwnership", "returns", "nil", "iff", "the", "Hostname", "and", "port", "match", "on", "oldTablet", "and", "newTablet", "which", "implies", "that", "no", "other", "tablet", "process", "has", "taken", "over", "the", "record", "." ]

[ "func", "TabletIdent", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "string", "{", "tagStr", ":=", "\"", "\"", "\n", "if", "tablet", ".", "Tags", "!=", "nil", "{", "for", "key", ",", "val", ":=", "range", "tablet", ".", "Tags", "{", "tagStr", "=", "tagStr", "+", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "key", ",", "val", ")", "\n", "}", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "tablet", ".", "Alias", ".", "Cell", ",", "tablet", ".", "Alias", ".", "Uid", ",", "tablet", ".", "Hostname", ",", "tagStr", ")", "\n", "}" ]

[ "TabletIdent", "returns", "a", "concise", "string", "representation", "of", "this", "tablet", "." ]

[ "func", "TargetIdent", "(", "target", "*", "querypb", ".", "Target", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "target", ".", "Keyspace", ",", "target", ".", "Shard", ",", "target", ".", "TabletType", ")", "\n", "}" ]

[ "TargetIdent", "returns", "a", "concise", "string", "representation", "of", "a", "query", "target" ]

[ "func", "CreateRecursive", "(", "ctx", "context", ".", "Context", ",", "conn", "*", "ZkConn", ",", "zkPath", "string", ",", "value", "[", "]", "byte", ",", "flags", "int32", ",", "aclv", "[", "]", "zk", ".", "ACL", ",", "maxCreationDepth", "int", ")", "(", "string", ",", "error", ")", "{", "pathCreated", ",", "err", ":=", "conn", ".", "Create", "(", "ctx", ",", "zkPath", ",", "value", ",", "flags", ",", "aclv", ")", "\n", "if", "err", "==", "zk", ".", "ErrNoNode", "{", "if", "maxCreationDepth", "==", "0", "{", "return", "\"", "\"", ",", "zk", ".", "ErrNoNode", "\n", "}", "\n\n", "// Make sure that nodes are either \"file\" or", "// \"directory\" to mirror file system semantics.", "dirAclv", ":=", "make", "(", "[", "]", "zk", ".", "ACL", ",", "len", "(", "aclv", ")", ")", "\n", "for", "i", ",", "acl", ":=", "range", "aclv", "{", "dirAclv", "[", "i", "]", "=", "acl", "\n", "dirAclv", "[", "i", "]", ".", "Perms", "=", "PermDirectory", "\n", "}", "\n", "parentPath", ":=", "path", ".", "Dir", "(", "zkPath", ")", "\n", "_", ",", "err", "=", "CreateRecursive", "(", "ctx", ",", "conn", ",", "parentPath", ",", "nil", ",", "0", ",", "dirAclv", ",", "maxCreationDepth", "-", "1", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "zk", ".", "ErrNodeExists", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "pathCreated", ",", "err", "=", "conn", ".", "Create", "(", "ctx", ",", "zkPath", ",", "value", ",", "flags", ",", "aclv", ")", "\n", "}", "\n", "return", "pathCreated", ",", "err", "\n", "}" ]

[ "CreateRecursive", "is", "a", "helper", "function", "on", "top", "of", "Create", ".", "It", "will", "create", "a", "path", "and", "any", "pieces", "required", "think", "mkdir", "-", "p", ".", "Intermediate", "znodes", "are", "always", "created", "empty", ".", "Pass", "maxCreationDepth", "=", "-", "1", "to", "create", "all", "nodes", "to", "the", "top", "." ]

[ "func", "ChildrenRecursive", "(", "ctx", "context", ".", "Context", ",", "zconn", "*", "ZkConn", ",", "zkPath", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "err", "error", "\n", "mutex", ":=", "sync", ".", "Mutex", "{", "}", "\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "pathList", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "32", ")", "\n", "children", ",", "_", ",", "err", ":=", "zconn", ".", "Children", "(", "ctx", ",", "zkPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "child", ":=", "range", "children", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "child", "string", ")", "{", "childPath", ":=", "path", ".", "Join", "(", "zkPath", ",", "child", ")", "\n", "rChildren", ",", "zkErr", ":=", "ChildrenRecursive", "(", "ctx", ",", "zconn", ",", "childPath", ")", "\n", "if", "zkErr", "!=", "nil", "{", "// If other processes are deleting nodes, we need to ignore", "// the missing nodes.", "if", "zkErr", "!=", "zk", ".", "ErrNoNode", "{", "mutex", ".", "Lock", "(", ")", "\n", "err", "=", "zkErr", "\n", "mutex", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "else", "{", "mutex", ".", "Lock", "(", ")", "\n", "pathList", "=", "append", "(", "pathList", ",", "child", ")", "\n", "for", "_", ",", "rChild", ":=", "range", "rChildren", "{", "pathList", "=", "append", "(", "pathList", ",", "path", ".", "Join", "(", "child", ",", "rChild", ")", ")", "\n", "}", "\n", "mutex", ".", "Unlock", "(", ")", "\n", "}", "\n", "wg", ".", "Done", "(", ")", "\n", "}", "(", "child", ")", "\n", "}", "\n\n", "wg", ".", "Wait", "(", ")", "\n\n", "mutex", ".", "Lock", "(", ")", "\n", "defer", "mutex", ".", "Unlock", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "pathList", ",", "nil", "\n", "}" ]

[ "ChildrenRecursive", "returns", "the", "relative", "path", "of", "all", "the", "children", "of", "the", "provided", "node", "." ]

[ "func", "DeleteRecursive", "(", "ctx", "context", ".", "Context", ",", "zconn", "*", "ZkConn", ",", "zkPath", "string", ",", "version", "int32", ")", "error", "{", "// version: -1 delete any version of the node at path - only applies to the top node", "err", ":=", "zconn", ".", "Delete", "(", "ctx", ",", "zkPath", ",", "version", ")", "\n", "if", "err", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "zk", ".", "ErrNotEmpty", "{", "return", "err", "\n", "}", "\n", "// Remove the ability for other nodes to get created while we are trying to delete.", "// Otherwise, you can enter a race condition, or get starved out from deleting.", "err", "=", "zconn", ".", "SetACL", "(", "ctx", ",", "zkPath", ",", "zk", ".", "WorldACL", "(", "zk", ".", "PermAdmin", "|", "zk", ".", "PermDelete", "|", "zk", ".", "PermRead", ")", ",", "version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "children", ",", "_", ",", "err", ":=", "zconn", ".", "Children", "(", "ctx", ",", "zkPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "child", ":=", "range", "children", "{", "err", ":=", "DeleteRecursive", "(", "ctx", ",", "zconn", ",", "path", ".", "Join", "(", "zkPath", ",", "child", ")", ",", "-", "1", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "zk", ".", "ErrNoNode", "{", "return", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "err", "=", "zconn", ".", "Delete", "(", "ctx", ",", "zkPath", ",", "version", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "zk", ".", "ErrNotEmpty", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "zkPath", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "DeleteRecursive", "will", "delete", "all", "children", "of", "the", "given", "path", "." ]

[ "func", "obtainQueueLock", "(", "ctx", "context", ".", "Context", ",", "conn", "*", "ZkConn", ",", "zkPath", "string", ")", "error", "{", "queueNode", ":=", "path", ".", "Dir", "(", "zkPath", ")", "\n", "lockNode", ":=", "path", ".", "Base", "(", "zkPath", ")", "\n\n", "for", "{", "// Get our siblings.", "children", ",", "_", ",", "err", ":=", "conn", ".", "Children", "(", "ctx", ",", "queueNode", ")", "\n", "if", "err", "!=", "nil", "{", "return", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "children", ")", "\n", "if", "len", "(", "children", ")", "==", "0", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "queueNode", ")", "\n", "}", "\n\n", "// If we are the first node, we got the lock.", "if", "children", "[", "0", "]", "==", "lockNode", "{", "return", "nil", "\n", "}", "\n\n", "// If not, find the previous node.", "prevLock", ":=", "\"", "\"", "\n", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "children", ")", ";", "i", "++", "{", "if", "children", "[", "i", "]", "==", "lockNode", "{", "prevLock", "=", "children", "[", "i", "-", "1", "]", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "prevLock", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "zkPath", ")", "\n", "}", "\n\n", "// Set a watch on the previous node.", "zkPrevLock", ":=", "path", ".", "Join", "(", "queueNode", ",", "prevLock", ")", "\n", "exists", ",", "_", ",", "watch", ",", "err", ":=", "conn", ".", "ExistsW", "(", "ctx", ",", "zkPrevLock", ")", "\n", "if", "err", "!=", "nil", "{", "return", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "zkPrevLock", ")", "\n", "}", "\n", "if", "!", "exists", "{", "// The lock disappeared, try to read again.", "continue", "\n", "}", "\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "ctx", ".", "Err", "(", ")", "\n", "case", "<-", "watch", ":", "// Something happened to the previous lock.", "// It doesn't matter what, read again.", "}", "\n", "}", "\n", "}" ]

[ "obtainQueueLock", "waits", "until", "we", "hold", "the", "lock", "in", "the", "provided", "path", ".", "The", "lexically", "lowest", "node", "is", "the", "lock", "holder", "-", "verify", "that", "this", "path", "holds", "the", "lock", ".", "Call", "this", "queue", "-", "lock", "because", "the", "semantics", "are", "a", "hybrid", ".", "Normal", "Zookeeper", "locks", "make", "assumptions", "about", "sequential", "numbering", "that", "don", "t", "hold", "when", "the", "data", "in", "a", "lock", "is", "modified", "." ]

[ "func", "NewResultMerger", "(", "inputs", "[", "]", "ResultReader", ",", "pkFieldCount", "int", ")", "(", "*", "ResultMerger", ",", "error", ")", "{", "if", "len", "(", "inputs", ")", "<", "2", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "fields", ":=", "inputs", "[", "0", "]", ".", "Fields", "(", ")", "\n\n", "if", "err", ":=", "checkFieldsEqual", "(", "fields", ",", "inputs", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "err", ":=", "CheckValidTypesForResultMerger", "(", "fields", ",", "pkFieldCount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// Initialize the priority queue with all input ResultReader which have at", "// least one row.", "var", "activeInputs", "[", "]", "ResultReader", "\n", "nextRowHeap", ":=", "newNextRowHeap", "(", "fields", ",", "pkFieldCount", ")", "\n", "for", "i", ",", "input", ":=", "range", "inputs", "{", "nextRow", ":=", "newNextRow", "(", "input", ")", "\n", "if", "err", ":=", "nextRow", ".", "next", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "continue", "\n", "}", "\n", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "i", ",", "input", ")", "\n", "}", "\n", "activeInputs", "=", "append", "(", "activeInputs", ",", "input", ")", "\n", "heap", ".", "Push", "(", "nextRowHeap", ",", "nextRow", ")", "\n", "}", "\n\n", "rm", ":=", "&", "ResultMerger", "{", "inputs", ":", "activeInputs", ",", "allInputs", ":", "inputs", ",", "fields", ":", "fields", ",", "nextRowHeap", ":", "nextRowHeap", ",", "}", "\n", "rm", ".", "reset", "(", ")", "\n", "return", "rm", ",", "nil", "\n", "}" ]

[ "NewResultMerger", "returns", "a", "new", "ResultMerger", "." ]

[ "func", "CheckValidTypesForResultMerger", "(", "fields", "[", "]", "*", "querypb", ".", "Field", ",", "pkFieldCount", "int", ")", "error", "{", "for", "i", ":=", "0", ";", "i", "<", "pkFieldCount", ";", "i", "++", "{", "typ", ":=", "fields", "[", "i", "]", ".", "Type", "\n", "if", "!", "sqltypes", ".", "IsIntegral", "(", "typ", ")", "&&", "!", "sqltypes", ".", "IsFloat", "(", "typ", ")", "&&", "!", "sqltypes", ".", "IsBinary", "(", "typ", ")", "{", "return", "vterrors", ".", "Errorf", "(", "vtrpc", ".", "Code_FAILED_PRECONDITION", ",", "\"", "\"", ",", "typ", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "CheckValidTypesForResultMerger", "returns", "an", "error", "if", "the", "provided", "fields", "are", "not", "compatible", "with", "how", "ResultMerger", "works" ]

[ "func", "(", "rm", "*", "ResultMerger", ")", "Next", "(", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "// All input readers were consumed during a merge. Return end of stream.", "if", "len", "(", "rm", ".", "inputs", ")", "==", "0", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "// Endgame mode if there is exactly one input left.", "if", "len", "(", "rm", ".", "inputs", ")", "==", "1", "&&", "rm", ".", "lastRowReaderDrained", "{", "return", "rm", ".", "inputs", "[", "0", "]", ".", "Next", "(", ")", "\n", "}", "\n\n", "// Current output buffer is not full and there is more than one input left.", "// Keep merging rows from the inputs using the priority queue.", "for", "len", "(", "rm", ".", "output", ")", "<", "ResultSizeRows", "&&", "len", "(", "rm", ".", "inputs", ")", "!=", "0", "{", "// Get the next smallest row.", "next", ":=", "heap", ".", "Pop", "(", "rm", ".", "nextRowHeap", ")", ".", "(", "*", "nextRow", ")", "\n", "// Add it to the output.", "rm", ".", "output", "=", "append", "(", "rm", ".", "output", ",", "next", ".", "row", ")", "\n", "// Check if the input we just popped has more rows.", "if", "err", ":=", "next", ".", "next", "(", ")", ";", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "// No more rows. Delete this input ResultReader from \"inputs\".", "rm", ".", "deleteInput", "(", "next", ".", "input", ")", "\n\n", "if", "len", "(", "rm", ".", "inputs", ")", "==", "1", "{", "// We just deleted the second last ResultReader from \"inputs\" i.e.", "// only one input is left. Tell the last input's RowReader to stop", "// processing new Results after the current Result. Once we read the", "// remaining rows, we can switch to the endgame mode where we read the", "// Result directly from the input.", "lastNextRow", ":=", "heap", ".", "Pop", "(", "rm", ".", "nextRowHeap", ")", ".", "(", "*", "nextRow", ")", "\n", "lastNextRow", ".", "rowReader", ".", "StopAfterCurrentResult", "(", ")", "\n", "heap", ".", "Push", "(", "rm", ".", "nextRowHeap", ",", "lastNextRow", ")", "\n", "}", "\n\n", "// Do not add back the deleted input to the priority queue.", "continue", "\n", "}", "else", "if", "err", "==", "ErrStoppedRowReader", "{", "// Endgame mode: We just consumed all rows from the last input.", "// Switch to a faster mode where we read Results from the input instead", "// of reading rows from the RowReader.", "rm", ".", "lastRowReaderDrained", "=", "true", "\n", "break", "\n", "}", "else", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "next", ".", "input", ")", "\n", "}", "\n", "}", "\n", "// Input has more rows. Add it back to the priority queue.", "heap", ".", "Push", "(", "rm", ".", "nextRowHeap", ",", "next", ")", "\n", "}", "\n\n", "result", ":=", "&", "sqltypes", ".", "Result", "{", "Fields", ":", "rm", ".", "fields", ",", "RowsAffected", ":", "uint64", "(", "len", "(", "rm", ".", "output", ")", ")", ",", "Rows", ":", "rm", ".", "output", ",", "}", "\n", "rm", ".", "reset", "(", ")", "\n\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Next", "returns", "the", "next", "Result", "in", "the", "sorted", "merged", "stream", ".", "It", "is", "part", "of", "the", "ResultReader", "interface", "." ]

[ "func", "(", "rm", "*", "ResultMerger", ")", "Close", "(", "ctx", "context", ".", "Context", ")", "{", "for", "_", ",", "i", ":=", "range", "rm", ".", "allInputs", "{", "i", ".", "Close", "(", "ctx", ")", "\n", "}", "\n", "}" ]

[ "Close", "closes", "all", "inputs" ]

[ "func", "(", "n", "*", "nextRow", ")", "next", "(", ")", "error", "{", "var", "err", "error", "\n", "n", ".", "row", ",", "err", "=", "n", ".", "rowReader", ".", "Next", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "n", ".", "row", "==", "nil", "{", "return", "io", ".", "EOF", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "next", "reads", "the", "next", "row", "from", "the", "input", ".", "It", "returns", "io", ".", "EOF", "if", "the", "input", "stream", "has", "ended", "." ]

[ "func", "(", "wr", "*", "Wrangler", ")", "waitForResults", "(", "wg", "*", "sync", ".", "WaitGroup", ",", "results", "chan", "error", ")", "error", "{", "go", "func", "(", ")", "{", "wg", ".", "Wait", "(", ")", "\n", "close", "(", "results", ")", "\n", "}", "(", ")", "\n\n", "var", "finalErr", "error", "\n", "for", "err", ":=", "range", "results", "{", "finalErr", "=", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "wr", ".", "Logger", "(", ")", ".", "Error", "(", "err", ")", "\n", "}", "\n", "return", "finalErr", "\n", "}" ]

[ "As", "with", "all", "distributed", "systems", "things", "can", "skew", ".", "These", "functions", "explore", "data", "in", "topology", "server", "and", "attempt", "to", "square", "that", "with", "reality", ".", "Given", "the", "node", "counts", "are", "usually", "large", "this", "work", "should", "be", "done", "with", "as", "much", "parallelism", "as", "is", "viable", ".", "This", "may", "eventually", "move", "into", "a", "separate", "package", ".", "waitForResults", "will", "wait", "for", "all", "the", "errors", "to", "come", "back", ".", "There", "is", "no", "timeout", "as", "individual", "calls", "will", "use", "the", "context", "and", "timeout", "and", "fail", "at", "the", "end", "anyway", "." ]

[ "func", "(", "wr", "*", "Wrangler", ")", "validateAllTablets", "(", "ctx", "context", ".", "Context", ",", "wg", "*", "sync", ".", "WaitGroup", ",", "results", "chan", "<-", "error", ")", "{", "cellSet", ":=", "make", "(", "map", "[", "string", "]", "bool", ",", "16", ")", "\n\n", "keyspaces", ",", "err", ":=", "wr", ".", "ts", ".", "GetKeyspaces", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "\n", "}", "\n", "for", "_", ",", "keyspace", ":=", "range", "keyspaces", "{", "shards", ",", "err", ":=", "wr", ".", "ts", ".", "GetShardNames", "(", "ctx", ",", "keyspace", ")", "\n", "if", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyspace", ",", "err", ")", "\n", "return", "\n", "}", "\n\n", "for", "_", ",", "shard", ":=", "range", "shards", "{", "aliases", ",", "err", ":=", "wr", ".", "ts", ".", "FindAllTabletAliasesInShard", "(", "ctx", ",", "keyspace", ",", "shard", ")", "\n", "if", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "keyspace", ",", "shard", ",", "err", ")", "\n", "return", "\n", "}", "\n", "for", "_", ",", "alias", ":=", "range", "aliases", "{", "cellSet", "[", "alias", ".", "Cell", "]", "=", "true", "\n", "}", "\n", "}", "\n", "}", "\n\n", "for", "cell", ":=", "range", "cellSet", "{", "aliases", ",", "err", ":=", "wr", ".", "ts", ".", "GetTabletsByCell", "(", "ctx", ",", "cell", ")", "\n", "if", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "cell", ",", "err", ")", "\n", "continue", "\n", "}", "\n\n", "for", "_", ",", "alias", ":=", "range", "aliases", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "alias", "*", "topodatapb", ".", "TabletAlias", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "if", "err", ":=", "topo", ".", "Validate", "(", "ctx", ",", "wr", ".", "ts", ",", "alias", ")", ";", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "topoproto", ".", "TabletAliasString", "(", "alias", ")", ",", "err", ")", "\n", "}", "else", "{", "wr", ".", "Logger", "(", ")", ".", "Infof", "(", "\"", "\"", ",", "topoproto", ".", "TabletAliasString", "(", "alias", ")", ")", "\n", "}", "\n", "}", "(", "alias", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Validate", "all", "tablets", "in", "all", "discoverable", "cells", "even", "if", "they", "are", "not", "in", "the", "replication", "graph", "." ]

[ "func", "(", "wr", "*", "Wrangler", ")", "Validate", "(", "ctx", "context", ".", "Context", ",", "pingTablets", "bool", ")", "error", "{", "// Results from various actions feed here.", "results", ":=", "make", "(", "chan", "error", ",", "16", ")", "\n", "wg", ":=", "&", "sync", ".", "WaitGroup", "{", "}", "\n\n", "// Validate all tablets in all cells, even if they are not discoverable", "// by the replication graph.", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "wr", ".", "validateAllTablets", "(", "ctx", ",", "wg", ",", "results", ")", "\n", "}", "(", ")", "\n\n", "// Validate replication graph by traversing each keyspace and then each shard.", "keyspaces", ",", "err", ":=", "wr", ".", "ts", ".", "GetKeyspaces", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "results", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "else", "{", "for", "_", ",", "keyspace", ":=", "range", "keyspaces", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "keyspace", "string", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "wr", ".", "validateKeyspace", "(", "ctx", ",", "keyspace", ",", "pingTablets", ",", "wg", ",", "results", ")", "\n", "}", "(", "keyspace", ")", "\n", "}", "\n", "}", "\n", "return", "wr", ".", "waitForResults", "(", "wg", ",", "results", ")", "\n", "}" ]

[ "Validate", "a", "whole", "TopologyServer", "tree" ]

[ "func", "(", "wr", "*", "Wrangler", ")", "ValidateKeyspace", "(", "ctx", "context", ".", "Context", ",", "keyspace", "string", ",", "pingTablets", "bool", ")", "error", "{", "wg", ":=", "&", "sync", ".", "WaitGroup", "{", "}", "\n", "results", ":=", "make", "(", "chan", "error", ",", "16", ")", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "wr", ".", "validateKeyspace", "(", "ctx", ",", "keyspace", ",", "pingTablets", ",", "wg", ",", "results", ")", "\n", "}", "(", ")", "\n", "return", "wr", ".", "waitForResults", "(", "wg", ",", "results", ")", "\n", "}" ]

[ "ValidateKeyspace", "will", "validate", "a", "bunch", "of", "information", "in", "a", "keyspace", "is", "correct", "." ]

[ "func", "(", "wr", "*", "Wrangler", ")", "ValidateShard", "(", "ctx", "context", ".", "Context", ",", "keyspace", ",", "shard", "string", ",", "pingTablets", "bool", ")", "error", "{", "wg", ":=", "&", "sync", ".", "WaitGroup", "{", "}", "\n", "results", ":=", "make", "(", "chan", "error", ",", "16", ")", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "wr", ".", "validateShard", "(", "ctx", ",", "keyspace", ",", "shard", ",", "pingTablets", ",", "wg", ",", "results", ")", "\n", "}", "(", ")", "\n", "return", "wr", ".", "waitForResults", "(", "wg", ",", "results", ")", "\n", "}" ]

[ "ValidateShard", "will", "validate", "a", "bunch", "of", "information", "in", "a", "shard", "is", "correct", "." ]

[ "func", "DatetimeToNative", "(", "v", "sqltypes", ".", "Value", ",", "loc", "*", "time", ".", "Location", ")", "(", "time", ".", "Time", ",", "error", ")", "{", "// Valid format string offsets for a DATETIME", "// |DATETIME |19+", "// |------------------|------|", "// \"2006-01-02 15:04:05.999999\"", "return", "parseISOTime", "(", "v", ".", "ToString", "(", ")", ",", "loc", ",", "19", ",", "isoTimeLength", ")", "\n", "}" ]

[ "DatetimeToNative", "converts", "a", "Datetime", "Value", "into", "a", "time", ".", "Time" ]

[ "func", "NewDatetime", "(", "t", "time", ".", "Time", ",", "defaultLoc", "*", "time", ".", "Location", ")", "sqltypes", ".", "Value", "{", "if", "t", ".", "Location", "(", ")", "!=", "defaultLoc", "{", "t", "=", "t", ".", "In", "(", "defaultLoc", ")", "\n", "}", "\n", "return", "sqltypes", ".", "MakeTrusted", "(", "sqltypes", ".", "Datetime", ",", "[", "]", "byte", "(", "t", ".", "Format", "(", "isoTimeFormat", ")", ")", ")", "\n", "}" ]

[ "NewDatetime", "builds", "a", "Datetime", "Value" ]

[ "func", "MysqlCallInfo", "(", "ctx", "context", ".", "Context", ",", "c", "*", "mysql", ".", "Conn", ")", "context", ".", "Context", "{", "return", "NewContext", "(", "ctx", ",", "&", "mysqlCallInfoImpl", "{", "remoteAddr", ":", "c", ".", "RemoteAddr", "(", ")", ".", "String", "(", ")", ",", "user", ":", "c", ".", "User", ",", "}", ")", "\n", "}" ]

[ "MysqlCallInfo", "returns", "an", "augmented", "context", "with", "a", "CallInfo", "structure", "only", "for", "Mysql", "contexts", "." ]

[ "func", "NewBlockWorker", "(", "wr", "*", "wrangler", ".", "Wrangler", ")", "(", "Worker", ",", "error", ")", "{", "return", "&", "BlockWorker", "{", "StatusWorker", ":", "NewStatusWorker", "(", ")", ",", "wr", ":", "wr", ",", "}", ",", "nil", "\n", "}" ]

[ "NewBlockWorker", "returns", "a", "new", "BlockWorker", "object", "." ]

[ "func", "(", "bw", "*", "BlockWorker", ")", "StatusAsHTML", "(", ")", "template", ".", "HTML", "{", "state", ":=", "bw", ".", "State", "(", ")", "\n\n", "result", ":=", "\"", "\\n", "\"", "\n", "result", "+=", "\"", "\"", "+", "state", ".", "String", "(", ")", "+", "\"", "\\n", "\"", "\n", "switch", "state", "{", "case", "WorkerStateDebugRunning", ":", "result", "+=", "\"", "\\n", "\"", "\n", "case", "WorkerStateDone", ":", "result", "+=", "\"", "\\n", "\"", "\n", "}", "\n\n", "return", "template", ".", "HTML", "(", "result", ")", "\n", "}" ]

[ "StatusAsHTML", "implements", "the", "Worker", "interface", "." ]

[ "func", "NewDBConn", "(", "cp", "*", "Pool", ",", "appParams", "*", "mysql", ".", "ConnParams", ")", "(", "*", "DBConn", ",", "error", ")", "{", "c", ",", "err", ":=", "dbconnpool", ".", "NewDBConnection", "(", "appParams", ",", "tabletenv", ".", "MySQLStats", ")", "\n", "if", "err", "!=", "nil", "{", "cp", ".", "checker", ".", "CheckMySQL", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "DBConn", "{", "conn", ":", "c", ",", "info", ":", "appParams", ",", "pool", ":", "cp", ",", "dbaPool", ":", "cp", ".", "dbaPool", ",", "}", ",", "nil", "\n", "}" ]

[ "NewDBConn", "creates", "a", "new", "DBConn", ".", "It", "triggers", "a", "CheckMySQL", "if", "creation", "fails", "." ]

[ "func", "NewDBConnNoPool", "(", "params", "*", "mysql", ".", "ConnParams", ",", "dbaPool", "*", "dbconnpool", ".", "ConnectionPool", ")", "(", "*", "DBConn", ",", "error", ")", "{", "c", ",", "err", ":=", "dbconnpool", ".", "NewDBConnection", "(", "params", ",", "tabletenv", ".", "MySQLStats", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "DBConn", "{", "conn", ":", "c", ",", "info", ":", "params", ",", "dbaPool", ":", "dbaPool", ",", "pool", ":", "nil", ",", "}", ",", "nil", "\n", "}" ]

[ "NewDBConnNoPool", "creates", "a", "new", "DBConn", "without", "a", "pool", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "Exec", "(", "ctx", "context", ".", "Context", ",", "query", "string", ",", "maxrows", "int", ",", "wantfields", "bool", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "span", ",", "ctx", ":=", "trace", ".", "NewSpan", "(", "ctx", ",", "\"", "\"", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "for", "attempt", ":=", "1", ";", "attempt", "<=", "2", ";", "attempt", "++", "{", "r", ",", "err", ":=", "dbc", ".", "execOnce", "(", "ctx", ",", "query", ",", "maxrows", ",", "wantfields", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "// Success.", "return", "r", ",", "nil", "\n", "case", "!", "mysql", ".", "IsConnErr", "(", "err", ")", ":", "// Not a connection error. Don't retry.", "return", "nil", ",", "err", "\n", "case", "attempt", "==", "2", ":", "// Reached the retry limit.", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Connection error. Retry if context has not expired.", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "err", "\n", "default", ":", "}", "\n\n", "if", "reconnectErr", ":=", "dbc", ".", "reconnect", "(", ")", ";", "reconnectErr", "!=", "nil", "{", "dbc", ".", "pool", ".", "checker", ".", "CheckMySQL", "(", ")", "\n", "// Return the error of the reconnect and not the original connection error.", "return", "nil", ",", "reconnectErr", "\n", "}", "\n\n", "// Reconnect succeeded. Retry query at second attempt.", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "Exec", "executes", "the", "specified", "query", ".", "If", "there", "is", "a", "connection", "error", "it", "will", "reconnect", "and", "retry", ".", "A", "failed", "reconnect", "will", "trigger", "a", "CheckMySQL", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "ExecOnce", "(", "ctx", "context", ".", "Context", ",", "query", "string", ",", "maxrows", "int", ",", "wantfields", "bool", ")", "(", "*", "sqltypes", ".", "Result", ",", "error", ")", "{", "return", "dbc", ".", "execOnce", "(", "ctx", ",", "query", ",", "maxrows", ",", "wantfields", ")", "\n", "}" ]

[ "ExecOnce", "executes", "the", "specified", "query", "but", "does", "not", "retry", "on", "connection", "errors", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "Stream", "(", "ctx", "context", ".", "Context", ",", "query", "string", ",", "callback", "func", "(", "*", "sqltypes", ".", "Result", ")", "error", ",", "streamBufferSize", "int", ",", "includedFields", "querypb", ".", "ExecuteOptions_IncludedFields", ")", "error", "{", "span", ",", "ctx", ":=", "trace", ".", "NewSpan", "(", "ctx", ",", "\"", "\"", ")", "\n", "trace", ".", "AnnotateSQL", "(", "span", ",", "query", ")", "\n", "defer", "span", ".", "Finish", "(", ")", "\n\n", "resultSent", ":=", "false", "\n", "for", "attempt", ":=", "1", ";", "attempt", "<=", "2", ";", "attempt", "++", "{", "err", ":=", "dbc", ".", "streamOnce", "(", "ctx", ",", "query", ",", "func", "(", "r", "*", "sqltypes", ".", "Result", ")", "error", "{", "if", "!", "resultSent", "{", "resultSent", "=", "true", "\n", "r", "=", "r", ".", "StripMetadata", "(", "includedFields", ")", "\n", "}", "\n", "return", "callback", "(", "r", ")", "\n", "}", ",", "streamBufferSize", ",", ")", "\n", "switch", "{", "case", "err", "==", "nil", ":", "// Success.", "return", "nil", "\n", "case", "!", "mysql", ".", "IsConnErr", "(", "err", ")", ":", "// Not a connection error. Don't retry.", "return", "err", "\n", "case", "attempt", "==", "2", ":", "// Reached the retry limit.", "return", "err", "\n", "case", "resultSent", ":", "// Don't retry if streaming has started.", "return", "err", "\n", "}", "\n\n", "// Connection error. Retry if context has not expired.", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "err", "\n", "default", ":", "}", "\n", "if", "reconnectErr", ":=", "dbc", ".", "reconnect", "(", ")", ";", "reconnectErr", "!=", "nil", "{", "dbc", ".", "pool", ".", "checker", ".", "CheckMySQL", "(", ")", "\n", "// Return the error of the reconnect and not the original connection error.", "return", "reconnectErr", "\n", "}", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "Stream", "executes", "the", "query", "and", "streams", "the", "results", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "Recycle", "(", ")", "{", "switch", "{", "case", "dbc", ".", "pool", "==", "nil", ":", "dbc", ".", "Close", "(", ")", "\n", "case", "dbc", ".", "conn", ".", "IsClosed", "(", ")", ":", "dbc", ".", "pool", ".", "Put", "(", "nil", ")", "\n", "default", ":", "dbc", ".", "pool", ".", "Put", "(", "dbc", ")", "\n", "}", "\n", "}" ]

[ "Recycle", "returns", "the", "DBConn", "to", "the", "pool", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "Kill", "(", "reason", "string", ",", "elapsed", "time", ".", "Duration", ")", "error", "{", "tabletenv", ".", "KillStats", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Infof", "(", "\"", "\"", ",", "reason", ",", "elapsed", ",", "dbc", ".", "conn", ".", "ID", "(", ")", ",", "dbc", ".", "Current", "(", ")", ")", "\n", "killConn", ",", "err", ":=", "dbc", ".", "dbaPool", ".", "Get", "(", "context", ".", "TODO", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "defer", "killConn", ".", "Recycle", "(", ")", "\n", "sql", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "dbc", ".", "conn", ".", "ID", "(", ")", ")", "\n", "_", ",", "err", "=", "killConn", ".", "ExecuteFetch", "(", "sql", ",", "10000", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "dbc", ".", "conn", ".", "ID", "(", ")", ",", "dbc", ".", "Current", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Kill", "kills", "the", "currently", "executing", "query", "both", "on", "MySQL", "side", "and", "on", "the", "connection", "side", ".", "If", "no", "query", "is", "executing", "it", "s", "a", "no", "-", "op", ".", "Kill", "will", "also", "not", "kill", "a", "query", "more", "than", "once", "." ]

[ "func", "(", "dbc", "*", "DBConn", ")", "setDeadline", "(", "ctx", "context", ".", "Context", ")", "(", "chan", "bool", ",", "*", "sync", ".", "WaitGroup", ")", "{", "if", "ctx", ".", "Done", "(", ")", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "done", ":=", "make", "(", "chan", "bool", ")", "\n", "var", "wg", "sync", ".", "WaitGroup", "\n", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "startTime", ":=", "time", ".", "Now", "(", ")", "\n", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "dbc", ".", "Kill", "(", "ctx", ".", "Err", "(", ")", ".", "Error", "(", ")", ",", "time", ".", "Since", "(", "startTime", ")", ")", "\n", "case", "<-", "done", ":", "return", "\n", "}", "\n", "elapsed", ":=", "time", ".", "Since", "(", "startTime", ")", "\n\n", "// Give 2x the elapsed time and some buffer as grace period", "// for the query to get killed.", "tmr2", ":=", "time", ".", "NewTimer", "(", "2", "*", "elapsed", "+", "5", "*", "time", ".", "Second", ")", "\n", "defer", "tmr2", ".", "Stop", "(", ")", "\n", "select", "{", "case", "<-", "tmr2", ".", "C", ":", "tabletenv", ".", "InternalErrors", ".", "Add", "(", "\"", "\"", ",", "1", ")", "\n", "log", ".", "Warningf", "(", "\"", "\"", ",", "dbc", ".", "Current", "(", ")", ")", "\n", "case", "<-", "done", ":", "return", "\n", "}", "\n", "<-", "done", "\n", "log", ".", "Warningf", "(", "\"", "\"", ")", "\n", "}", "(", ")", "\n", "return", "done", ",", "&", "wg", "\n", "}" ]

[ "setDeadline", "starts", "a", "goroutine", "that", "will", "kill", "the", "currently", "executing", "query", "if", "the", "deadline", "is", "exceeded", ".", "It", "returns", "a", "channel", "and", "a", "waitgroup", ".", "After", "the", "query", "is", "done", "executing", "the", "caller", "is", "required", "to", "close", "the", "done", "channel", "and", "wait", "for", "the", "waitgroup", "to", "make", "sure", "that", "the", "necessary", "cleanup", "is", "done", "." ]

[ "func", "(", "ts", "*", "Server", ")", "SaveVSchema", "(", "ctx", "context", ".", "Context", ",", "keyspace", "string", ",", "vschema", "*", "vschemapb", ".", "Keyspace", ")", "error", "{", "err", ":=", "vindexes", ".", "ValidateKeyspace", "(", "vschema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "nodePath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "keyspace", ",", "VSchemaFile", ")", "\n", "data", ",", "err", ":=", "proto", ".", "Marshal", "(", "vschema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "len", "(", "data", ")", "==", "0", "{", "// No vschema, remove it. So we can remove the keyspace.", "return", "ts", ".", "globalCell", ".", "Delete", "(", "ctx", ",", "nodePath", ",", "nil", ")", "\n", "}", "\n\n", "_", ",", "err", "=", "ts", ".", "globalCell", ".", "Update", "(", "ctx", ",", "nodePath", ",", "data", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "SaveVSchema", "first", "validates", "the", "VSchema", "then", "saves", "it", ".", "If", "the", "VSchema", "is", "empty", "just", "remove", "it", "." ]

[ "func", "(", "ts", "*", "Server", ")", "GetVSchema", "(", "ctx", "context", ".", "Context", ",", "keyspace", "string", ")", "(", "*", "vschemapb", ".", "Keyspace", ",", "error", ")", "{", "nodePath", ":=", "path", ".", "Join", "(", "KeyspacesPath", ",", "keyspace", ",", "VSchemaFile", ")", "\n", "data", ",", "_", ",", "err", ":=", "ts", ".", "globalCell", ".", "Get", "(", "ctx", ",", "nodePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "var", "vs", "vschemapb", ".", "Keyspace", "\n", "err", "=", "proto", ".", "Unmarshal", "(", "data", ",", "&", "vs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "data", ")", "\n", "}", "\n", "return", "&", "vs", ",", "nil", "\n", "}" ]

[ "GetVSchema", "fetches", "the", "vschema", "from", "the", "topo", "." ]

[ "func", "(", "ts", "*", "Server", ")", "SaveRoutingRules", "(", "ctx", "context", ".", "Context", ",", "routingRules", "*", "vschemapb", ".", "RoutingRules", ")", "error", "{", "data", ",", "err", ":=", "proto", ".", "Marshal", "(", "routingRules", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "len", "(", "data", ")", "==", "0", "{", "// No vschema, remove it. So we can remove the keyspace.", "return", "ts", ".", "globalCell", ".", "Delete", "(", "ctx", ",", "RoutingRulesFile", ",", "nil", ")", "\n", "}", "\n\n", "_", ",", "err", "=", "ts", ".", "globalCell", ".", "Update", "(", "ctx", ",", "RoutingRulesFile", ",", "data", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "SaveRoutingRules", "saves", "the", "routing", "rules", "into", "the", "topo", "." ]

[ "func", "(", "ts", "*", "Server", ")", "GetRoutingRules", "(", "ctx", "context", ".", "Context", ")", "(", "*", "vschemapb", ".", "RoutingRules", ",", "error", ")", "{", "rr", ":=", "&", "vschemapb", ".", "RoutingRules", "{", "}", "\n", "data", ",", "_", ",", "err", ":=", "ts", ".", "globalCell", ".", "Get", "(", "ctx", ",", "RoutingRulesFile", ")", "\n", "if", "err", "!=", "nil", "{", "if", "IsErrType", "(", "err", ",", "NoNode", ")", "{", "return", "rr", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "err", "=", "proto", ".", "Unmarshal", "(", "data", ",", "rr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "data", ")", "\n", "}", "\n", "return", "rr", ",", "nil", "\n", "}" ]

[ "GetRoutingRules", "fetches", "the", "routing", "rules", "from", "the", "topo", "." ]

[ "func", "MarkTaskSucceeded", "(", "t", "*", "automationpb", ".", "Task", ",", "output", "string", ")", "{", "t", ".", "State", "=", "automationpb", ".", "TaskState_DONE", "\n", "t", ".", "Output", "=", "output", "\n", "}" ]

[ "Helper", "functions", "for", "Task", "protobuf", "message", ".", "MarkTaskSucceeded", "marks", "the", "task", "as", "done", "." ]

[ "func", "MarkTaskFailed", "(", "t", "*", "automationpb", ".", "Task", ",", "output", "string", ",", "err", "error", ")", "{", "t", ".", "State", "=", "automationpb", ".", "TaskState_DONE", "\n", "t", ".", "Output", "=", "output", "\n", "t", ".", "Error", "=", "err", ".", "Error", "(", ")", "\n", "}" ]

[ "MarkTaskFailed", "marks", "the", "task", "as", "failed", "." ]

[ "func", "NewTask", "(", "taskName", "string", ",", "parameters", "map", "[", "string", "]", "string", ")", "*", "automationpb", ".", "Task", "{", "return", "&", "automationpb", ".", "Task", "{", "State", ":", "automationpb", ".", "TaskState_NOT_STARTED", ",", "Name", ":", "taskName", ",", "Parameters", ":", "parameters", ",", "}", "\n", "}" ]

[ "NewTask", "creates", "a", "new", "task", "protobuf", "message", "for", "taskName", "with", "parameters", "." ]

[ "func", "ReadMycnf", "(", "mycnf", "*", "Mycnf", ")", "(", "*", "Mycnf", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "mycnf", ".", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "buf", ":=", "bufio", ".", "NewReader", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mycnf", ".", "mycnfMap", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "var", "lval", ",", "rval", "string", "\n", "var", "parts", "[", "]", "[", "]", "byte", "\n\n", "for", "{", "line", ",", "_", ",", "err", ":=", "buf", ".", "ReadLine", "(", ")", "\n", "if", "err", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "line", "=", "bytes", ".", "TrimSpace", "(", "line", ")", "\n\n", "parts", "=", "bytes", ".", "Split", "(", "line", ",", "[", "]", "byte", "(", "\"", "\"", ")", ")", "\n", "if", "len", "(", "parts", ")", "<", "2", "{", "continue", "\n", "}", "\n", "lval", "=", "normKey", "(", "parts", "[", "0", "]", ")", "\n", "rval", "=", "string", "(", "bytes", ".", "TrimSpace", "(", "parts", "[", "1", "]", ")", ")", "\n", "mycnf", ".", "mycnfMap", "[", "lval", "]", "=", "rval", "\n", "}", "\n\n", "serverID", ",", "err", ":=", "mycnf", ".", "lookupInt", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mycnf", ".", "ServerID", "=", "uint32", "(", "serverID", ")", "\n\n", "port", ",", "err", ":=", "mycnf", ".", "lookupInt", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "mycnf", ".", "MysqlPort", "=", "int32", "(", "port", ")", "\n\n", "mapping", ":=", "map", "[", "string", "]", "*", "string", "{", "\"", "\"", ":", "&", "mycnf", ".", "DataDir", ",", "\"", "\"", ":", "&", "mycnf", ".", "InnodbDataHomeDir", ",", "\"", "\"", ":", "&", "mycnf", ".", "InnodbLogGroupHomeDir", ",", "\"", "\"", ":", "&", "mycnf", ".", "SocketFile", ",", "\"", "\"", ":", "&", "mycnf", ".", "GeneralLogPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "ErrorLogPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "SlowLogPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "RelayLogPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "RelayLogIndexPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "RelayLogInfoPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "BinLogPath", ",", "\"", "\"", ":", "&", "mycnf", ".", "MasterInfoFile", ",", "\"", "\"", ":", "&", "mycnf", ".", "PidFile", ",", "\"", "\"", ":", "&", "mycnf", ".", "TmpDir", ",", "\"", "\"", ":", "&", "mycnf", ".", "SlaveLoadTmpDir", ",", "}", "\n", "for", "key", ",", "member", ":=", "range", "mapping", "{", "val", ",", "err", ":=", "mycnf", ".", "lookupWithDefault", "(", "key", ",", "*", "member", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "*", "member", "=", "val", "\n", "}", "\n\n", "return", "mycnf", ",", "nil", "\n", "}" ]

[ "ReadMycnf", "will", "read", "an", "existing", "my", ".", "cnf", "from", "disk", "and", "update", "the", "passed", "in", "Mycnf", "object", "with", "values", "from", "the", "my", ".", "cnf", "on", "disk", "." ]

[ "func", "(", "sq", "*", "Subquery", ")", "buildResult", "(", "inner", "*", "sqltypes", ".", "Result", ")", "*", "sqltypes", ".", "Result", "{", "result", ":=", "&", "sqltypes", ".", "Result", "{", "Fields", ":", "sq", ".", "buildFields", "(", "inner", ")", "}", "\n", "result", ".", "Rows", "=", "make", "(", "[", "]", "[", "]", "sqltypes", ".", "Value", ",", "0", ",", "len", "(", "inner", ".", "Rows", ")", ")", "\n", "for", "_", ",", "innerRow", ":=", "range", "inner", ".", "Rows", "{", "row", ":=", "make", "(", "[", "]", "sqltypes", ".", "Value", ",", "0", ",", "len", "(", "sq", ".", "Cols", ")", ")", "\n", "for", "_", ",", "col", ":=", "range", "sq", ".", "Cols", "{", "row", "=", "append", "(", "row", ",", "innerRow", "[", "col", "]", ")", "\n", "}", "\n", "result", ".", "Rows", "=", "append", "(", "result", ".", "Rows", ",", "row", ")", "\n", "}", "\n", "result", ".", "RowsAffected", "=", "inner", ".", "RowsAffected", "\n", "return", "result", "\n", "}" ]

[ "buildResult", "builds", "a", "new", "result", "by", "pulling", "the", "necessary", "columns", "from", "the", "subquery", "in", "the", "requested", "order", "." ]

[ "func", "(", "cleaner", "*", "Cleaner", ")", "Record", "(", "name", ",", "target", "string", ",", "action", "CleanerFunction", ")", "{", "cleaner", ".", "mu", ".", "Lock", "(", ")", "\n", "cleaner", ".", "actions", "=", "append", "(", "cleaner", ".", "actions", ",", "cleanerActionReference", "{", "name", ":", "name", ",", "target", ":", "target", ",", "action", ":", "action", ",", "}", ")", "\n", "cleaner", ".", "mu", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Record", "will", "add", "a", "cleaning", "action", "to", "the", "list" ]

[ "func", "RecordChangeSlaveTypeAction", "(", "cleaner", "*", "Cleaner", ",", "tabletAlias", "*", "topodatapb", ".", "TabletAlias", ",", "from", "topodatapb", ".", "TabletType", ",", "to", "topodatapb", ".", "TabletType", ")", "{", "cleaner", ".", "Record", "(", "ChangeSlaveTypeActionName", ",", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", ",", "func", "(", "ctx", "context", ".", "Context", ",", "wr", "*", "Wrangler", ")", "error", "{", "ti", ",", "err", ":=", "wr", ".", "ts", ".", "GetTablet", "(", "ctx", ",", "tabletAlias", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "ti", ".", "Type", "!=", "from", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", ",", "ti", ".", "Type", ",", "from", ",", "to", ")", "\n", "}", "\n", "if", "!", "topo", ".", "IsTrivialTypeChange", "(", "ti", ".", "Type", ",", "to", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "topoproto", ".", "TabletAliasString", "(", "tabletAlias", ")", ",", "ti", ".", "Type", ",", "to", ")", "\n", "}", "\n\n", "// ask the tablet to make the change", "return", "wr", ".", "tmc", ".", "ChangeType", "(", "ctx", ",", "ti", ".", "Tablet", ",", "to", ")", "\n", "}", ")", "\n", "}" ]

[ "RecordChangeSlaveTypeAction", "records", "a", "new", "ChangeSlaveTypeAction", "into", "the", "specified", "Cleaner" ]

[ "func", "RecordStartSlaveAction", "(", "cleaner", "*", "Cleaner", ",", "tablet", "*", "topodatapb", ".", "Tablet", ")", "{", "cleaner", ".", "Record", "(", "StartSlaveActionName", ",", "topoproto", ".", "TabletAliasString", "(", "tablet", ".", "Alias", ")", ",", "func", "(", "ctx", "context", ".", "Context", ",", "wr", "*", "Wrangler", ")", "error", "{", "return", "wr", ".", "TabletManagerClient", "(", ")", ".", "StartSlave", "(", "ctx", ",", "tablet", ")", "\n", "}", ")", "\n", "}" ]

[ "RecordStartSlaveAction", "records", "a", "new", "action", "to", "restart", "binlog", "replication", "on", "a", "server", "into", "the", "specified", "Cleaner" ]

[ "func", "RecordVReplicationAction", "(", "cleaner", "*", "Cleaner", ",", "tablet", "*", "topodatapb", ".", "Tablet", ",", "query", "string", ")", "{", "cleaner", ".", "Record", "(", "VReplicationActionName", ",", "topoproto", ".", "TabletAliasString", "(", "tablet", ".", "Alias", ")", ",", "func", "(", "ctx", "context", ".", "Context", ",", "wr", "*", "Wrangler", ")", "error", "{", "_", ",", "err", ":=", "wr", ".", "TabletManagerClient", "(", ")", ".", "VReplicationExec", "(", "ctx", ",", "tablet", ",", "query", ")", "\n", "return", "err", "\n", "}", ")", "\n", "}" ]

[ "RecordVReplicationAction", "records", "an", "action", "to", "restart", "binlog", "replication", "on", "a", "server", "into", "the", "specified", "Cleaner" ]

[ "func", "NewKeyspaceFilteringServer", "(", "underlying", "Server", ",", "selectedKeyspaces", "[", "]", "string", ")", "(", "Server", ",", "error", ")", "{", "if", "underlying", "==", "nil", "{", "return", "nil", ",", "ErrNilUnderlyingServer", "\n", "}", "\n\n", "keyspaces", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "for", "_", ",", "ks", ":=", "range", "selectedKeyspaces", "{", "keyspaces", "[", "ks", "]", "=", "true", "\n", "}", "\n\n", "return", "keyspaceFilteringServer", "{", "server", ":", "underlying", ",", "selectKeyspaces", ":", "keyspaces", ",", "}", ",", "nil", "\n", "}" ]

[ "NewKeyspaceFilteringServer", "constructs", "a", "new", "server", "based", "on", "the", "provided", "implementation", "that", "prevents", "the", "specified", "keyspaces", "from", "being", "exposed", "to", "consumers", "of", "the", "new", "Server", ".", "A", "filtering", "server", "will", "not", "allow", "access", "to", "the", "topo", ".", "Server", "to", "prevent", "updates", "that", "may", "corrupt", "the", "global", "VSchema", "keyspace", "." ]

[ "func", "keyspacesWithServedFrom", "(", "ctx", "context", ".", "Context", ",", "wr", "*", "wrangler", ".", "Wrangler", ")", "(", "[", "]", "string", ",", "error", ")", "{", "shortCtx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "*", "remoteActionsTimeout", ")", "\n", "keyspaces", ",", "err", ":=", "wr", ".", "TopoServer", "(", ")", ".", "GetKeyspaces", "(", "shortCtx", ")", "\n", "cancel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "wg", ":=", "sync", ".", "WaitGroup", "{", "}", "\n", "mu", ":=", "sync", ".", "Mutex", "{", "}", "// protects result", "\n", "result", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "keyspaces", ")", ")", "\n", "rec", ":=", "concurrency", ".", "AllErrorRecorder", "{", "}", "\n", "for", "_", ",", "keyspace", ":=", "range", "keyspaces", "{", "wg", ".", "Add", "(", "1", ")", "\n", "go", "func", "(", "keyspace", "string", ")", "{", "defer", "wg", ".", "Done", "(", ")", "\n", "shortCtx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "ctx", ",", "*", "remoteActionsTimeout", ")", "\n", "ki", ",", "err", ":=", "wr", ".", "TopoServer", "(", ")", ".", "GetKeyspace", "(", "shortCtx", ",", "keyspace", ")", "\n", "cancel", "(", ")", "\n", "if", "err", "!=", "nil", "{", "rec", ".", "RecordError", "(", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "keyspace", ")", ")", "\n", "return", "\n", "}", "\n", "if", "len", "(", "ki", ".", "ServedFroms", ")", ">", "0", "{", "mu", ".", "Lock", "(", ")", "\n", "result", "=", "append", "(", "result", ",", "keyspace", ")", "\n", "mu", ".", "Unlock", "(", ")", "\n", "}", "\n", "}", "(", "keyspace", ")", "\n", "}", "\n", "wg", ".", "Wait", "(", ")", "\n\n", "if", "rec", ".", "HasErrors", "(", ")", "{", "return", "nil", ",", "rec", ".", "Error", "(", ")", "\n", "}", "\n", "if", "len", "(", "result", ")", "==", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "keyspacesWithServedFrom", "returns", "all", "the", "keyspaces", "that", "have", "ServedFrom", "set", "to", "one", "value", "." ]

[ "func", "newOrcClient", "(", ")", "(", "*", "orcClient", ",", "error", ")", "{", "if", "*", "orcAddr", "==", "\"", "\"", "{", "// Orchestrator integration is disabled.", "return", "nil", ",", "nil", "\n", "}", "\n", "apiRoot", ",", "err", ":=", "url", ".", "Parse", "(", "*", "orcAddr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "vterrors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "*", "orcAddr", ")", "\n", "}", "\n", "return", "&", "orcClient", "{", "apiRoot", ":", "apiRoot", ",", "httpClient", ":", "&", "http", ".", "Client", "{", "Timeout", ":", "*", "orcTimeout", "}", ",", "}", ",", "nil", "\n", "}" ]

[ "newOrcClient", "creates", "a", "client", "for", "the", "Orchestrator", "HTTP", "API", ".", "It", "should", "only", "be", "called", "after", "flags", "have", "been", "parsed", "." ]

[ "func", "(", "orc", "*", "orcClient", ")", "Discover", "(", "tablet", "*", "topodatapb", ".", "Tablet", ")", "error", "{", "host", ",", "port", ",", "err", ":=", "mysqlHostPort", "(", "tablet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "orc", ".", "apiGet", "(", "\"", "\"", ",", "host", ",", "port", ")", "\n", "return", "err", "\n", "}" ]

[ "Discover", "executes", "a", "single", "attempt", "to", "self", "-", "register", "with", "Orchestrator", "." ]

[ "func", "NewRowAggregator", "(", "ctx", "context", ".", "Context", ",", "maxRows", ",", "maxSize", "int", ",", "insertChannel", "chan", "string", ",", "dbName", "string", ",", "td", "*", "tabletmanagerdatapb", ".", "TableDefinition", ",", "diffType", "DiffType", ",", "statsCounters", "*", "stats", ".", "CountersWithSingleLabel", ")", "*", "RowAggregator", "{", "// Construct head and tail base commands for the reconciliation statement.", "var", "builder", "QueryBuilder", "\n", "switch", "diffType", "{", "case", "DiffMissing", ":", "// Example: INSERT INTO test (id, sub_id, msg) VALUES (0, 10, 'a'), (1, 11, 'b')", "builder", "=", "NewInsertsQueryBuilder", "(", "dbName", ",", "td", ")", "\n", "case", "DiffNotEqual", ":", "// Example: UPDATE test SET msg='a' WHERE id=0 AND sub_id=10", "builder", "=", "NewUpdatesQueryBuilder", "(", "dbName", ",", "td", ")", "\n", "// UPDATE ... SET does not support multiple rows as input.", "maxRows", "=", "1", "\n", "case", "DiffExtraneous", ":", "// Example: DELETE FROM test WHERE (id, sub_id) IN ((0, 10), (1, 11))", "builder", "=", "NewDeletesQueryBuilder", "(", "dbName", ",", "td", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "diffType", ")", ")", "\n", "}", "\n\n", "return", "&", "RowAggregator", "{", "ctx", ":", "ctx", ",", "maxRows", ":", "maxRows", ",", "maxSize", ":", "maxSize", ",", "insertChannel", ":", "insertChannel", ",", "td", ":", "td", ",", "diffType", ":", "diffType", ",", "builder", ":", "builder", ",", "statsCounters", ":", "statsCounters", ",", "}", "\n", "}" ]

[ "NewRowAggregator", "returns", "a", "RowAggregator", ".", "The", "index", "of", "the", "elements", "in", "statCounters", "must", "match", "the", "elements", "in", "DiffTypes", "i", ".", "e", ".", "the", "first", "counter", "is", "for", "inserts", "second", "for", "updates", "and", "the", "third", "for", "deletes", "." ]

[ "func", "(", "ra", "*", "RowAggregator", ")", "Add", "(", "row", "[", "]", "sqltypes", ".", "Value", ")", "error", "{", "if", "ra", ".", "buffer", ".", "Len", "(", ")", "==", "0", "{", "ra", ".", "builder", ".", "WriteHead", "(", "&", "ra", ".", "buffer", ")", "\n", "}", "\n\n", "if", "ra", ".", "bufferedRows", ">=", "1", "{", "ra", ".", "builder", ".", "WriteSeparator", "(", "&", "ra", ".", "buffer", ")", "\n", "}", "\n", "ra", ".", "builder", ".", "WriteRow", "(", "&", "ra", ".", "buffer", ",", "row", ")", "\n", "ra", ".", "bufferedRows", "++", "\n\n", "if", "ra", ".", "bufferedRows", ">=", "ra", ".", "maxRows", "||", "ra", ".", "buffer", ".", "Len", "(", ")", ">=", "ra", ".", "maxSize", "{", "if", "err", ":=", "ra", ".", "Flush", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Add", "will", "add", "a", "new", "row", "which", "must", "be", "reconciled", ".", "If", "an", "error", "is", "returned", "RowAggregator", "will", "be", "in", "an", "undefined", "state", "and", "must", "not", "be", "used", "any", "longer", "." ]

[ "func", "(", "ra", "*", "RowAggregator", ")", "Flush", "(", ")", "error", "{", "if", "ra", ".", "buffer", ".", "Len", "(", ")", "==", "0", "{", "// Already flushed.", "return", "nil", "\n", "}", "\n\n", "ra", ".", "builder", ".", "WriteTail", "(", "&", "ra", ".", "buffer", ")", "\n", "// select blocks until sending the SQL succeeded or the context was canceled.", "select", "{", "case", "ra", ".", "insertChannel", "<-", "ra", ".", "buffer", ".", "String", "(", ")", ":", "case", "<-", "ra", ".", "ctx", ".", "Done", "(", ")", ":", "return", "vterrors", ".", "Wrap", "(", "ra", ".", "ctx", ".", "Err", "(", ")", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Update our statistics.", "ra", ".", "statsCounters", ".", "Add", "(", "ra", ".", "td", ".", "Name", ",", "int64", "(", "ra", ".", "bufferedRows", ")", ")", "\n\n", "ra", ".", "buffer", ".", "Reset", "(", ")", "\n", "ra", ".", "bufferedRows", "=", "0", "\n", "return", "nil", "\n", "}" ]

[ "Flush", "sends", "out", "the", "current", "aggregation", "buffer", "." ]

[ "func", "(", "b", "*", "BaseQueryBuilder", ")", "WriteHead", "(", "buffer", "*", "bytes", ".", "Buffer", ")", "{", "buffer", ".", "WriteString", "(", "b", ".", "head", ")", "\n", "}" ]

[ "WriteHead", "implements", "the", "QueryBuilder", "interface", "." ]

[ "func", "(", "b", "*", "BaseQueryBuilder", ")", "WriteTail", "(", "buffer", "*", "bytes", ".", "Buffer", ")", "{", "buffer", ".", "WriteString", "(", "b", ".", "tail", ")", "\n", "}" ]

[ "WriteTail", "implements", "the", "QueryBuilder", "interface", "." ]

[ "func", "(", "b", "*", "BaseQueryBuilder", ")", "WriteSeparator", "(", "buffer", "*", "bytes", ".", "Buffer", ")", "{", "if", "b", ".", "separator", "==", "\"", "\"", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "buffer", ".", "WriteString", "(", "b", ".", "separator", ")", "\n", "}" ]

[ "WriteSeparator", "implements", "the", "QueryBuilder", "interface", "." ]