Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "InferType", "(", "sc", "*", "variable", ".", "StatementContext", ",", "node", "ast", ".", "Node", ")", "error", "{", "var", "inferrer", "typeInferrer", "\n", "inferrer", ".", "sc", "=", "sc", "\n", "// TODO: get the default charset from ctx", "inferrer", ".", "defaultCharset", "=", "\"", "\"", "\n", "node", ".", "Accept", "(", "&", "inferrer", ")", "\n", "return", "inferrer", ".", "err", "\n", "}" ]

[ "InferType", "infers", "result", "type", "for", "ast", ".", "ExprNode", "." ]

[ "func", "(", "v", "*", "typeInferrer", ")", "handleCaseExpr", "(", "x", "*", "ast", ".", "CaseExpr", ")", "{", "var", "currType", "types", ".", "FieldType", "\n", "for", "_", ",", "w", ":=", "range", "x", ".", "WhenClauses", "{", "t", ":=", "w", ".", "Result", ".", "GetType", "(", ")", "\n", "if", "currType", ".", "Tp", "==", "mysql", ".", "TypeUnspecified", "{", "currType", "=", "*", "t", "\n", "continue", "\n", "}", "\n", "mtp", ":=", "types", ".", "MergeFieldType", "(", "currType", ".", "Tp", ",", "t", ".", "Tp", ")", "\n", "if", "mtp", "==", "t", ".", "Tp", "&&", "mtp", "!=", "currType", ".", "Tp", "{", "currType", ".", "Charset", "=", "t", ".", "Charset", "\n", "currType", ".", "Collate", "=", "t", ".", "Collate", "\n", "}", "\n", "currType", ".", "Tp", "=", "mtp", "\n\n", "}", "\n", "if", "x", ".", "ElseClause", "!=", "nil", "{", "t", ":=", "x", ".", "ElseClause", ".", "GetType", "(", ")", "\n", "if", "currType", ".", "Tp", "==", "mysql", ".", "TypeUnspecified", "{", "currType", "=", "*", "t", "\n", "}", "else", "{", "mtp", ":=", "types", ".", "MergeFieldType", "(", "currType", ".", "Tp", ",", "t", ".", "Tp", ")", "\n", "if", "mtp", "==", "t", ".", "Tp", "&&", "mtp", "!=", "currType", ".", "Tp", "{", "currType", ".", "Charset", "=", "t", ".", "Charset", "\n", "currType", ".", "Collate", "=", "t", ".", "Collate", "\n", "}", "\n", "currType", ".", "Tp", "=", "mtp", "\n", "}", "\n", "}", "\n", "x", ".", "SetType", "(", "&", "currType", ")", "\n", "// TODO: We need a better way to set charset/collation", "x", ".", "Type", ".", "Charset", ",", "x", ".", "Type", ".", "Collate", "=", "types", ".", "DefaultCharsetForType", "(", "x", ".", "Type", ".", "Tp", ")", "\n", "}" ]

[ "The", "return", "type", "of", "a", "CASE", "expression", "is", "the", "compatible", "aggregated", "type", "of", "all", "return", "values", "but", "also", "depends", "on", "the", "context", "in", "which", "it", "is", "used", ".", "If", "used", "in", "a", "string", "context", "the", "result", "is", "returned", "as", "a", "string", ".", "If", "used", "in", "a", "numeric", "context", "the", "result", "is", "returned", "as", "a", "decimal", "real", "or", "integer", "value", "." ]

[ "func", "(", "v", "*", "typeInferrer", ")", "handleLikeExpr", "(", "x", "*", "ast", ".", "PatternLikeExpr", ")", "{", "x", ".", "SetType", "(", "types", ".", "NewFieldType", "(", "mysql", ".", "TypeLonglong", ")", ")", "\n", "x", ".", "Type", ".", "Charset", "=", "charset", ".", "CharsetBin", "\n", "x", ".", "Type", ".", "Collate", "=", "charset", ".", "CollationBin", "\n", "x", ".", "Expr", "=", "v", ".", "addCastToString", "(", "x", ".", "Expr", ")", "\n", "x", ".", "Pattern", "=", "v", ".", "addCastToString", "(", "x", ".", "Pattern", ")", "\n", "}" ]

[ "like", "expression", "expects", "the", "target", "expression", "and", "pattern", "to", "be", "a", "string", "if", "it", "s", "not", "we", "add", "a", "cast", "function", "." ]

[ "func", "(", "v", "*", "typeInferrer", ")", "addCastToString", "(", "expr", "ast", ".", "ExprNode", ")", "ast", ".", "ExprNode", "{", "if", "!", "mysql", ".", "IsUTF8Charset", "(", "expr", ".", "GetType", "(", ")", ".", "Charset", ")", "{", "castTp", ":=", "types", ".", "NewFieldType", "(", "mysql", ".", "TypeString", ")", "\n", "castTp", ".", "Charset", ",", "castTp", ".", "Collate", "=", "types", ".", "DefaultCharsetForType", "(", "mysql", ".", "TypeString", ")", "\n", "if", "val", ",", "ok", ":=", "expr", ".", "(", "*", "ast", ".", "ValueExpr", ")", ";", "ok", "{", "newVal", ",", "err", ":=", "val", ".", "Datum", ".", "ConvertTo", "(", "v", ".", "sc", ",", "castTp", ")", "\n", "if", "err", "!=", "nil", "{", "v", ".", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "expr", ".", "SetDatum", "(", "newVal", ")", "\n", "}", "else", "{", "castFunc", ":=", "&", "ast", ".", "FuncCastExpr", "{", "Expr", ":", "expr", ",", "Tp", ":", "castTp", ",", "FunctionType", ":", "ast", ".", "CastFunction", ",", "}", "\n", "expr", "=", "castFunc", "\n", "}", "\n", "expr", ".", "SetType", "(", "castTp", ")", "\n", "}", "\n", "return", "expr", "\n", "}" ]

[ "AddCastToString", "adds", "a", "cast", "function", "to", "string", "type", "if", "the", "expr", "charset", "is", "not", "UTF8", "." ]

[ "func", "(", "v", "*", "typeInferrer", ")", "convertValueToColumnTypeIfNeeded", "(", "x", "*", "ast", ".", "PatternInExpr", ")", "{", "if", "cn", ",", "ok", ":=", "x", ".", "Expr", ".", "(", "*", "ast", ".", "ColumnNameExpr", ")", ";", "ok", "&&", "cn", ".", "Refer", "!=", "nil", "{", "ft", ":=", "cn", ".", "Refer", ".", "Column", ".", "FieldType", "\n", "for", "_", ",", "expr", ":=", "range", "x", ".", "List", "{", "if", "valueExpr", ",", "ok", ":=", "expr", ".", "(", "*", "ast", ".", "ValueExpr", ")", ";", "ok", "{", "newDatum", ",", "err", ":=", "valueExpr", ".", "Datum", ".", "ConvertTo", "(", "v", ".", "sc", ",", "&", "ft", ")", "\n", "if", "err", "!=", "nil", "{", "v", ".", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "cmp", ",", "err", ":=", "newDatum", ".", "CompareDatum", "(", "v", ".", "sc", ",", "valueExpr", ".", "Datum", ")", "\n", "if", "err", "!=", "nil", "{", "v", ".", "err", "=", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "cmp", "!=", "0", "{", "// The value will never match the column, do not set newDatum.", "continue", "\n", "}", "\n", "valueExpr", ".", "SetDatum", "(", "newDatum", ")", "\n", "}", "\n", "}", "\n", "if", "v", ".", "err", "!=", "nil", "{", "// TODO: Errors should be handled differently according to query context.", "log", ".", "Printf", "(", "\"", "\"", ",", "v", ".", "err", ")", "\n", "v", ".", "err", "=", "nil", "\n", "}", "\n", "}", "\n", "}" ]

[ "ConvertValueToColumnTypeIfNeeded", "checks", "if", "the", "expr", "in", "PatternInExpr", "is", "column", "name", "and", "casts", "function", "to", "the", "items", "in", "the", "list", "." ]

[ "func", "DecimalDiv", "(", "from1", ",", "from2", ",", "to", "*", "MyDecimal", ",", "fracIncr", "int", ")", "error", "{", "to", ".", "resultFrac", "=", "myMinInt8", "(", "from1", ".", "resultFrac", "+", "int8", "(", "fracIncr", ")", ",", "MaxFraction", ")", "\n", "return", "doDivMod", "(", "from1", ",", "from2", ",", "to", ",", "nil", ",", "fracIncr", ")", "\n", "}" ]

[ "DecimalDiv", "does", "division", "of", "two", "decimals", ".", "from1", "-", "dividend", "from2", "-", "divisor", "to", "-", "quotient", "fracIncr", "-", "increment", "of", "fraction" ]

[ "func", "(", "s", "*", "Scheduler", ")", "Fetch", "(", "demands", "[", "]", "market", ".", "Demand", ")", "{", "var", "request", "pb", ".", "ComputeRequest", "\n", "request", ".", "Username", "=", "s", ".", "Option", ".", "Username", "\n", "request", ".", "Hostname", "=", "s", ".", "Option", ".", "Hostname", "\n", "request", ".", "FlowHashCode", "=", "s", ".", "Option", ".", "FlowHashcode", "\n", "request", ".", "DataCenter", "=", "s", ".", "Option", ".", "DataCenter", "\n", "for", "_", ",", "d", ":=", "range", "demands", "{", "taskGroup", ":=", "d", ".", "Requirement", ".", "(", "*", "plan", ".", "TaskGroup", ")", "\n", "requiredResource", ":=", "taskGroup", ".", "RequiredResources", "(", ")", "\n", "request", ".", "ComputeResources", "=", "append", "(", "request", ".", "ComputeResources", ",", "requiredResource", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "getResources", "(", "s", ".", "Master", ",", "&", "request", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "s", ".", "Master", ",", "err", ")", "\n", "time", ".", "Sleep", "(", "time", ".", "Millisecond", "*", "time", ".", "Duration", "(", "15000", "+", "rand", ".", "Int63n", "(", "5000", ")", ")", ")", "\n", "}", "else", "{", "if", "len", "(", "result", ".", "Allocations", ")", "==", "0", "{", "// log.Printf(\"%s No more new executors.\", s.Master)", "time", ".", "Sleep", "(", "time", ".", "Millisecond", "*", "time", ".", "Duration", "(", "2000", "+", "rand", ".", "Int63n", "(", "1000", ")", ")", ")", "\n", "}", "else", "{", "if", "s", ".", "Option", ".", "DataCenter", "==", "\"", "\"", "{", "s", ".", "Option", ".", "DataCenter", "=", "result", ".", "Allocations", "[", "0", "]", ".", "Location", ".", "DataCenter", "\n", "}", "\n", "var", "allocatedMemory", "int64", "\n", "for", "_", ",", "allocation", ":=", "range", "result", ".", "Allocations", "{", "s", ".", "Market", ".", "AddSupply", "(", "market", ".", "Supply", "{", "Object", ":", "allocation", ",", "}", ")", "\n", "allocatedMemory", "+=", "allocation", ".", "Allocated", ".", "MemoryMb", "\n", "}", "\n", "// log.Printf(\"%s allocated %d executors with %d MB memory.\", s.Master, len(result.Allocations), allocatedMemory)", "}", "\n", "}", "\n", "}" ]

[ "Requirement", "is", "TaskGroup", "Object", "is", "Agent", "s", "Location" ]

[ "func", "(", "d", "*", "Dataset", ")", "ReduceByKey", "(", "name", "string", ",", "reducerId", "gio", ".", "ReducerId", ")", "(", "ret", "*", "Dataset", ")", "{", "sortOption", ":=", "Field", "(", "1", ")", "\n", "return", "d", ".", "ReduceBy", "(", "name", ",", "reducerId", ",", "sortOption", ")", "\n", "}" ]

[ "ReduceByKey", "runs", "the", "reducer", "registered", "to", "the", "reducerId", "combining", "rows", "with", "the", "same", "key", "fields", "into", "one", "row" ]

[ "func", "(", "d", "*", "Dataset", ")", "Reduce", "(", "name", "string", ",", "reducerId", "gio", ".", "ReducerId", ")", "(", "ret", "*", "Dataset", ")", "{", "name", "=", "name", "+", "\"", "\"", "\n\n", "ret", "=", "d", ".", "LocalReduceBy", "(", "name", "+", "\"", "\"", ",", "reducerId", ",", "nil", ")", "\n", "if", "len", "(", "d", ".", "Shards", ")", ">", "1", "{", "ret", "=", "ret", ".", "MergeTo", "(", "name", ",", "1", ")", ".", "LocalReduceBy", "(", "name", "+", "\"", "\"", ",", "reducerId", ",", "nil", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "Reduce", "runs", "the", "reducer", "registered", "to", "the", "reducerId", "combining", "all", "rows", "into", "one", "row" ]

[ "func", "decorrelate", "(", "p", "LogicalPlan", ")", "LogicalPlan", "{", "if", "apply", ",", "ok", ":=", "p", ".", "(", "*", "Apply", ")", ";", "ok", "{", "outerPlan", ":=", "apply", ".", "children", "[", "0", "]", "\n", "innerPlan", ":=", "apply", ".", "children", "[", "1", "]", ".", "(", "LogicalPlan", ")", "\n", "apply", ".", "extractCorColumnsBySchema", "(", ")", "\n", "if", "len", "(", "apply", ".", "corCols", ")", "==", "0", "{", "// If the inner plan is non-correlated, the apply will be simplified to join.", "join", ":=", "&", "apply", ".", "Join", "\n", "innerPlan", ".", "SetParents", "(", "join", ")", "\n", "outerPlan", ".", "SetParents", "(", "join", ")", "\n", "p", "=", "join", "\n", "}", "else", "if", "sel", ",", "ok", ":=", "innerPlan", ".", "(", "*", "Selection", ")", ";", "ok", "{", "// If the inner plan is a selection, we add this condition to join predicates.", "// Notice that no matter what kind of join is, it's always right.", "newConds", ":=", "make", "(", "[", "]", "expression", ".", "Expression", ",", "0", ",", "len", "(", "sel", ".", "Conditions", ")", ")", "\n", "for", "_", ",", "cond", ":=", "range", "sel", ".", "Conditions", "{", "newConds", "=", "append", "(", "newConds", ",", "cond", ".", "Decorrelate", "(", "outerPlan", ".", "GetSchema", "(", ")", ")", ")", "\n", "}", "\n", "apply", ".", "attachOnConds", "(", "newConds", ")", "\n", "innerPlan", "=", "sel", ".", "children", "[", "0", "]", ".", "(", "LogicalPlan", ")", "\n", "apply", ".", "SetChildren", "(", "outerPlan", ",", "innerPlan", ")", "\n", "innerPlan", ".", "SetParents", "(", "apply", ")", "\n", "return", "decorrelate", "(", "p", ")", "\n", "}", "\n", "// TODO: Deal with aggregation and projection.", "}", "\n", "newChildren", ":=", "make", "(", "[", "]", "Plan", ",", "0", ",", "len", "(", "p", ".", "GetChildren", "(", ")", ")", ")", "\n", "for", "_", ",", "child", ":=", "range", "p", ".", "GetChildren", "(", ")", "{", "newChildren", "=", "append", "(", "newChildren", ",", "decorrelate", "(", "child", ".", "(", "LogicalPlan", ")", ")", ")", "\n", "child", ".", "SetParents", "(", "p", ")", "\n", "}", "\n", "p", ".", "SetChildren", "(", "newChildren", "...", ")", "\n", "return", "p", "\n", "}" ]

[ "decorrelate", "function", "tries", "to", "convert", "apply", "plan", "to", "join", "plan", "." ]

[ "func", "BufWrites", "(", "rawWriters", "[", "]", "io", ".", "Writer", ",", "function", "func", "(", "[", "]", "io", ".", "Writer", ")", ")", "{", "var", "writers", "[", "]", "io", ".", "Writer", "\n", "var", "bufWriters", "[", "]", "*", "bufio", ".", "Writer", "\n", "for", "_", ",", "w", ":=", "range", "rawWriters", "{", "if", "bufWriter", ",", "ok", ":=", "w", ".", "(", "*", "bufio", ".", "Writer", ")", ";", "ok", "{", "writers", "=", "append", "(", "writers", ",", "bufWriter", ")", "\n", "}", "else", "{", "bufWriter", "=", "bufio", ".", "NewWriter", "(", "w", ")", "\n", "bufWriters", "=", "append", "(", "bufWriters", ",", "bufWriter", ")", "\n", "writers", "=", "append", "(", "writers", ",", "bufWriter", ")", "\n", "}", "\n", "}", "\n\n", "function", "(", "writers", ")", "\n\n", "for", "_", ",", "w", ":=", "range", "bufWriters", "{", "w", ".", "Flush", "(", ")", "\n", "}", "\n\n", "}" ]

[ "BufWrites", "ensures", "all", "writers", "are", "bufio", ".", "Writer", "For", "any", "bufio", ".", "Writer", "created", "here", "flush", "it", "before", "returning", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "reset", "(", "sql", "string", ")", "{", "s", ".", "r", "=", "reader", "{", "s", ":", "sql", "}", "\n", "s", ".", "buf", ".", "Reset", "(", ")", "\n", "s", ".", "errs", "=", "s", ".", "errs", "[", ":", "0", "]", "\n", "s", ".", "stmtStartPos", "=", "0", "\n", "}" ]

[ "reset", "resets", "the", "sql", "string", "to", "be", "scanned", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "Errorf", "(", "format", "string", ",", "a", "...", "interface", "{", "}", ")", "{", "str", ":=", "fmt", ".", "Sprintf", "(", "format", ",", "a", "...", ")", "\n", "val", ":=", "s", ".", "r", ".", "s", "[", "s", ".", "r", ".", "pos", "(", ")", ".", "Offset", ":", "]", "\n", "if", "len", "(", "val", ")", ">", "2048", "{", "val", "=", "val", "[", ":", "2048", "]", "\n", "}", "\n", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "s", ".", "r", ".", "p", ".", "Line", ",", "s", ".", "r", ".", "p", ".", "Col", ",", "val", ",", "str", ",", "len", "(", "s", ".", "r", ".", "s", ")", ")", "\n", "s", ".", "errs", "=", "append", "(", "s", ".", "errs", ",", "err", ")", "\n", "}" ]

[ "Errorf", "tells", "scanner", "something", "is", "wrong", ".", "Scanner", "satisfies", "yyLexer", "interface", "which", "need", "this", "function", "." ]

[ "func", "handleEscape", "(", "s", "*", "Scanner", ")", "rune", "{", "s", ".", "r", ".", "inc", "(", ")", "\n", "ch0", ":=", "s", ".", "r", ".", "peek", "(", ")", "\n", "/*\n\t\t\\\" \\' \\\\ \\n \\0 \\b \\Z \\r \\t ==> escape to one char\n\t\t\\% \\_ ==> preserve both char\n\t\tother ==> remove \\\n\t*/", "switch", "ch0", "{", "case", "'n'", ":", "ch0", "=", "'\\n'", "\n", "case", "'0'", ":", "ch0", "=", "0", "\n", "case", "'b'", ":", "ch0", "=", "8", "\n", "case", "'Z'", ":", "ch0", "=", "26", "\n", "case", "'r'", ":", "ch0", "=", "'\\r'", "\n", "case", "'t'", ":", "ch0", "=", "'\\t'", "\n", "case", "'%'", ",", "'_'", ":", "s", ".", "buf", ".", "WriteByte", "(", "'\\\\'", ")", "\n", "}", "\n", "return", "ch0", "\n", "}" ]

[ "handleEscape", "handles", "the", "case", "in", "scanString", "when", "previous", "char", "is", "\\", "." ]

[ "func", "(", "r", "*", "reader", ")", "inc", "(", ")", "{", "if", "r", ".", "s", "[", "r", ".", "p", ".", "Offset", "]", "==", "'\\n'", "{", "r", ".", "p", ".", "Line", "++", "\n", "r", ".", "p", ".", "Col", "=", "0", "\n", "}", "\n", "r", ".", "p", ".", "Offset", "+=", "r", ".", "w", "\n", "r", ".", "p", ".", "Col", "++", "\n", "}" ]

[ "inc", "increase", "the", "position", "offset", "of", "the", "reader", ".", "peek", "must", "be", "called", "before", "calling", "inc!" ]

[ "func", "addChild", "(", "parent", "Plan", ",", "child", "Plan", ")", "{", "if", "child", "==", "nil", "||", "parent", "==", "nil", "{", "return", "\n", "}", "\n", "child", ".", "AddParent", "(", "parent", ")", "\n", "parent", ".", "AddChild", "(", "child", ")", "\n", "}" ]

[ "AddChild", "for", "parent", "." ]

[ "func", "InsertPlan", "(", "parent", "Plan", ",", "child", "Plan", ",", "insert", "Plan", ")", "error", "{", "err", ":=", "child", ".", "ReplaceParent", "(", "parent", ",", "insert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "parent", ".", "ReplaceChild", "(", "child", ",", "insert", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "insert", ".", "AddChild", "(", "child", ")", "\n", "insert", ".", "AddParent", "(", "parent", ")", "\n", "return", "nil", "\n", "}" ]

[ "InsertPlan", "means", "inserting", "plan", "between", "two", "plans", "." ]

[ "func", "RemovePlan", "(", "p", "Plan", ")", "error", "{", "parents", ":=", "p", ".", "GetParents", "(", ")", "\n", "children", ":=", "p", ".", "GetChildren", "(", ")", "\n", "if", "len", "(", "parents", ")", ">", "1", "||", "len", "(", "children", ")", "!=", "1", "{", "return", "SystemInternalErrorType", ".", "Gen", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "len", "(", "parents", ")", "==", "0", "{", "child", ":=", "children", "[", "0", "]", "\n", "child", ".", "SetParents", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "parent", ",", "child", ":=", "parents", "[", "0", "]", ",", "children", "[", "0", "]", "\n", "err", ":=", "parent", ".", "ReplaceChild", "(", "p", ",", "child", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "err", "=", "child", ".", "ReplaceParent", "(", "p", ",", "parent", ")", "\n", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "RemovePlan", "means", "removing", "a", "plan", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Map", "(", "name", "string", ",", "mapperId", "gio", ".", "MapperId", ")", "*", "Dataset", "{", "ret", ",", "step", ":=", "add1ShardTo1Step", "(", "d", ")", "\n", "step", ".", "Name", "=", "name", "+", "\"", "\"", "\n", "step", ".", "IsPipe", "=", "false", "\n", "step", ".", "IsGoCode", "=", "true", "\n\n", "ex", ",", "_", ":=", "os", ".", "Executable", "(", ")", "\n\n", "mapper", ",", "_", ":=", "gio", ".", "GetMapper", "(", "mapperId", ")", "\n", "step", ".", "Description", "=", "mapper", ".", "Name", "\n\n", "var", "args", "[", "]", "string", "\n", "args", "=", "append", "(", "args", ",", "os", ".", "Args", "[", "1", ":", "]", "...", ")", "\n", "args", "=", "append", "(", "args", ",", "\"", "\"", ",", "string", "(", "mapperId", ")", ")", "\n", "step", ".", "Command", "=", "&", "script", ".", "Command", "{", "Path", ":", "ex", ",", "Args", ":", "args", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "Mapper", "runs", "the", "mapper", "registered", "to", "the", "mapperId", ".", "This", "is", "used", "to", "execute", "pure", "Go", "code", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Select", "(", "name", "string", ",", "sortOption", "*", "SortOption", ")", "*", "Dataset", "{", "ret", ",", "step", ":=", "add1ShardTo1Step", "(", "d", ")", "\n", "indexes", ":=", "sortOption", ".", "Indexes", "(", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewSelect", "(", "[", "]", "int", "{", "indexes", "[", "0", "]", "}", ",", "indexes", "[", "1", ":", "]", ")", ")", "\n", "step", ".", "Description", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "sortOption", ".", "Indexes", "(", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "Select", "selects", "multiple", "fields", "into", "the", "next", "dataset", ".", "The", "index", "starts", "from", "1", ".", "The", "first", "one", "is", "the", "key" ]

[ "func", "(", "d", "*", "Dataset", ")", "SelectKV", "(", "name", "string", ",", "keys", ",", "values", "*", "SortOption", ")", "*", "Dataset", "{", "ret", ",", "step", ":=", "add1ShardTo1Step", "(", "d", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewSelect", "(", "keys", ".", "Indexes", "(", ")", ",", "values", ".", "Indexes", "(", ")", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "Select", "selects", "multiple", "fields", "into", "the", "next", "dataset", ".", "The", "index", "starts", "from", "1", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "LocalLimit", "(", "name", "string", ",", "n", "int", ",", "offset", "int", ")", "*", "Dataset", "{", "ret", ",", "step", ":=", "add1ShardTo1Step", "(", "d", ")", "\n", "ret", ".", "IsLocalSorted", "=", "d", ".", "IsLocalSorted", "\n", "ret", ".", "IsPartitionedBy", "=", "d", ".", "IsPartitionedBy", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewLocalLimit", "(", "n", ",", "offset", ")", ")", "\n", "step", ".", "Description", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "n", ")", "\n", "return", "ret", "\n", "}" ]

[ "LocalLimit", "take", "the", "local", "first", "n", "rows", "and", "skip", "all", "other", "rows", "." ]

[ "func", "findAncestorStepId", "(", "step", "*", "flow", ".", "Step", ")", "(", "int", ",", "bool", ")", "{", "current", ":=", "step", "\n", "taskCount", ":=", "len", "(", "current", ".", "Tasks", ")", "\n\n", "// println(\"find step\", step.Name)", "for", "taskCount", "==", "len", "(", "current", ".", "Tasks", ")", "{", "if", "len", "(", "current", ".", "InputDatasets", ")", ">", "1", "{", "// more than 2 dataset inputs", "break", "\n", "}", "\n", "if", "len", "(", "current", ".", "InputDatasets", ")", "==", "0", "{", "// no dataset inputs", "break", "\n", "}", "\n", "if", "!", "isMergeableDataset", "(", "current", ".", "InputDatasets", "[", "0", "]", ",", "taskCount", ")", "{", "break", "\n", "}", "\n", "if", "(", "!", "current", ".", "IsOnDriverSide", "&&", "current", ".", "InputDatasets", "[", "0", "]", ".", "Step", ".", "IsOnDriverSide", ")", "||", "(", "current", ".", "IsOnDriverSide", "&&", "!", "current", ".", "InputDatasets", "[", "0", "]", ".", "Step", ".", "IsOnDriverSide", ")", "{", "break", "\n", "}", "\n\n", "current", "=", "current", ".", "InputDatasets", "[", "0", "]", ".", "Step", "\n", "taskCount", "=", "len", "(", "current", ".", "Tasks", ")", "\n\n", "}", "\n", "return", "current", ".", "Id", ",", "true", "\n", "}" ]

[ "find", "mergeable", "parent", "step", "or", "itself", "if", "parent", "is", "not", "mergeable" ]

[ "func", "translateToStepGroups", "(", "fc", "*", "flow", ".", "Flow", ")", "[", "]", "*", "StepGroup", "{", "// use array instead of map to ensure consistent ordering", "stepId2StepGroup", ":=", "make", "(", "[", "]", "*", "StepGroup", ",", "len", "(", "fc", ".", "Steps", ")", ")", "\n", "for", "_", ",", "step", ":=", "range", "fc", ".", "Steps", "{", "// println(\"step:\", step.Name, step.Id, \"starting...\")", "ancestorStepId", ",", "foundStepId", ":=", "findAncestorStepId", "(", "step", ")", "\n", "if", "!", "foundStepId", "{", "println", "(", "\"", "\"", ",", "step", ".", "Id", ",", "\"", "\"", ")", "\n", "continue", "\n", "}", "\n", "// println(\"step:\", step.Name, step.Id, \"ancestorStepId\", ancestorStepId)", "if", "stepId2StepGroup", "[", "ancestorStepId", "]", "==", "nil", "{", "stepId2StepGroup", "[", "ancestorStepId", "]", "=", "NewStepGroup", "(", ")", "\n", "for", "_", ",", "ds", ":=", "range", "step", ".", "InputDatasets", "{", "parentDsId", ",", "hasParentIdId", ":=", "findAncestorStepId", "(", "ds", ".", "Step", ")", "\n", "if", "!", "hasParentIdId", "{", "// since we add steps following the same order as the code", "log", ".", "Panic", "(", "\"", "\"", ")", "\n", "}", "\n", "parentSg", ":=", "stepId2StepGroup", "[", "parentDsId", "]", "\n", "if", "parentSg", "==", "nil", "{", "// since we add steps following the same order as the code", "log", ".", "Panic", "(", "\"", "\"", ")", "\n", "}", "\n", "stepId2StepGroup", "[", "ancestorStepId", "]", ".", "AddParent", "(", "parentSg", ")", "\n", "}", "\n", "}", "\n", "stepId2StepGroup", "[", "ancestorStepId", "]", ".", "AddStep", "(", "step", ")", "\n", "}", "\n", "// shrink", "var", "ret", "[", "]", "*", "StepGroup", "\n", "for", "_", ",", "stepGroup", ":=", "range", "stepId2StepGroup", "{", "if", "stepGroup", "==", "nil", "||", "len", "(", "stepGroup", ".", "Steps", ")", "==", "0", "{", "continue", "\n", "}", "\n", "// println(\"add step group started by\", stepGroup.Steps[0].Name, \"with\", len(stepGroup.Steps), \"steps\")", "ret", "=", "append", "(", "ret", ",", "stepGroup", ")", "\n", "}", "\n\n", "return", "ret", "\n", "}" ]

[ "group", "local", "steps", "into", "one", "step", "group" ]

[ "func", "(", "ft", "*", "FieldType", ")", "Init", "(", "tp", "byte", ")", "{", "ft", ".", "Tp", "=", "tp", "\n", "ft", ".", "Flen", "=", "UnspecifiedLength", "\n", "ft", ".", "Decimal", "=", "UnspecifiedLength", "\n", "}" ]

[ "Init", "initializes", "the", "FieldType", "data", "." ]

[ "func", "(", "ft", "*", "FieldType", ")", "String", "(", ")", "string", "{", "strs", ":=", "[", "]", "string", "{", "ft", ".", "CompactStr", "(", ")", "}", "\n", "if", "mysql", ".", "HasUnsignedFlag", "(", "ft", ".", "Flag", ")", "{", "strs", "=", "append", "(", "strs", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "mysql", ".", "HasZerofillFlag", "(", "ft", ".", "Flag", ")", "{", "strs", "=", "append", "(", "strs", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "mysql", ".", "HasBinaryFlag", "(", "ft", ".", "Flag", ")", "{", "strs", "=", "append", "(", "strs", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "IsTypeChar", "(", "ft", ".", "Tp", ")", "||", "IsTypeBlob", "(", "ft", ".", "Tp", ")", "{", "if", "ft", ".", "Charset", "!=", "\"", "\"", "&&", "ft", ".", "Charset", "!=", "charset", ".", "CharsetBin", "{", "strs", "=", "append", "(", "strs", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ft", ".", "Charset", ")", ")", "\n", "}", "\n", "if", "ft", ".", "Collate", "!=", "\"", "\"", "&&", "ft", ".", "Collate", "!=", "charset", ".", "CharsetBin", "{", "strs", "=", "append", "(", "strs", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ft", ".", "Collate", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "strs", ",", "\"", "\"", ")", "\n", "}" ]

[ "String", "joins", "the", "information", "of", "FieldType", "and", "returns", "a", "string", "." ]

[ "func", "Sha1Hash", "(", "bs", "[", "]", "byte", ")", "[", "]", "byte", "{", "crypt", ":=", "sha1", ".", "New", "(", ")", "\n", "crypt", ".", "Write", "(", "bs", ")", "\n", "return", "crypt", ".", "Sum", "(", "nil", ")", "\n", "}" ]

[ "Sha1Hash", "is", "an", "util", "function", "to", "calculate", "sha1", "hash", "." ]

[ "func", "EncodePassword", "(", "pwd", "string", ")", "string", "{", "if", "len", "(", "pwd", ")", "==", "0", "{", "return", "\"", "\"", "\n", "}", "\n", "hash", ":=", "Sha1Hash", "(", "[", "]", "byte", "(", "pwd", ")", ")", "\n", "return", "hex", ".", "EncodeToString", "(", "hash", ")", "\n", "}" ]

[ "EncodePassword", "converts", "plaintext", "password", "to", "hashed", "hex", "string", "." ]

[ "func", "DecodePassword", "(", "pwd", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "x", ",", "err", ":=", "hex", ".", "DecodeString", "(", "pwd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "x", ",", "nil", "\n", "}" ]

[ "DecodePassword", "converts", "hex", "string", "password", "to", "byte", "array", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Join", "(", "name", "string", ",", "other", "*", "Dataset", ",", "sortOption", "*", "SortOption", ")", "*", "Dataset", "{", "return", "d", ".", "DoJoin", "(", "name", ",", "other", ",", "false", ",", "false", ",", "sortOption", ")", "\n", "}" ]

[ "Join", "joins", "two", "datasets", "by", "the", "key", "." ]

[ "func", "(", "this", "*", "Dataset", ")", "JoinPartitionedSorted", "(", "name", "string", ",", "that", "*", "Dataset", ",", "sortOption", "*", "SortOption", ",", "isLeftOuterJoin", ",", "isRightOuterJoin", "bool", ")", "*", "Dataset", "{", "ret", ":=", "this", ".", "Flow", ".", "NewNextDataset", "(", "len", "(", "this", ".", "Shards", ")", ")", "\n", "ret", ".", "IsPartitionedBy", "=", "that", ".", "IsPartitionedBy", "\n", "ret", ".", "IsLocalSorted", "=", "that", ".", "IsLocalSorted", "\n\n", "inputs", ":=", "[", "]", "*", "Dataset", "{", "this", ",", "that", "}", "\n", "step", ":=", "this", ".", "Flow", ".", "MergeDatasets1ShardTo1Step", "(", "inputs", ",", "ret", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewJoinPartitionedSorted", "(", "isLeftOuterJoin", ",", "isRightOuterJoin", ",", "sortOption", ".", "Indexes", "(", ")", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "JoinPartitionedSorted", "Join", "multiple", "datasets", "that", "are", "sharded", "by", "the", "same", "key", "and", "locally", "sorted", "within", "the", "shard" ]

[ "func", "EvalBool", "(", "expr", "Expression", ",", "row", "[", "]", "types", ".", "Datum", ",", "ctx", "context", ".", "Context", ")", "(", "bool", ",", "error", ")", "{", "data", ",", "err", ":=", "expr", ".", "Eval", "(", "row", ",", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "data", ".", "IsNull", "(", ")", "{", "return", "false", ",", "nil", "\n", "}", "\n\n", "i", ",", "err", ":=", "data", ".", "ToBool", "(", "ctx", ".", "GetSessionVars", "(", ")", ".", "StmtCtx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "return", "i", "!=", "0", ",", "nil", "\n", "}" ]

[ "EvalBool", "evaluates", "expression", "to", "a", "boolean", "value", "." ]

[ "func", "TableInfo2Schema", "(", "tbl", "*", "model", ".", "TableInfo", ")", "Schema", "{", "schema", ":=", "NewSchema", "(", "make", "(", "[", "]", "*", "Column", ",", "0", ",", "len", "(", "tbl", ".", "Columns", ")", ")", ")", "\n", "keys", ":=", "make", "(", "[", "]", "KeyInfo", ",", "0", ",", "len", "(", "tbl", ".", "Indices", ")", "+", "1", ")", "\n", "for", "i", ",", "col", ":=", "range", "tbl", ".", "Columns", "{", "newCol", ":=", "&", "Column", "{", "ColName", ":", "col", ".", "Name", ",", "TblName", ":", "tbl", ".", "Name", ",", "RetType", ":", "&", "col", ".", "FieldType", ",", "Position", ":", "i", ",", "}", "\n", "schema", ".", "Append", "(", "newCol", ")", "\n", "}", "\n", "for", "_", ",", "idx", ":=", "range", "tbl", ".", "Indices", "{", "if", "!", "idx", ".", "Unique", "{", "continue", "\n", "}", "\n", "ok", ":=", "true", "\n", "newKey", ":=", "make", "(", "[", "]", "*", "Column", ",", "0", ",", "len", "(", "idx", ".", "Columns", ")", ")", "\n", "for", "_", ",", "idxCol", ":=", "range", "idx", ".", "Columns", "{", "find", ":=", "false", "\n", "for", "i", ",", "col", ":=", "range", "tbl", ".", "Columns", "{", "if", "idxCol", ".", "Name", ".", "L", "==", "col", ".", "Name", ".", "L", "{", "if", "!", "mysql", ".", "HasNotNullFlag", "(", "col", ".", "Flag", ")", "{", "break", "\n", "}", "\n", "newKey", "=", "append", "(", "newKey", ",", "schema", ".", "Columns", "[", "i", "]", ")", "\n", "find", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "find", "{", "ok", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "ok", "{", "keys", "=", "append", "(", "keys", ",", "newKey", ")", "\n", "}", "\n", "}", "\n", "schema", ".", "SetUniqueKeys", "(", "keys", ")", "\n", "return", "schema", "\n", "}" ]

[ "TableInfo2Schema", "converts", "table", "info", "to", "schema", "." ]

[ "func", "NewCastFunc", "(", "tp", "*", "types", ".", "FieldType", ",", "arg", "Expression", ",", "ctx", "context", ".", "Context", ")", "*", "ScalarFunction", "{", "bt", ":=", "&", "builtinCastSig", "{", "newBaseBuiltinFunc", "(", "[", "]", "Expression", "{", "arg", "}", ",", "ctx", ")", ",", "tp", "}", "\n", "return", "&", "ScalarFunction", "{", "FuncName", ":", "model", ".", "NewCIStr", "(", "ast", ".", "Cast", ")", ",", "RetType", ":", "tp", ",", "Function", ":", "bt", ",", "}", "\n", "}" ]

[ "NewCastFunc", "creates", "a", "new", "cast", "function", "." ]

[ "func", "FoldConstant", "(", "ctx", "context", ".", "Context", ",", "expr", "Expression", ")", "Expression", "{", "scalarFunc", ",", "ok", ":=", "expr", ".", "(", "*", "ScalarFunction", ")", "\n", "if", "!", "ok", "{", "return", "expr", "\n", "}", "\n", "if", "_", ",", "isDynamic", ":=", "DynamicFuncs", "[", "scalarFunc", ".", "FuncName", ".", "L", "]", ";", "isDynamic", "{", "return", "expr", "\n", "}", "\n", "args", ":=", "scalarFunc", ".", "GetArgs", "(", ")", "\n", "canFold", ":=", "true", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "args", ")", ";", "i", "++", "{", "foldedArg", ":=", "FoldConstant", "(", "ctx", ",", "args", "[", "i", "]", ")", "\n", "scalarFunc", ".", "GetArgs", "(", ")", "[", "i", "]", "=", "foldedArg", "\n", "if", "_", ",", "ok", ":=", "foldedArg", ".", "(", "*", "Constant", ")", ";", "!", "ok", "{", "canFold", "=", "false", "\n", "}", "\n", "}", "\n", "if", "!", "canFold", "{", "return", "expr", "\n", "}", "\n", "value", ",", "err", ":=", "scalarFunc", ".", "Eval", "(", "nil", ",", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "scalarFunc", ".", "FuncName", ",", "args", ")", "\n", "return", "expr", "\n", "}", "\n", "return", "&", "Constant", "{", "Value", ":", "value", ",", "RetType", ":", "scalarFunc", ".", "RetType", ",", "}", "\n", "}" ]

[ "FoldConstant", "does", "constant", "folding", "optimization", "on", "an", "expression", "." ]

[ "func", "TakeMessage", "(", "reader", "io", ".", "Reader", ",", "count", "int", ",", "f", "func", "(", "[", "]", "byte", ")", "error", ")", "(", "err", "error", ")", "{", "if", "_", ",", "isBufioReader", ":=", "reader", ".", "(", "*", "bufio", ".", "Reader", ")", ";", "!", "isBufioReader", "{", "reader", "=", "bufio", ".", "NewReader", "(", "reader", ")", "\n", "}", "\n", "for", "err", "==", "nil", "{", "if", "count", "==", "0", "{", "io", ".", "Copy", "(", "ioutil", ".", "Discard", ",", "reader", ")", "\n", "return", "nil", "\n", "}", "\n", "message", ",", "readError", ":=", "ReadMessage", "(", "reader", ")", "\n", "if", "readError", "==", "io", ".", "EOF", "{", "break", "\n", "}", "\n", "if", "readError", "==", "nil", "{", "err", "=", "f", "(", "message", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "readError", ")", "\n", "}", "\n", "count", "--", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "TakeMessage", "Reads", "and", "processes", "MessagePack", "encoded", "messages", ".", "If", "count", "is", "less", "than", "0", "all", "lines", "are", "processed", "." ]

[ "func", "ProcessMessage", "(", "reader", "io", ".", "Reader", ",", "f", "func", "(", "[", "]", "byte", ")", "error", ")", "(", "err", "error", ")", "{", "return", "TakeMessage", "(", "reader", ",", "-", "1", ",", "f", ")", "\n", "}" ]

[ "ProcessMessage", "Reads", "and", "processes", "MessagePack", "encoded", "messages", "until", "EOF" ]

[ "func", "(", "l", "*", "SingleFileStore", ")", "Write", "(", "p", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "l", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "l", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "l", ".", "file", "==", "nil", "{", "if", "err", "=", "l", ".", "openNew", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "}", "\n\n", "l", ".", "file", ".", "Seek", "(", "0", ",", "2", ")", "\n", "n", ",", "err", "=", "l", ".", "file", ".", "Write", "(", "p", ")", "\n", "l", ".", "size", "+=", "int64", "(", "n", ")", "\n", "l", ".", "Position", "+=", "int64", "(", "n", ")", "\n", "l", ".", "waitForReading", ".", "Broadcast", "(", ")", "\n\n", "return", "n", ",", "err", "\n", "}" ]

[ "Write", "implements", "io", ".", "Writer", ".", "If", "a", "write", "would", "cause", "the", "log", "file", "to", "be", "larger", "than", "MaxMegaByte", "the", "file", "is", "closed", "renamed", "to", "include", "a", "timestamp", "of", "the", "current", "time", "and", "a", "new", "log", "file", "is", "created", "using", "the", "original", "log", "file", "name", ".", "If", "the", "length", "of", "the", "write", "is", "greater", "than", "MaxMegaByte", "an", "error", "is", "returned", "." ]

[ "func", "mergeStats", "(", "a", ",", "b", "[", "]", "*", "pb", ".", "InstructionStat", ")", "(", "ret", "[", "]", "*", "pb", ".", "InstructionStat", ")", "{", "var", "nonOverlapping", "[", "]", "*", "pb", ".", "InstructionStat", "\n", "for", "_", ",", "ai", ":=", "range", "a", "{", "var", "found", "bool", "\n", "for", "_", ",", "bi", ":=", "range", "b", "{", "if", "ai", ".", "StepId", "==", "bi", ".", "StepId", "{", "found", "=", "true", "\n", "if", "ai", ".", "InputCounter", ">", "bi", ".", "InputCounter", "{", "ret", "=", "append", "(", "ret", ",", "ai", ")", "\n", "}", "else", "{", "ret", "=", "append", "(", "ret", ",", "bi", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "nonOverlapping", "=", "append", "(", "nonOverlapping", ",", "ai", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "bi", ":=", "range", "b", "{", "var", "found", "bool", "\n", "for", "_", ",", "ai", ":=", "range", "a", "{", "if", "ai", ".", "StepId", "==", "bi", ".", "StepId", "{", "found", "=", "true", "\n", "}", "\n", "}", "\n", "if", "!", "found", "{", "nonOverlapping", "=", "append", "(", "nonOverlapping", ",", "bi", ")", "\n", "}", "\n", "}", "\n", "ret", "=", "append", "(", "ret", ",", "nonOverlapping", "...", ")", "\n", "return", "ret", "\n", "}" ]

[ "merge", "existing", "stats", "with", "incoming", "stats" ]

[ "func", "(", "p", "*", "DataSource", ")", "tryToConvert2DummyScan", "(", "prop", "*", "requiredProperty", ")", "(", "*", "physicalPlanInfo", ",", "error", ")", "{", "sel", ",", "isSel", ":=", "p", ".", "GetParentByIndex", "(", "0", ")", ".", "(", "*", "Selection", ")", "\n", "if", "!", "isSel", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "for", "_", ",", "cond", ":=", "range", "sel", ".", "Conditions", "{", "if", "con", ",", "ok", ":=", "cond", ".", "(", "*", "expression", ".", "Constant", ")", ";", "ok", "{", "result", ",", "err", ":=", "expression", ".", "EvalBool", "(", "con", ",", "nil", ",", "p", ".", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "!", "result", "{", "dummy", ":=", "&", "PhysicalDummyScan", "{", "}", "\n", "dummy", ".", "tp", "=", "\"", "\"", "\n", "dummy", ".", "allocator", "=", "p", ".", "allocator", "\n", "dummy", ".", "initIDAndContext", "(", "p", ".", "ctx", ")", "\n", "dummy", ".", "SetSchema", "(", "p", ".", "schema", ")", "\n", "info", ":=", "&", "physicalPlanInfo", "{", "p", ":", "dummy", "}", "\n", "p", ".", "storePlanInfo", "(", "prop", ",", "info", ")", "\n", "return", "info", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "tryToConvert2DummyScan", "is", "an", "optimization", "which", "checks", "if", "its", "parent", "is", "a", "selection", "with", "a", "constant", "condition", "that", "evaluates", "to", "false", ".", "If", "it", "is", "there", "is", "no", "need", "for", "a", "real", "physical", "scan", "a", "dummy", "scan", "will", "do", "." ]

[ "func", "removeLimit", "(", "prop", "*", "requiredProperty", ")", "*", "requiredProperty", "{", "ret", ":=", "&", "requiredProperty", "{", "props", ":", "prop", ".", "props", ",", "sortKeyLen", ":", "prop", ".", "sortKeyLen", ",", "}", "\n", "return", "ret", "\n", "}" ]

[ "removeLimit", "removes", "the", "limit", "from", "prop", "." ]

[ "func", "replaceColsInPropBySchema", "(", "prop", "*", "requiredProperty", ",", "schema", "expression", ".", "Schema", ")", "*", "requiredProperty", "{", "newProps", ":=", "make", "(", "[", "]", "*", "columnProp", ",", "0", ",", "len", "(", "prop", ".", "props", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "prop", ".", "props", "{", "idx", ":=", "schema", ".", "GetColumnIndex", "(", "p", ".", "col", ")", "\n", "if", "idx", "==", "-", "1", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "p", ".", "col", ")", "\n", "}", "\n", "newProps", "=", "append", "(", "newProps", ",", "&", "columnProp", "{", "col", ":", "schema", ".", "Columns", "[", "idx", "]", ",", "desc", ":", "p", ".", "desc", "}", ")", "\n", "}", "\n", "return", "&", "requiredProperty", "{", "props", ":", "newProps", ",", "sortKeyLen", ":", "prop", ".", "sortKeyLen", ",", "limit", ":", "prop", ".", "limit", ",", "}", "\n", "}" ]

[ "replaceColsInPropBySchema", "replaces", "the", "columns", "in", "original", "prop", "with", "the", "columns", "in", "schema", "." ]

[ "func", "(", "p", "*", "Aggregation", ")", "convert2PhysicalPlanHash", "(", ")", "(", "*", "physicalPlanInfo", ",", "error", ")", "{", "childInfo", ",", "err", ":=", "p", ".", "children", "[", "0", "]", ".", "(", "LogicalPlan", ")", ".", "convert2PhysicalPlan", "(", "&", "requiredProperty", "{", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "distinct", ":=", "false", "\n", "for", "_", ",", "fun", ":=", "range", "p", ".", "AggFuncs", "{", "if", "fun", ".", "IsDistinct", "(", ")", "{", "distinct", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "!", "distinct", "{", "if", "x", ",", "ok", ":=", "childInfo", ".", "p", ".", "(", "physicalDistSQLPlan", ")", ";", "ok", "{", "info", ":=", "p", ".", "convert2PhysicalPlanFinalHash", "(", "x", ",", "childInfo", ")", "\n", "if", "info", "!=", "nil", "{", "return", "info", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "p", ".", "convert2PhysicalPlanCompleteHash", "(", "childInfo", ")", ",", "nil", "\n", "}" ]

[ "convert2PhysicalPlanHash", "converts", "the", "logical", "aggregation", "to", "the", "physical", "hash", "aggregation", "." ]

[ "func", "physicalInitialize", "(", "p", "PhysicalPlan", ")", "{", "for", "_", ",", "child", ":=", "range", "p", ".", "GetChildren", "(", ")", "{", "physicalInitialize", "(", "child", ".", "(", "PhysicalPlan", ")", ")", "\n", "}", "\n", "// initialize attributes", "p", ".", "SetCorrelated", "(", ")", "\n", "}" ]

[ "physicalInitialize", "will", "set", "value", "of", "some", "attributes", "after", "convert2PhysicalPlan", "process", ".", "Currently", "only", "attribute", "correlated", "is", "considered", "." ]

[ "func", "EncodeInt", "(", "b", "[", "]", "byte", ",", "v", "int64", ")", "[", "]", "byte", "{", "var", "data", "[", "8", "]", "byte", "\n", "u", ":=", "encodeIntToCmpUint", "(", "v", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint64", "(", "data", "[", ":", "]", ",", "u", ")", "\n", "return", "append", "(", "b", ",", "data", "[", ":", "]", "...", ")", "\n", "}" ]

[ "EncodeInt", "appends", "the", "encoded", "value", "to", "slice", "b", "and", "returns", "the", "appended", "slice", ".", "EncodeInt", "guarantees", "that", "the", "encoded", "value", "is", "in", "ascending", "order", "for", "comparison", "." ]

[ "func", "DecodeIntDesc", "(", "b", "[", "]", "byte", ")", "(", "[", "]", "byte", ",", "int64", ",", "error", ")", "{", "if", "len", "(", "b", ")", "<", "8", "{", "return", "nil", ",", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "u", ":=", "binary", ".", "BigEndian", ".", "Uint64", "(", "b", "[", ":", "8", "]", ")", "\n", "v", ":=", "decodeCmpUintToInt", "(", "^", "u", ")", "\n", "b", "=", "b", "[", "8", ":", "]", "\n", "return", "b", ",", "v", ",", "nil", "\n", "}" ]

[ "DecodeIntDesc", "decodes", "value", "encoded", "by", "EncodeInt", "before", ".", "It", "returns", "the", "leftover", "un", "-", "decoded", "slice", "decoded", "value", "if", "no", "error", "." ]

[ "func", "StrToInt", "(", "sc", "*", "variable", ".", "StatementContext", ",", "str", "string", ")", "(", "int64", ",", "error", ")", "{", "str", "=", "strings", ".", "TrimSpace", "(", "str", ")", "\n", "validPrefix", ",", "err", ":=", "getValidIntPrefix", "(", "sc", ",", "str", ")", "\n", "iVal", ",", "err1", ":=", "strconv", ".", "ParseInt", "(", "validPrefix", ",", "10", ",", "64", ")", "\n", "if", "err1", "!=", "nil", "{", "return", "iVal", ",", "errors", ".", "Trace", "(", "ErrOverflow", ")", "\n", "}", "\n", "return", "iVal", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "StrToInt", "converts", "a", "string", "to", "an", "integer", "at", "the", "best", "-", "effort", "." ]

[ "func", "floatStrToIntStr", "(", "validFloat", "string", ")", "(", "string", ",", "error", ")", "{", "var", "dotIdx", "=", "-", "1", "\n", "var", "eIdx", "=", "-", "1", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "validFloat", ")", ";", "i", "++", "{", "switch", "validFloat", "[", "i", "]", "{", "case", "'.'", ":", "dotIdx", "=", "i", "\n", "case", "'e'", ",", "'E'", ":", "eIdx", "=", "i", "\n", "}", "\n", "}", "\n", "if", "eIdx", "==", "-", "1", "{", "if", "dotIdx", "==", "-", "1", "{", "return", "validFloat", ",", "nil", "\n", "}", "\n", "return", "validFloat", "[", ":", "dotIdx", "]", ",", "nil", "\n", "}", "\n", "var", "intCnt", "int", "\n", "digits", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "len", "(", "validFloat", ")", ")", "\n", "if", "dotIdx", "==", "-", "1", "{", "digits", "=", "append", "(", "digits", ",", "validFloat", "[", ":", "eIdx", "]", "...", ")", "\n", "intCnt", "=", "len", "(", "digits", ")", "\n", "}", "else", "{", "digits", "=", "append", "(", "digits", ",", "validFloat", "[", ":", "dotIdx", "]", "...", ")", "\n", "intCnt", "=", "len", "(", "digits", ")", "\n", "digits", "=", "append", "(", "digits", ",", "validFloat", "[", "dotIdx", "+", "1", ":", "eIdx", "]", "...", ")", "\n", "}", "\n", "exp", ",", "err", ":=", "strconv", ".", "Atoi", "(", "validFloat", "[", "eIdx", "+", "1", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "validFloat", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "exp", ">", "0", "&&", "intCnt", ">", "(", "math", ".", "MaxInt64", "-", "exp", ")", "{", "// (exp + incCnt) overflows MaxInt64.", "return", "validFloat", ",", "errors", ".", "Trace", "(", "ErrOverflow", ")", "\n", "}", "\n", "intCnt", "+=", "exp", "\n", "if", "intCnt", "<=", "0", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "if", "intCnt", "==", "1", "&&", "(", "digits", "[", "0", "]", "==", "'-'", "||", "digits", "[", "0", "]", "==", "'+'", ")", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "var", "validInt", "string", "\n", "if", "intCnt", "<=", "len", "(", "digits", ")", "{", "validInt", "=", "string", "(", "digits", "[", ":", "intCnt", "]", ")", "\n", "}", "else", "{", "extraZeroCount", ":=", "intCnt", "-", "len", "(", "digits", ")", "\n", "if", "extraZeroCount", ">", "20", "{", "// Return overflow to avoid allocating too much memory.", "return", "validFloat", ",", "errors", ".", "Trace", "(", "ErrOverflow", ")", "\n", "}", "\n", "validInt", "=", "string", "(", "digits", ")", "+", "strings", ".", "Repeat", "(", "\"", "\"", ",", "extraZeroCount", ")", "\n", "}", "\n", "return", "validInt", ",", "nil", "\n", "}" ]

[ "floatStrToIntStr", "converts", "a", "valid", "float", "string", "into", "valid", "integer", "string", "which", "can", "be", "parsed", "by", "strconv", ".", "ParseInt", "we", "can", "t", "parse", "float", "first", "then", "convert", "it", "to", "string", "because", "precision", "will", "be", "lost", "." ]

[ "func", "getValidFloatPrefix", "(", "sc", "*", "variable", ".", "StatementContext", ",", "s", "string", ")", "(", "valid", "string", ",", "err", "error", ")", "{", "var", "(", "sawDot", "bool", "\n", "sawDigit", "bool", "\n", "validLen", "int", "\n", "eIdx", "int", "\n", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "s", ")", ";", "i", "++", "{", "c", ":=", "s", "[", "i", "]", "\n", "if", "c", "==", "'+'", "||", "c", "==", "'-'", "{", "if", "i", "!=", "0", "&&", "i", "!=", "eIdx", "+", "1", "{", "// \"1e+1\" is valid.", "break", "\n", "}", "\n", "}", "else", "if", "c", "==", "'.'", "{", "if", "sawDot", "||", "eIdx", ">", "0", "{", "// \"1.1.\" or \"1e1.1\"", "break", "\n", "}", "\n", "sawDot", "=", "true", "\n", "if", "sawDigit", "{", "// \"123.\" is valid.", "validLen", "=", "i", "+", "1", "\n", "}", "\n", "}", "else", "if", "c", "==", "'e'", "||", "c", "==", "'E'", "{", "if", "!", "sawDigit", "{", "// \"+.e\"", "break", "\n", "}", "\n", "if", "eIdx", "!=", "0", "{", "// \"1e5e\"", "break", "\n", "}", "\n", "eIdx", "=", "i", "\n", "}", "else", "if", "c", "<", "'0'", "||", "c", ">", "'9'", "{", "break", "\n", "}", "else", "{", "sawDigit", "=", "true", "\n", "validLen", "=", "i", "+", "1", "\n", "}", "\n", "}", "\n", "valid", "=", "s", "[", ":", "validLen", "]", "\n", "if", "valid", "==", "\"", "\"", "{", "valid", "=", "\"", "\"", "\n", "}", "\n", "if", "validLen", "==", "0", "||", "validLen", "!=", "len", "(", "s", ")", "{", "err", "=", "errors", ".", "Trace", "(", "handleTruncateError", "(", "sc", ")", ")", "\n", "}", "\n", "return", "valid", ",", "err", "\n", "}" ]

[ "getValidFloatPrefix", "gets", "prefix", "of", "string", "which", "can", "be", "successfully", "parsed", "as", "float", "." ]

[ "func", "ToString", "(", "value", "interface", "{", "}", ")", "(", "string", ",", "error", ")", "{", "switch", "v", ":=", "value", ".", "(", "type", ")", "{", "case", "bool", ":", "if", "v", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "return", "\"", "\"", ",", "nil", "\n", "case", "int", ":", "return", "strconv", ".", "FormatInt", "(", "int64", "(", "v", ")", ",", "10", ")", ",", "nil", "\n", "case", "int64", ":", "return", "strconv", ".", "FormatInt", "(", "int64", "(", "v", ")", ",", "10", ")", ",", "nil", "\n", "case", "uint64", ":", "return", "strconv", ".", "FormatUint", "(", "uint64", "(", "v", ")", ",", "10", ")", ",", "nil", "\n", "case", "float32", ":", "return", "strconv", ".", "FormatFloat", "(", "float64", "(", "v", ")", ",", "'f'", ",", "-", "1", ",", "32", ")", ",", "nil", "\n", "case", "float64", ":", "return", "strconv", ".", "FormatFloat", "(", "float64", "(", "v", ")", ",", "'f'", ",", "-", "1", ",", "64", ")", ",", "nil", "\n", "case", "string", ":", "return", "v", ",", "nil", "\n", "case", "[", "]", "byte", ":", "return", "string", "(", "v", ")", ",", "nil", "\n", "case", "Time", ":", "return", "v", ".", "String", "(", ")", ",", "nil", "\n", "case", "Duration", ":", "return", "v", ".", "String", "(", ")", ",", "nil", "\n", "case", "*", "MyDecimal", ":", "return", "v", ".", "String", "(", ")", ",", "nil", "\n", "case", "Hex", ":", "return", "v", ".", "ToString", "(", ")", ",", "nil", "\n", "case", "Bit", ":", "return", "v", ".", "ToString", "(", ")", ",", "nil", "\n", "case", "Enum", ":", "return", "v", ".", "String", "(", ")", ",", "nil", "\n", "case", "Set", ":", "return", "v", ".", "String", "(", ")", ",", "nil", "\n", "default", ":", "return", "\"", "\"", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "value", ",", "value", ")", "\n", "}", "\n", "}" ]

[ "ToString", "converts", "an", "interface", "to", "a", "string", "." ]

[ "func", "Validate", "(", "node", "ast", ".", "Node", ",", "inPrepare", "bool", ")", "error", "{", "v", ":=", "validator", "{", "inPrepare", ":", "inPrepare", "}", "\n", "node", ".", "Accept", "(", "&", "v", ")", "\n", "return", "v", ".", "err", "\n", "}" ]

[ "Validate", "checkes", "whether", "the", "node", "is", "valid", "." ]

[ "func", "outerJoinSimplify", "(", "p", "*", "Join", ",", "predicates", "[", "]", "expression", ".", "Expression", ")", "error", "{", "var", "innerTable", ",", "outerTable", "LogicalPlan", "\n", "child1", ":=", "p", ".", "GetChildByIndex", "(", "0", ")", ".", "(", "LogicalPlan", ")", "\n", "child2", ":=", "p", ".", "GetChildByIndex", "(", "1", ")", ".", "(", "LogicalPlan", ")", "\n", "var", "fullConditions", "[", "]", "expression", ".", "Expression", "\n", "if", "p", ".", "JoinType", "==", "LeftOuterJoin", "{", "innerTable", "=", "child2", "\n", "outerTable", "=", "child1", "\n", "}", "else", "if", "p", ".", "JoinType", "==", "RightOuterJoin", "||", "p", ".", "JoinType", "==", "InnerJoin", "{", "innerTable", "=", "child1", "\n", "outerTable", "=", "child2", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "// first simplify embedded outer join.", "// When trying to simplify an embedded outer join operation in a query,", "// we must take into account the join condition for the embedding outer join together with the WHERE condition.", "if", "innerPlan", ",", "ok", ":=", "innerTable", ".", "(", "*", "Join", ")", ";", "ok", "{", "fullConditions", "=", "concatOnAndWhereConds", "(", "p", ",", "predicates", ")", "\n", "err", ":=", "outerJoinSimplify", "(", "innerPlan", ",", "fullConditions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "outerPlan", ",", "ok", ":=", "outerTable", ".", "(", "*", "Join", ")", ";", "ok", "{", "if", "fullConditions", "!=", "nil", "{", "fullConditions", "=", "concatOnAndWhereConds", "(", "p", ",", "predicates", ")", "\n", "}", "\n", "err", ":=", "outerJoinSimplify", "(", "outerPlan", ",", "fullConditions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "}", "\n", "if", "p", ".", "JoinType", "==", "InnerJoin", "{", "return", "nil", "\n", "}", "\n", "// then simplify embedding outer join.", "canBeSimplified", ":=", "false", "\n", "for", "_", ",", "expr", ":=", "range", "predicates", "{", "isOk", ",", "err", ":=", "isNullRejected", "(", "p", ".", "ctx", ",", "innerTable", ".", "GetSchema", "(", ")", ",", "expr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Trace", "(", "err", ")", "\n", "}", "\n", "if", "isOk", "{", "canBeSimplified", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "canBeSimplified", "{", "p", ".", "JoinType", "=", "InnerJoin", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "outerJoinSimplify", "simplifies", "outer", "join", "." ]

[ "func", "concatOnAndWhereConds", "(", "join", "*", "Join", ",", "predicates", "[", "]", "expression", ".", "Expression", ")", "[", "]", "expression", ".", "Expression", "{", "equalConds", ",", "leftConds", ",", "rightConds", ",", "otherConds", ":=", "join", ".", "EqualConditions", ",", "join", ".", "LeftConditions", ",", "join", ".", "RightConditions", ",", "join", ".", "OtherConditions", "\n", "ans", ":=", "make", "(", "[", "]", "expression", ".", "Expression", ",", "0", ",", "len", "(", "equalConds", ")", "+", "len", "(", "leftConds", ")", "+", "len", "(", "rightConds", ")", "+", "len", "(", "predicates", ")", ")", "\n", "for", "_", ",", "v", ":=", "range", "equalConds", "{", "ans", "=", "append", "(", "ans", ",", "v", ")", "\n", "}", "\n", "ans", "=", "append", "(", "ans", ",", "leftConds", "...", ")", "\n", "ans", "=", "append", "(", "ans", ",", "rightConds", "...", ")", "\n", "ans", "=", "append", "(", "ans", ",", "otherConds", "...", ")", "\n", "ans", "=", "append", "(", "ans", ",", "predicates", "...", ")", "\n", "return", "ans", "\n", "}" ]

[ "concatOnAndWhereConds", "concatenate", "ON", "conditions", "with", "WHERE", "conditions", "." ]

[ "func", "(", "z", "*", "Row", ")", "fieldsNotEmpty", "(", "isempty", "[", "]", "bool", ")", "uint32", "{", "if", "len", "(", "isempty", ")", "==", "0", "{", "return", "3", "\n", "}", "\n", "var", "fieldsInUse", "uint32", "=", "3", "\n", "isempty", "[", "0", "]", "=", "(", "len", "(", "z", ".", "K", ")", "==", "0", ")", "// string, omitempty", "\n", "if", "isempty", "[", "0", "]", "{", "fieldsInUse", "--", "\n", "}", "\n", "isempty", "[", "1", "]", "=", "(", "len", "(", "z", ".", "V", ")", "==", "0", ")", "// string, omitempty", "\n", "if", "isempty", "[", "1", "]", "{", "fieldsInUse", "--", "\n", "}", "\n", "isempty", "[", "2", "]", "=", "(", "z", ".", "T", "==", "0", ")", "// number, omitempty", "\n", "if", "isempty", "[", "2", "]", "{", "fieldsInUse", "--", "\n", "}", "\n\n", "return", "fieldsInUse", "\n", "}" ]

[ "fieldsNotEmpty", "supports", "omitempty", "tags" ]

[ "func", "PropagateConstant", "(", "ctx", "context", ".", "Context", ",", "conditions", "[", "]", "Expression", ")", "[", "]", "Expression", "{", "solver", ":=", "&", "propagateConstantSolver", "{", "colMapper", ":", "make", "(", "map", "[", "string", "]", "int", ")", ",", "ctx", ":", "ctx", ",", "}", "\n", "return", "solver", ".", "solve", "(", "conditions", ")", "\n", "}" ]

[ "PropagateConstant", "propagate", "constant", "values", "of", "equality", "predicates", "and", "inequality", "predicates", "in", "a", "condition", "." ]

[ "func", "(", "o", "*", "SortOption", ")", "By", "(", "index", "int", ",", "ascending", "bool", ")", "*", "SortOption", "{", "order", ":=", "instruction", ".", "Descending", "\n", "if", "ascending", "{", "order", "=", "instruction", ".", "Ascending", "\n", "}", "\n", "o", ".", "orderByList", "=", "append", "(", "o", ".", "orderByList", ",", "instruction", ".", "OrderBy", "{", "Index", ":", "index", ",", "Order", ":", "order", ",", "}", ")", "\n", "return", "o", "\n", "}" ]

[ "OrderBy", "chains", "a", "list", "of", "sorting", "order", "by" ]

[ "func", "(", "o", "*", "SortOption", ")", "Indexes", "(", ")", "[", "]", "int", "{", "var", "ret", "[", "]", "int", "\n", "for", "_", ",", "x", ":=", "range", "o", ".", "orderByList", "{", "ret", "=", "append", "(", "ret", ",", "x", ".", "Index", ")", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "return", "a", "list", "of", "indexes" ]

[ "func", "(", "s", "Schema", ")", "RetrieveColumn", "(", "col", "*", "Column", ")", "*", "Column", "{", "index", ":=", "s", ".", "GetColumnIndex", "(", "col", ")", "\n", "if", "index", "!=", "-", "1", "{", "return", "s", ".", "Columns", "[", "index", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RetrieveColumn", "retrieves", "column", "in", "expression", "from", "the", "columns", "in", "schema", "." ]

[ "func", "(", "s", "Schema", ")", "GetColumnIndex", "(", "col", "*", "Column", ")", "int", "{", "for", "i", ",", "c", ":=", "range", "s", ".", "Columns", "{", "if", "c", ".", "FromID", "==", "col", ".", "FromID", "&&", "c", ".", "Position", "==", "col", ".", "Position", "{", "return", "i", "\n", "}", "\n", "}", "\n", "return", "-", "1", "\n", "}" ]

[ "GetColumnIndex", "finds", "the", "index", "for", "a", "column", "." ]

[ "func", "(", "s", "*", "Schema", ")", "Append", "(", "col", "*", "Column", ")", "{", "s", ".", "Columns", "=", "append", "(", "s", ".", "Columns", ",", "col", ")", "\n", "}" ]

[ "Append", "append", "new", "column", "to", "the", "columns", "stored", "in", "schema", "." ]

[ "func", "(", "s", "Schema", ")", "GetColumnsIndices", "(", "cols", "[", "]", "*", "Column", ")", "(", "ret", "[", "]", "int", ")", "{", "ret", "=", "make", "(", "[", "]", "int", ",", "0", ",", "len", "(", "cols", ")", ")", "\n", "for", "_", ",", "col", ":=", "range", "cols", "{", "pos", ":=", "s", ".", "GetColumnIndex", "(", "col", ")", "\n", "if", "pos", "!=", "-", "1", "{", "ret", "=", "append", "(", "ret", ",", "pos", ")", "\n", "}", "else", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "GetColumnsIndices", "will", "return", "a", "slice", "which", "contains", "the", "position", "of", "each", "column", "in", "schema", ".", "If", "there", "is", "one", "column", "that", "doesn", "t", "match", "nil", "will", "be", "returned", "." ]

[ "func", "MergeSchema", "(", "lSchema", ",", "rSchema", "Schema", ")", "Schema", "{", "tmpL", ":=", "lSchema", ".", "Clone", "(", ")", "\n", "tmpR", ":=", "rSchema", ".", "Clone", "(", ")", "\n", "ret", ":=", "NewSchema", "(", "append", "(", "tmpL", ".", "Columns", ",", "tmpR", ".", "Columns", "...", ")", ")", "\n", "ret", ".", "SetUniqueKeys", "(", "append", "(", "tmpL", ".", "Keys", ",", "tmpR", ".", "Keys", "...", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "MergeSchema", "will", "merge", "two", "schema", "into", "one", "schema", "." ]

[ "func", "(", "bigger", "*", "Dataset", ")", "HashJoin", "(", "name", "string", ",", "smaller", "*", "Dataset", ",", "sortOption", "*", "SortOption", ")", "*", "Dataset", "{", "return", "smaller", ".", "Broadcast", "(", "name", ",", "len", "(", "bigger", ".", "Shards", ")", ")", ".", "LocalHashAndJoinWith", "(", "name", ",", "bigger", ",", "sortOption", ")", "\n", "}" ]

[ "HashJoin", "joins", "two", "datasets", "by", "putting", "the", "smaller", "dataset", "in", "memory", "on", "all", "executors", "and", "streams", "through", "the", "bigger", "dataset", "." ]

[ "func", "(", "d", "*", "Dataset", ")", "Broadcast", "(", "name", "string", ",", "shardCount", "int", ")", "*", "Dataset", "{", "if", "shardCount", "==", "1", "&&", "len", "(", "d", ".", "Shards", ")", "==", "shardCount", "{", "return", "d", "\n", "}", "\n", "ret", ":=", "d", ".", "Flow", ".", "NewNextDataset", "(", "shardCount", ")", "\n", "step", ":=", "d", ".", "Flow", ".", "AddOneToAllStep", "(", "d", ",", "ret", ")", "\n", "step", ".", "SetInstruction", "(", "name", ",", "instruction", ".", "NewBroadcast", "(", ")", ")", "\n", "return", "ret", "\n", "}" ]

[ "Broadcast", "replicates", "itself", "to", "all", "shards", "." ]

[ "func", "linelabel", "(", "canvas", "*", "svg", ".", "SVG", ",", "x1", ",", "y1", ",", "x2", ",", "y2", "int", ",", "label", "string", ",", "mark", "string", ",", "d1", "string", ",", "d2", "string", ",", "dir", "string", ",", "color", "string", ")", "{", "aw", ":=", "linesize", "*", "4", "\n", "ah", ":=", "linesize", "*", "3", "\n\n", "if", "len", "(", "color", ")", "==", "0", "{", "color", "=", "lcolor", "\n", "}", "\n", "switch", "mark", "{", "case", "\"", "\"", ":", "lx1", ",", "ly1", ":=", "arrow", "(", "canvas", ",", "x1", ",", "y1", ",", "aw", ",", "ah", ",", "d1", ",", "color", ")", "\n", "lx2", ",", "ly2", ":=", "arrow", "(", "canvas", ",", "x2", ",", "y2", ",", "aw", ",", "ah", ",", "d2", ",", "color", ")", "\n", "doline", "(", "canvas", ",", "lx1", ",", "ly1", ",", "lx2", ",", "ly2", ",", "linestyle", "(", "color", ")", ",", "dir", ",", "label", ")", "\n\n", "case", "\"", "\"", ":", "lx1", ",", "ly1", ":=", "arrow", "(", "canvas", ",", "x1", ",", "y1", ",", "aw", ",", "ah", ",", "d1", ",", "color", ")", "\n", "doline", "(", "canvas", ",", "lx1", ",", "ly1", ",", "x2", ",", "y2", ",", "linestyle", "(", "color", ")", ",", "dir", ",", "label", ")", "\n\n", "case", "\"", "\"", ":", "lx2", ",", "ly2", ":=", "arrow", "(", "canvas", ",", "x2", ",", "y2", ",", "aw", ",", "ah", ",", "d2", ",", "color", ")", "\n", "doline", "(", "canvas", ",", "x1", ",", "y1", ",", "lx2", ",", "ly2", ",", "linestyle", "(", "color", ")", ",", "dir", ",", "label", ")", "\n\n", "default", ":", "doline", "(", "canvas", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "linestyle", "(", "color", ")", ",", "dir", ",", "label", ")", "\n", "}", "\n", "}" ]

[ "linelabel", "determines", "the", "connection", "and", "arrow", "geometry" ]

[ "func", "arrow", "(", "canvas", "*", "svg", ".", "SVG", ",", "x", ",", "y", ",", "w", ",", "h", "int", ",", "dir", "string", ",", "color", "string", ")", "(", "xl", ",", "yl", "int", ")", "{", "var", "xp", "=", "[", "]", "int", "{", "x", ",", "x", ",", "x", ",", "x", "}", "\n", "var", "yp", "=", "[", "]", "int", "{", "y", ",", "y", ",", "y", ",", "y", "}", "\n\n", "n", ":=", "notchsize", "\n", "switch", "dir", "{", "case", "\"", "\"", ":", "xp", "[", "1", "]", "=", "x", "-", "w", "\n", "yp", "[", "1", "]", "=", "y", "-", "h", "/", "2", "\n", "xp", "[", "2", "]", "=", "(", "x", "-", "w", ")", "+", "n", "\n", "yp", "[", "2", "]", "=", "y", "\n", "xp", "[", "3", "]", "=", "x", "-", "w", "\n", "yp", "[", "3", "]", "=", "y", "+", "h", "/", "2", "\n", "xl", ",", "yl", "=", "xp", "[", "2", "]", ",", "y", "\n", "case", "\"", "\"", ":", "xp", "[", "1", "]", "=", "x", "+", "w", "\n", "yp", "[", "1", "]", "=", "y", "-", "h", "/", "2", "\n", "xp", "[", "2", "]", "=", "(", "x", "+", "w", ")", "-", "n", "\n", "yp", "[", "2", "]", "=", "y", "\n", "xp", "[", "3", "]", "=", "x", "+", "w", "\n", "yp", "[", "3", "]", "=", "y", "+", "h", "/", "2", "\n", "xl", ",", "yl", "=", "xp", "[", "2", "]", ",", "y", "\n", "case", "\"", "\"", ":", "xp", "[", "1", "]", "=", "x", "-", "w", "/", "2", "\n", "yp", "[", "1", "]", "=", "y", "+", "h", "\n", "xp", "[", "2", "]", "=", "x", "\n", "yp", "[", "2", "]", "=", "(", "y", "+", "h", ")", "-", "n", "\n", "xp", "[", "3", "]", "=", "x", "+", "w", "/", "2", "\n", "yp", "[", "3", "]", "=", "y", "+", "h", "\n", "xl", ",", "yl", "=", "x", ",", "yp", "[", "2", "]", "\n", "case", "\"", "\"", ":", "xp", "[", "1", "]", "=", "x", "-", "w", "/", "2", "\n", "yp", "[", "1", "]", "=", "y", "-", "h", "\n", "xp", "[", "2", "]", "=", "x", "\n", "yp", "[", "2", "]", "=", "(", "y", "-", "h", ")", "+", "n", "\n", "xp", "[", "3", "]", "=", "x", "+", "w", "/", "2", "\n", "yp", "[", "3", "]", "=", "y", "-", "h", "\n", "xl", ",", "yl", "=", "x", ",", "yp", "[", "2", "]", "\n", "}", "\n", "canvas", ".", "Polygon", "(", "xp", ",", "yp", ",", "\"", "\"", "+", "color", "+", "\"", "\"", "+", "lopacity", ")", "\n", "return", "xl", ",", "yl", "\n", "}" ]

[ "arrow", "constructs", "line", "-", "ending", "arrows", "according", "to", "connecting", "points" ]

[ "func", "doline", "(", "canvas", "*", "svg", ".", "SVG", ",", "x1", ",", "y1", ",", "x2", ",", "y2", "int", ",", "style", ",", "direction", ",", "label", "string", ")", "{", "var", "labelstyle", "string", "\n", "var", "upflag", "bool", "\n\n", "tadjust", ":=", "6", "\n", "mx", ":=", "(", "x2", "-", "x1", ")", "/", "2", "\n", "my", ":=", "(", "y2", "-", "y1", ")", "/", "2", "\n", "lx", ":=", "x1", "+", "mx", "\n", "ly", ":=", "y1", "+", "my", "\n", "m", ",", "_", ":=", "sloper", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ")", "\n", "hline", ":=", "m", "==", "0", "\n", "vline", ":=", "m", "==", "math", ".", "Inf", "(", "-", "1", ")", "||", "m", "==", "math", ".", "Inf", "(", "1", ")", "\n", "straight", ":=", "hline", "||", "vline", "\n\n", "switch", "{", "case", "m", "<", "0", ":", "// upwards line", "upflag", "=", "true", "\n", "labelstyle", "+=", "\"", "\"", "\n", "lx", "-=", "tadjust", "\n", "case", "hline", ":", "// horizontal line", "labelstyle", "+=", "\"", "\"", "\n", "ly", "-=", "tadjust", "\n", "case", "m", ">", "0", ":", "// downwards line", "upflag", "=", "false", "\n", "labelstyle", "+=", "\"", "\"", "\n", "lx", "+=", "tadjust", "\n", "}", "\n", "if", "!", "straight", "&&", "direction", "!=", "\"", "\"", "{", "cx", ",", "cy", ":=", "x1", ",", "y2", "// initial control points", "\n", "// fmt.Fprintf(os.Stderr, \"%s slope = %.3f\\n\", label, m)", "if", "upflag", "{", "if", "direction", "==", "\"", "\"", "{", "cx", ",", "cy", "=", "x2", ",", "y1", "\n", "}", "else", "{", "cx", ",", "cy", "=", "x1", ",", "y2", "\n", "}", "\n", "}", "else", "{", "if", "direction", "==", "\"", "\"", "{", "cx", ",", "cy", "=", "x1", ",", "y2", "\n", "}", "else", "{", "cx", ",", "cy", "=", "x2", ",", "y1", "\n", "}", "\n", "}", "\n", "canvas", ".", "Qbez", "(", "x1", ",", "y1", ",", "cx", ",", "cy", ",", "x2", ",", "y2", ",", "style", ")", "\n", "labelstyle", "+=", "\"", "\"", "\n", "canvas", ".", "Text", "(", "lx", ",", "ly", ",", "label", ",", "labelstyle", ")", "\n", "}", "else", "{", "canvas", ".", "Line", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "style", ")", "\n", "canvas", ".", "Text", "(", "lx", ",", "ly", ",", "label", ",", "labelstyle", ")", "// midpoint", "\n", "}", "\n", "}" ]

[ "doline", "draws", "a", "line", "between", "to", "coordinates" ]

[ "func", "sloper", "(", "x1", ",", "y1", ",", "x2", ",", "y2", "int", ")", "(", "m", ",", "r", "float64", ")", "{", "dy", ":=", "float64", "(", "y1", "-", "y2", ")", "\n", "dx", ":=", "float64", "(", "x1", "-", "x2", ")", "\n", "m", "=", "dy", "/", "dx", "\n", "r", "=", "math", ".", "Atan2", "(", "dy", ",", "dx", ")", "*", "(", "180", "/", "math", ".", "Pi", ")", "\n", "return", "m", ",", "r", "\n", "}" ]

[ "sloper", "computes", "the", "slope", "and", "r", "of", "a", "line" ]

[ "func", "RegisterMapper", "(", "fn", "Mapper", ")", "MapperId", "{", "mappersLock", ".", "Lock", "(", ")", "\n", "defer", "mappersLock", ".", "Unlock", "(", ")", "\n\n", "mapperId", ":=", "MapperId", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "len", "(", "mappers", ")", "+", "1", ")", ")", "\n", "mappers", "[", "mapperId", "]", "=", "MapperObject", "{", "fn", ",", "runtime", ".", "FuncForPC", "(", "reflect", ".", "ValueOf", "(", "fn", ")", ".", "Pointer", "(", ")", ")", ".", "Name", "(", ")", "}", "\n\n", "return", "mapperId", "\n", "}" ]

[ "RegisterMapper", "register", "a", "mapper", "function", "to", "process", "a", "command" ]

[ "func", "ListRegisteredFunctions", "(", ")", "{", "for", "k", ",", "fn", ":=", "range", "mappers", "{", "println", "(", "k", ",", "\"", "\"", ",", "fn", ".", "Name", ")", "\n", "}", "\n", "for", "k", ",", "fn", ":=", "range", "reducers", "{", "println", "(", "k", ",", "\"", "\"", ",", "fn", ".", "Name", ")", "\n", "}", "\n", "}" ]

[ "ListRegisteredFunctions", "lists", "out", "all", "registered", "mappers", "and", "reducers" ]

[ "func", "(", "p", "*", "requiredProperty", ")", "getHashKey", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "datums", ":=", "make", "(", "[", "]", "types", ".", "Datum", ",", "0", ",", "len", "(", "p", ".", "props", ")", "*", "3", "+", "1", ")", "\n", "datums", "=", "append", "(", "datums", ",", "types", ".", "NewDatum", "(", "p", ".", "sortKeyLen", ")", ")", "\n", "for", "_", ",", "c", ":=", "range", "p", ".", "props", "{", "datums", "=", "append", "(", "datums", ",", "types", ".", "NewDatum", "(", "c", ".", "desc", ")", ",", "types", ".", "NewDatum", "(", "c", ".", "col", ".", "FromID", ")", ",", "types", ".", "NewDatum", "(", "c", ".", "col", ".", "Index", ")", ")", "\n", "}", "\n", "bytes", ",", "err", ":=", "codec", ".", "EncodeValue", "(", "nil", ",", "datums", "...", ")", "\n", "return", "bytes", ",", "errors", ".", "Trace", "(", "err", ")", "\n", "}" ]

[ "getHashKey", "encodes", "a", "requiredProperty", "to", "a", "unique", "hash", "code", "." ]

[ "func", "(", "p", "*", "baseLogicalPlan", ")", "ResolveIndicesAndCorCols", "(", ")", "{", "for", "_", ",", "child", ":=", "range", "p", ".", "children", "{", "child", ".", "(", "LogicalPlan", ")", ".", "ResolveIndicesAndCorCols", "(", ")", "\n", "}", "\n", "}" ]

[ "ResolveIndicesAndCorCols", "implements", "LogicalPlan", "interface", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "AddParent", "(", "parent", "Plan", ")", "{", "p", ".", "parents", "=", "append", "(", "p", ".", "parents", ",", "parent", ")", "\n", "}" ]

[ "AddParent", "implements", "Plan", "AddParent", "interface", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "AddChild", "(", "child", "Plan", ")", "{", "p", ".", "children", "=", "append", "(", "p", ".", "children", ",", "child", ")", "\n", "}" ]

[ "AddChild", "implements", "Plan", "AddChild", "interface", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "ReplaceParent", "(", "parent", ",", "newPar", "Plan", ")", "error", "{", "for", "i", ",", "par", ":=", "range", "p", ".", "parents", "{", "if", "par", ".", "GetID", "(", ")", "==", "parent", ".", "GetID", "(", ")", "{", "p", ".", "parents", "[", "i", "]", "=", "newPar", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "SystemInternalErrorType", ".", "Gen", "(", "\"", "\"", ")", "\n", "}" ]

[ "ReplaceParent", "means", "replace", "a", "parent", "for", "another", "one", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "ReplaceChild", "(", "child", ",", "newChild", "Plan", ")", "error", "{", "for", "i", ",", "ch", ":=", "range", "p", ".", "children", "{", "if", "ch", ".", "GetID", "(", ")", "==", "child", ".", "GetID", "(", ")", "{", "p", ".", "children", "[", "i", "]", "=", "newChild", "\n", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "SystemInternalErrorType", ".", "Gen", "(", "\"", "\"", ")", "\n", "}" ]

[ "ReplaceChild", "means", "replace", "a", "child", "with", "another", "one", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "GetParentByIndex", "(", "index", "int", ")", "(", "parent", "Plan", ")", "{", "if", "index", "<", "len", "(", "p", ".", "parents", ")", "&&", "index", ">=", "0", "{", "return", "p", ".", "parents", "[", "index", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetParentByIndex", "implements", "Plan", "GetParentByIndex", "interface", "." ]

[ "func", "(", "p", "*", "basePlan", ")", "GetChildByIndex", "(", "index", "int", ")", "(", "parent", "Plan", ")", "{", "if", "index", "<", "len", "(", "p", ".", "children", ")", "&&", "index", ">=", "0", "{", "return", "p", ".", "children", "[", "index", "]", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetChildByIndex", "implements", "Plan", "GetChildByIndex", "interface", "." ]

[ "func", "(", "as", "*", "AgentServer", ")", "serveTcp", "(", "listener", "net", ".", "Listener", ")", "{", "for", "{", "// Listen for an incoming connection.", "conn", ",", "err", ":=", "listener", ".", "Accept", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Println", "(", "\"", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "continue", "\n", "}", "\n", "// Handle connections in a new goroutine.", "go", "func", "(", ")", "{", "defer", "conn", ".", "Close", "(", ")", "\n", "if", "err", "=", "conn", ".", "SetDeadline", "(", "time", ".", "Time", "{", "}", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "}", "\n", "if", "c", ",", "ok", ":=", "conn", ".", "(", "*", "net", ".", "TCPConn", ")", ";", "ok", "{", "c", ".", "SetKeepAlive", "(", "true", ")", "\n", "}", "\n", "as", ".", "handleRequest", "(", "conn", ")", "\n", "}", "(", ")", "\n", "}", "\n", "}" ]

[ "Run", "starts", "the", "heartbeating", "to", "master", "and", "starts", "accepting", "requests", "." ]

[ "func", "IsTypeBlob", "(", "tp", "byte", ")", "bool", "{", "switch", "tp", "{", "case", "mysql", ".", "TypeTinyBlob", ",", "mysql", ".", "TypeMediumBlob", ",", "mysql", ".", "TypeBlob", ",", "mysql", ".", "TypeLongBlob", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsTypeBlob", "returns", "a", "boolean", "indicating", "whether", "the", "tp", "is", "a", "blob", "type", "." ]

[ "func", "IsTypeChar", "(", "tp", "byte", ")", "bool", "{", "switch", "tp", "{", "case", "mysql", ".", "TypeString", ",", "mysql", ".", "TypeVarchar", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}" ]

[ "IsTypeChar", "returns", "a", "boolean", "indicating", "whether", "the", "tp", "is", "the", "char", "type", "like", "a", "string", "type", "or", "a", "varchar", "type", "." ]

[ "func", "overflow", "(", "v", "interface", "{", "}", ",", "tp", "byte", ")", "error", "{", "return", "errors", ".", "Errorf", "(", "\"", "\"", ",", "v", ",", "TypeStr", "(", "tp", ")", ")", "\n", "}" ]

[ "Overflow", "returns", "an", "overflowed", "error", "." ]

[ "func", "DoSelect", "(", "reader", "io", ".", "Reader", ",", "writer", "io", ".", "Writer", ",", "keyIndexes", ",", "valueIndexes", "[", "]", "int", ",", "stats", "*", "pb", ".", "InstructionStat", ")", "error", "{", "return", "util", ".", "ProcessRow", "(", "reader", ",", "nil", ",", "func", "(", "row", "*", "util", ".", "Row", ")", "error", "{", "stats", ".", "InputCounter", "++", "\n\n", "var", "keys", ",", "values", "[", "]", "interface", "{", "}", "\n", "kLen", ":=", "len", "(", "row", ".", "K", ")", "\n", "for", "_", ",", "x", ":=", "range", "keyIndexes", "{", "if", "x", "<=", "kLen", "{", "keys", "=", "append", "(", "keys", ",", "row", ".", "K", "[", "x", "-", "1", "]", ")", "\n", "}", "else", "{", "keys", "=", "append", "(", "keys", ",", "row", ".", "V", "[", "x", "-", "1", "-", "kLen", "]", ")", "\n", "}", "\n", "}", "\n", "for", "_", ",", "x", ":=", "range", "valueIndexes", "{", "if", "x", "<=", "kLen", "{", "values", "=", "append", "(", "values", ",", "row", ".", "K", "[", "x", "-", "1", "]", ")", "\n", "}", "else", "{", "values", "=", "append", "(", "values", ",", "row", ".", "V", "[", "x", "-", "1", "-", "kLen", "]", ")", "\n", "}", "\n", "}", "\n", "row", ".", "K", ",", "row", ".", "V", "=", "keys", ",", "values", "\n\n", "row", ".", "WriteTo", "(", "writer", ")", "\n", "stats", ".", "OutputCounter", "++", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "}" ]

[ "DoSelect", "projects", "the", "fields" ]

[ "func", "(", "r", "*", "retrier", ")", "NextInterval", "(", "retry", "int", ")", "time", ".", "Duration", "{", "return", "r", ".", "backoff", ".", "Next", "(", "retry", ")", "\n", "}" ]

[ "NextInterval", "returns", "next", "retriable", "time" ]

[ "func", "WithHTTPTimeout", "(", "timeout", "time", ".", "Duration", ")", "Option", "{", "return", "func", "(", "c", "*", "Client", ")", "{", "c", ".", "timeout", "=", "timeout", "\n", "}", "\n", "}" ]

[ "WithHTTPTimeout", "sets", "hystrix", "timeout" ]

[ "func", "WithHystrixTimeout", "(", "timeout", "time", ".", "Duration", ")", "Option", "{", "return", "func", "(", "c", "*", "Client", ")", "{", "c", ".", "hystrixTimeout", "=", "timeout", "\n", "}", "\n", "}" ]

[ "WithHystrixTimeout", "sets", "hystrix", "timeout" ]

[ "func", "WithRetrier", "(", "retrier", "heimdall", ".", "Retriable", ")", "Option", "{", "return", "func", "(", "c", "*", "Client", ")", "{", "c", ".", "retrier", "=", "retrier", "\n", "}", "\n", "}" ]

[ "WithRetrier", "sets", "the", "strategy", "for", "retrying" ]

[ "func", "WithHTTPClient", "(", "client", "heimdall", ".", "Doer", ")", "Option", "{", "return", "func", "(", "c", "*", "Client", ")", "{", "c", ".", "client", "=", "client", "\n", "}", "\n", "}" ]

[ "WithHTTPClient", "sets", "a", "custom", "http", "client", "for", "hystrix", "client" ]

[ "func", "NewClient", "(", "opts", "...", "Option", ")", "*", "Client", "{", "client", ":=", "Client", "{", "timeout", ":", "defaultHTTPTimeout", ",", "retryCount", ":", "defaultRetryCount", ",", "retrier", ":", "heimdall", ".", "NewNoRetrier", "(", ")", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "opt", "(", "&", "client", ")", "\n", "}", "\n\n", "if", "client", ".", "client", "==", "nil", "{", "client", ".", "client", "=", "&", "http", ".", "Client", "{", "Timeout", ":", "client", ".", "timeout", ",", "}", "\n", "}", "\n\n", "return", "&", "client", "\n", "}" ]

[ "NewClient", "returns", "a", "new", "instance", "of", "http", "Client" ]

[ "func", "(", "cb", "*", "constantBackoff", ")", "Next", "(", "retry", "int", ")", "time", ".", "Duration", "{", "if", "retry", "<=", "0", "{", "return", "0", "*", "time", ".", "Millisecond", "\n", "}", "\n", "return", "(", "time", ".", "Duration", "(", "cb", ".", "backoffInterval", ")", "*", "time", ".", "Millisecond", ")", "+", "(", "time", ".", "Duration", "(", "rand", ".", "Int63n", "(", "cb", ".", "maximumJitterInterval", ")", ")", "*", "time", ".", "Millisecond", ")", "\n", "}" ]

[ "Next", "returns", "next", "time", "for", "retrying", "operation", "with", "constant", "strategy" ]

[ "func", "(", "eb", "*", "exponentialBackoff", ")", "Next", "(", "retry", "int", ")", "time", ".", "Duration", "{", "if", "retry", "<=", "0", "{", "return", "0", "*", "time", ".", "Millisecond", "\n", "}", "\n", "return", "time", ".", "Duration", "(", "math", ".", "Min", "(", "eb", ".", "initialTimeout", "+", "math", ".", "Pow", "(", "eb", ".", "exponentFactor", ",", "float64", "(", "retry", ")", ")", ",", "eb", ".", "maxTimeout", ")", "+", "float64", "(", "rand", ".", "Int63n", "(", "eb", ".", "maximumJitterInterval", ")", ")", ")", "*", "time", ".", "Millisecond", "\n", "}" ]

[ "Next", "returns", "next", "time", "for", "retrying", "operation", "with", "exponential", "strategy" ]

[ "func", "NewClient", "(", "opts", "...", "Option", ")", "*", "Client", "{", "client", ":=", "Client", "{", "timeout", ":", "defaultHTTPTimeout", ",", "hystrixTimeout", ":", "defaultHystrixTimeout", ",", "maxConcurrentRequests", ":", "defaultMaxConcurrentRequests", ",", "errorPercentThreshold", ":", "defaultErrorPercentThreshold", ",", "sleepWindow", ":", "defaultSleepWindow", ",", "requestVolumeThreshold", ":", "defaultRequestVolumeThreshold", ",", "retryCount", ":", "defaultHystrixRetryCount", ",", "retrier", ":", "heimdall", ".", "NewNoRetrier", "(", ")", ",", "}", "\n\n", "for", "_", ",", "opt", ":=", "range", "opts", "{", "opt", "(", "&", "client", ")", "\n", "}", "\n\n", "if", "client", ".", "client", "==", "nil", "{", "client", ".", "client", "=", "&", "http", ".", "Client", "{", "Timeout", ":", "client", ".", "timeout", ",", "}", "\n", "}", "\n\n", "hystrix", ".", "ConfigureCommand", "(", "client", ".", "hystrixCommandName", ",", "hystrix", ".", "CommandConfig", "{", "Timeout", ":", "durationToInt", "(", "client", ".", "hystrixTimeout", ",", "time", ".", "Millisecond", ")", ",", "MaxConcurrentRequests", ":", "client", ".", "maxConcurrentRequests", ",", "RequestVolumeThreshold", ":", "client", ".", "requestVolumeThreshold", ",", "SleepWindow", ":", "client", ".", "sleepWindow", ",", "ErrorPercentThreshold", ":", "client", ".", "errorPercentThreshold", ",", "}", ")", "\n\n", "return", "&", "client", "\n", "}" ]

[ "NewClient", "returns", "a", "new", "instance", "of", "hystrix", "Client" ]

[ "func", "(", "hhc", "*", "Client", ")", "Patch", "(", "url", "string", ",", "body", "io", ".", "Reader", ",", "headers", "http", ".", "Header", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "var", "response", "*", "http", ".", "Response", "\n", "request", ",", "err", ":=", "http", ".", "NewRequest", "(", "http", ".", "MethodPatch", ",", "url", ",", "body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "response", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "request", ".", "Header", "=", "headers", "\n\n", "return", "hhc", ".", "Do", "(", "request", ")", "\n", "}" ]

[ "Patch", "makes", "a", "HTTP", "PATCH", "request", "to", "provided", "URL", "and", "requestBody" ]

[ "func", "(", "hhc", "*", "Client", ")", "Delete", "(", "url", "string", ",", "headers", "http", ".", "Header", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "var", "response", "*", "http", ".", "Response", "\n", "request", ",", "err", ":=", "http", ".", "NewRequest", "(", "http", ".", "MethodDelete", ",", "url", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "response", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "request", ".", "Header", "=", "headers", "\n\n", "return", "hhc", ".", "Do", "(", "request", ")", "\n", "}" ]

[ "Delete", "makes", "a", "HTTP", "DELETE", "request", "with", "provided", "URL" ]

[ "func", "CopyTo", "(", "ctx", "context", ".", "Context", ",", "name", "string", ",", "content", "[", "]", "byte", ")", "error", "{", "if", "clipboard", ".", "Unsupported", "{", "out", ".", "Yellow", "(", "ctx", ",", "\"", "\"", ",", "ErrNotSupported", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "clipboard", ".", "WriteAll", "(", "string", "(", "content", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "err", ":=", "clear", "(", "ctx", ",", "content", ",", "ctxutil", ".", "GetClipTimeout", "(", "ctx", ")", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "out", ".", "Print", "(", "ctx", ",", "\"", " ", "c", "lor.Y", "e", "llowString(n", "a", "me),", " ", "c", "xutil.G", "e", "tClipTimeout(c", "t", "x))", "", "", "\n", "return", "nil", "\n", "}" ]

[ "CopyTo", "copies", "the", "given", "data", "to", "the", "clipboard", "and", "enqueues", "automatic", "clearing", "of", "the", "clipboard" ]

[ "func", "GetCryptoBackend", "(", "ctx", "context", ".", "Context", ",", "cb", "backend", ".", "CryptoBackend", ",", "cfgdir", "string", ",", "agent", "*", "client", ".", "Client", ")", "(", "backend", ".", "Crypto", ",", "error", ")", "{", "ctx", "=", "client", ".", "WithClient", "(", "ctx", ",", "agent", ")", "\n", "ctx", "=", "ctxutil", ".", "WithConfigDir", "(", "ctx", ",", "cfgdir", ")", "\n", "crypto", ",", "err", ":=", "backend", ".", "NewCrypto", "(", "ctx", ",", "cb", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "crypto", ",", "nil", "\n", "}" ]

[ "GetCryptoBackend", "initialized", "the", "correct", "crypto", "backend" ]

[ "func", "(", "s", "*", "Action", ")", "Generate", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ")", "error", "{", "force", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "edit", ":=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n\n", "args", ",", "kvps", ":=", "parseArgs", "(", "c", ")", "\n", "name", ":=", "args", ".", "Get", "(", "0", ")", "\n", "key", ",", "length", ":=", "keyAndLength", "(", "args", ")", "\n\n", "// ask for name of the secret if it wasn't provided already", "if", "name", "==", "\"", "\"", "{", "var", "err", "error", "\n", "name", ",", "err", "=", "termio", ".", "AskForString", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "||", "name", "==", "\"", "\"", "{", "return", "ExitError", "(", "ctx", ",", "ExitNoName", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "ctx", "=", "s", ".", "Store", ".", "WithConfig", "(", "ctx", ",", "name", ")", "\n\n", "// ask for confirmation before overwriting existing entry", "if", "!", "force", "{", "// don't check if it's force anyway", "if", "s", ".", "Store", ".", "Exists", "(", "ctx", ",", "name", ")", "&&", "key", "==", "\"", "\"", "&&", "!", "termio", ".", "AskForConfirmation", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "{", "return", "ExitError", "(", "ctx", ",", "ExitAborted", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "// generate password", "password", ",", "err", ":=", "s", ".", "generatePassword", "(", "ctx", ",", "c", ",", "length", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// write generated password to store", "ctx", ",", "err", "=", "s", ".", "generateSetPassword", "(", "ctx", ",", "name", ",", "key", ",", "password", ",", "kvps", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// if requested launch editor to add more data to the generated secret", "if", "(", "edit", "||", "ctxutil", ".", "IsAskForMore", "(", "ctx", ")", ")", "&&", "termio", ".", "AskForConfirmation", "(", "ctx", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "{", "if", "err", ":=", "s", ".", "Edit", "(", "ctx", ",", "c", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitUnknown", ",", "err", ",", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "// display or copy to clipboard", "return", "s", ".", "generateCopyOrPrint", "(", "ctx", ",", "c", ",", "name", ",", "key", ",", "password", ")", "\n", "}" ]

[ "Generate", "and", "save", "a", "password" ]

[ "func", "(", "s", "*", "Action", ")", "generateCopyOrPrint", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ",", "name", ",", "key", ",", "password", "string", ")", "error", "{", "if", "ctxutil", ".", "IsAutoPrint", "(", "ctx", ")", "||", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "if", "key", "!=", "\"", "\"", "{", "key", "=", "\"", "\"", "+", "key", "\n", "}", "\n", "out", ".", "Print", "(", "ctx", ",", "\"", "\\n", "\"", ",", "name", ",", "key", ",", "color", ".", "YellowString", "(", "password", ")", ",", ")", "\n", "}", "\n\n", "if", "ctxutil", ".", "IsAutoClip", "(", "ctx", ")", "||", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "if", "err", ":=", "clipboard", ".", "CopyTo", "(", "ctx", ",", "name", ",", "[", "]", "byte", "(", "password", ")", ")", ";", "err", "!=", "nil", "{", "return", "ExitError", "(", "ctx", ",", "ExitIO", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "||", "c", ".", "Bool", "(", "\"", "\"", ")", "{", "return", "nil", "\n", "}", "\n\n", "entry", ":=", "name", "\n", "if", "key", "!=", "\"", "\"", "{", "entry", "+=", "\"", "\"", "+", "key", "\n", "}", "\n", "out", ".", "Print", "(", "ctx", ",", "\"", "\"", ",", "entry", ")", "\n", "return", "nil", "\n", "}" ]

[ "generateCopyOrPrint", "will", "print", "the", "password", "to", "the", "screen", "or", "copy", "to", "the", "clipboard" ]

[ "func", "(", "s", "*", "Action", ")", "generatePassword", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ",", "length", "string", ")", "(", "string", ",", "error", ")", "{", "if", "c", ".", "Bool", "(", "\"", "\"", ")", "||", "c", ".", "IsSet", "(", "\"", "\"", ")", "{", "return", "s", ".", "generatePasswordXKCD", "(", "ctx", ",", "c", ",", "length", ")", "\n", "}", "\n\n", "symbols", ":=", "ctxutil", ".", "IsUseSymbols", "(", "ctx", ")", "\n", "if", "c", ".", "IsSet", "(", "\"", "\"", ")", "{", "symbols", "=", "c", ".", "Bool", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "pwlen", "int", "\n", "if", "length", "==", "\"", "\"", "{", "candidateLength", ":=", "defaultLength", "\n", "question", ":=", "\"", "\"", "\n", "iv", ",", "err", ":=", "termio", ".", "AskForInt", "(", "ctx", ",", "question", ",", "candidateLength", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "pwlen", "=", "iv", "\n", "}", "else", "{", "iv", ",", "err", ":=", "strconv", ".", "Atoi", "(", "length", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "pwlen", "=", "iv", "\n", "}", "\n\n", "if", "pwlen", "<", "1", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "corp", ",", "err", ":=", "termio", ".", "AskForBool", "(", "ctx", ",", "\"", "\"", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "if", "corp", "{", "return", "pwgen", ".", "GeneratePasswordWithAllClasses", "(", "pwlen", ")", "\n", "}", "\n\n", "return", "pwgen", ".", "GeneratePassword", "(", "pwlen", ",", "symbols", ")", ",", "nil", "\n", "}" ]

[ "generatePassword", "will", "run", "through", "the", "password", "generation", "steps" ]

[ "func", "(", "s", "*", "Action", ")", "generatePasswordXKCD", "(", "ctx", "context", ".", "Context", ",", "c", "*", "cli", ".", "Context", ",", "length", "string", ")", "(", "string", ",", "error", ")", "{", "xkcdSeparator", ":=", "\"", "\"", "\n", "if", "c", ".", "IsSet", "(", "\"", "\"", ")", "{", "xkcdSeparator", "=", "c", ".", "String", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "pwlen", "int", "\n", "if", "length", "==", "\"", "\"", "{", "candidateLength", ":=", "defaultXKCDLength", "\n", "question", ":=", "\"", "\"", "\n", "iv", ",", "err", ":=", "termio", ".", "AskForInt", "(", "ctx", ",", "question", ",", "candidateLength", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "pwlen", "=", "iv", "\n", "}", "else", "{", "iv", ",", "err", ":=", "strconv", ".", "Atoi", "(", "length", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "pwlen", "=", "iv", "\n", "}", "\n\n", "if", "pwlen", "<", "1", "{", "return", "\"", "\"", ",", "ExitError", "(", "ctx", ",", "ExitUsage", ",", "nil", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "xkcdgen", ".", "RandomLengthDelim", "(", "pwlen", ",", "xkcdSeparator", ",", "c", ".", "String", "(", "\"", "\"", ")", ")", "\n", "}" ]

[ "generatePasswordXKCD", "walks", "through", "the", "steps", "necessary", "to", "create", "an", "XKCD", "-", "style", "password" ]