Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "query", "Query", ")", "Aggregate", "(", "mode", "string", ",", "field", "string", ",", "out", "interface", "{", "}", ")", "error", "{", "query", ".", "AggregateMode", "=", "mode", "\n", "query", ".", "AggregateField", "=", "field", "\n", "return", "query", ".", "repo", ".", "adapter", ".", "Aggregate", "(", "query", ",", "out", ",", "query", ".", "repo", ".", "logger", "...", ")", "\n", "}" ]

[ "Aggregate", "calculate", "aggregate", "over", "the", "given", "field", "." ]

[ "func", "(", "query", "Query", ")", "MustAggregate", "(", "mode", "string", ",", "field", "string", ",", "out", "interface", "{", "}", ")", "{", "must", "(", "query", ".", "Aggregate", "(", "mode", ",", "field", ",", "out", ")", ")", "\n", "}" ]

[ "MustAggregate", "calculate", "aggregate", "over", "the", "given", "field", ".", "It", "ll", "panic", "if", "any", "error", "eccured", "." ]

[ "func", "(", "query", "Query", ")", "Count", "(", ")", "(", "int", ",", "error", ")", "{", "var", "out", "struct", "{", "Count", "int", "\n", "}", "\n\n", "err", ":=", "query", ".", "Aggregate", "(", "\"", "\"", ",", "\"", "\"", ",", "&", "out", ")", "\n", "return", "out", ".", "Count", ",", "err", "\n", "}" ]

[ "Count", "retrieves", "count", "of", "results", "that", "match", "the", "query", "." ]

[ "func", "(", "query", "Query", ")", "MustCount", "(", ")", "int", "{", "count", ",", "err", ":=", "query", ".", "Count", "(", ")", "\n", "must", "(", "err", ")", "\n", "return", "count", "\n", "}" ]

[ "MustCount", "retrieves", "count", "of", "results", "that", "match", "the", "query", ".", "It", "ll", "panic", "if", "any", "error", "eccured", "." ]

[ "func", "(", "query", "Query", ")", "Insert", "(", "record", "interface", "{", "}", ",", "chs", "...", "*", "changeset", ".", "Changeset", ")", "error", "{", "var", "err", "error", "\n", "var", "ids", "[", "]", "interface", "{", "}", "\n\n", "if", "len", "(", "chs", ")", "==", "1", "{", "// single insert", "ch", ":=", "chs", "[", "0", "]", "\n", "changes", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "cloneChangeset", "(", "changes", ",", "ch", ".", "Changes", "(", ")", ")", "\n", "putTimestamp", "(", "changes", ",", "\"", "\"", ",", "ch", ".", "Types", "(", ")", ")", "\n", "putTimestamp", "(", "changes", ",", "\"", "\"", ",", "ch", ".", "Types", "(", ")", ")", "\n", "cloneQuery", "(", "changes", ",", "query", ".", "Changes", ")", "\n\n", "var", "id", "interface", "{", "}", "\n", "id", ",", "err", "=", "query", ".", "repo", ".", "adapter", ".", "Insert", "(", "query", ",", "changes", ",", "query", ".", "repo", ".", "logger", "...", ")", "\n", "ids", "=", "append", "(", "ids", ",", "id", ")", "\n", "}", "else", "if", "len", "(", "chs", ")", ">", "1", "{", "// multiple insert", "fields", ":=", "getFields", "(", "query", ",", "chs", ")", "\n\n", "allchanges", ":=", "make", "(", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "len", "(", "chs", ")", ")", "\n", "for", "i", ",", "ch", ":=", "range", "chs", "{", "changes", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "cloneChangeset", "(", "changes", ",", "ch", ".", "Changes", "(", ")", ")", "\n", "putTimestamp", "(", "changes", ",", "\"", "\"", ",", "ch", ".", "Types", "(", ")", ")", "\n", "putTimestamp", "(", "changes", ",", "\"", "\"", ",", "ch", ".", "Types", "(", ")", ")", "\n", "cloneQuery", "(", "changes", ",", "query", ".", "Changes", ")", "\n\n", "allchanges", "[", "i", "]", "=", "changes", "\n", "}", "\n\n", "ids", ",", "err", "=", "query", ".", "repo", ".", "adapter", ".", "InsertAll", "(", "query", ",", "fields", ",", "allchanges", ",", "query", ".", "repo", ".", "logger", "...", ")", "\n", "}", "else", "if", "len", "(", "query", ".", "Changes", ")", ">", "0", "{", "// set only", "var", "id", "interface", "{", "}", "\n", "id", ",", "err", "=", "query", ".", "repo", ".", "adapter", ".", "Insert", "(", "query", ",", "query", ".", "Changes", ",", "query", ".", "repo", ".", "logger", "...", ")", "\n", "ids", "=", "append", "(", "ids", ",", "id", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "transformError", "(", "err", ",", "chs", "...", ")", "\n", "}", "else", "if", "record", "==", "nil", "||", "len", "(", "ids", ")", "==", "0", "{", "return", "nil", "\n", "}", "else", "if", "len", "(", "ids", ")", "==", "1", "{", "return", "transformError", "(", "query", ".", "Find", "(", "ids", "[", "0", "]", ")", ".", "One", "(", "record", ")", ")", "\n", "}", "\n\n", "return", "transformError", "(", "query", ".", "Where", "(", "c", ".", "In", "(", "c", ".", "I", "(", "\"", "\"", ")", ",", "ids", "...", ")", ")", ".", "All", "(", "record", ")", ")", "\n", "}" ]

[ "Insert", "records", "to", "database", "." ]

[ "func", "(", "query", "Query", ")", "MustInsert", "(", "record", "interface", "{", "}", ",", "chs", "...", "*", "changeset", ".", "Changeset", ")", "{", "must", "(", "query", ".", "Insert", "(", "record", ",", "chs", "...", ")", ")", "\n", "}" ]

[ "MustInsert", "records", "to", "database", ".", "It", "ll", "panic", "if", "any", "error", "occurred", "." ]

[ "func", "(", "query", "Query", ")", "Update", "(", "record", "interface", "{", "}", ",", "chs", "...", "*", "changeset", ".", "Changeset", ")", "error", "{", "changes", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "// only take the first changeset if any", "if", "len", "(", "chs", ")", "!=", "0", "{", "cloneChangeset", "(", "changes", ",", "chs", "[", "0", "]", ".", "Changes", "(", ")", ")", "\n", "putTimestamp", "(", "changes", ",", "\"", "\"", ",", "chs", "[", "0", "]", ".", "Types", "(", ")", ")", "\n", "}", "\n\n", "cloneQuery", "(", "changes", ",", "query", ".", "Changes", ")", "\n\n", "// nothing to update", "if", "len", "(", "changes", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// perform update", "err", ":=", "query", ".", "repo", ".", "adapter", ".", "Update", "(", "query", ",", "changes", ",", "query", ".", "repo", ".", "logger", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "transformError", "(", "err", ",", "chs", "...", ")", "\n", "}", "\n\n", "// should not fetch updated record(s) if not necessery", "if", "record", "!=", "nil", "{", "return", "transformError", "(", "query", ".", "All", "(", "record", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Update", "records", "in", "database", ".", "It", "ll", "panic", "if", "any", "error", "occurred", "." ]

[ "func", "(", "query", "Query", ")", "MustUpdate", "(", "record", "interface", "{", "}", ",", "chs", "...", "*", "changeset", ".", "Changeset", ")", "{", "must", "(", "query", ".", "Update", "(", "record", ",", "chs", "...", ")", ")", "\n", "}" ]

[ "MustUpdate", "records", "in", "database", ".", "It", "ll", "panic", "if", "any", "error", "occurred", "." ]

[ "func", "(", "query", "Query", ")", "Save", "(", "record", "interface", "{", "}", ")", "error", "{", "rv", ":=", "reflect", ".", "ValueOf", "(", "record", ")", "\n", "rt", ":=", "rv", ".", "Type", "(", ")", "\n", "if", "rt", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "&&", "rt", ".", "Elem", "(", ")", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "{", "// Put multiple records", "rv", "=", "rv", ".", "Elem", "(", ")", "\n\n", "// if it's an empty slice, do nothing", "if", "rv", ".", "Len", "(", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "if", "query", ".", "Condition", ".", "None", "(", ")", "{", "// InsertAll", "chs", ":=", "[", "]", "*", "changeset", ".", "Changeset", "{", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "rv", ".", "Len", "(", ")", ";", "i", "++", "{", "ch", ":=", "changeset", ".", "Convert", "(", "rv", ".", "Index", "(", "i", ")", ".", "Interface", "(", ")", ")", "\n", "changeset", ".", "DeleteChange", "(", "ch", ",", "\"", "\"", ")", "\n", "chs", "=", "append", "(", "chs", ",", "ch", ")", "\n", "}", "\n\n", "return", "query", ".", "Insert", "(", "record", ",", "chs", "...", ")", "\n", "}", "\n\n", "// Update only with first record definition.", "ch", ":=", "changeset", ".", "Convert", "(", "rv", ".", "Index", "(", "0", ")", ".", "Interface", "(", ")", ")", "\n", "changeset", ".", "DeleteChange", "(", "ch", ",", "\"", "\"", ")", "\n", "changeset", ".", "DeleteChange", "(", "ch", ",", "\"", "\"", ")", "\n", "return", "query", ".", "Update", "(", "record", ",", "ch", ")", "\n", "}", "\n\n", "// Put single records", "ch", ":=", "changeset", ".", "Convert", "(", "record", ")", "\n", "changeset", ".", "DeleteChange", "(", "ch", ",", "\"", "\"", ")", "\n\n", "if", "query", ".", "Condition", ".", "None", "(", ")", "{", "return", "query", ".", "Insert", "(", "record", ",", "ch", ")", "\n", "}", "\n\n", "// remove created_at from changeset", "changeset", ".", "DeleteChange", "(", "ch", ",", "\"", "\"", ")", "\n\n", "return", "query", ".", "Update", "(", "record", ",", "ch", ")", "\n", "}" ]

[ "Save", "a", "record", "to", "database", ".", "If", "condition", "exist", "it", "will", "try", "to", "update", "the", "record", "otherwise", "it", "ll", "insert", "it", ".", "Save", "ignores", "id", "from", "record", "." ]

[ "func", "(", "query", "Query", ")", "Delete", "(", ")", "error", "{", "return", "transformError", "(", "query", ".", "repo", ".", "adapter", ".", "Delete", "(", "query", ",", "query", ".", "repo", ".", "logger", "...", ")", ")", "\n", "}" ]

[ "Delete", "deletes", "all", "results", "that", "match", "the", "query", "." ]

[ "func", "(", "query", "Query", ")", "Preload", "(", "record", "interface", "{", "}", ",", "field", "string", ")", "error", "{", "path", ":=", "strings", ".", "Split", "(", "field", ",", "\"", "\"", ")", "\n\n", "rv", ":=", "reflect", ".", "ValueOf", "(", "record", ")", "\n", "if", "rv", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "||", "rv", ".", "IsNil", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "preload", ":=", "traversePreloadTarget", "(", "rv", ".", "Elem", "(", ")", ",", "path", ")", "\n", "if", "len", "(", "preload", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "schemaType", ":=", "preload", "[", "0", "]", ".", "schema", ".", "Type", "(", ")", "\n", "refIndex", ",", "fkIndex", ",", "column", ":=", "getPreloadInfo", "(", "schemaType", ",", "path", "[", "len", "(", "path", ")", "-", "1", "]", ")", "\n\n", "addrs", ",", "ids", ":=", "collectPreloadTarget", "(", "preload", ",", "refIndex", ")", "\n", "if", "len", "(", "ids", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "// prepare temp result variable for querying", "rt", ":=", "preload", "[", "0", "]", ".", "field", ".", "Type", "(", ")", "\n", "if", "rt", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "||", "rt", ".", "Kind", "(", ")", "==", "reflect", ".", "Array", "||", "rt", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "rt", "=", "rt", ".", "Elem", "(", ")", "\n", "}", "\n\n", "slice", ":=", "reflect", ".", "MakeSlice", "(", "reflect", ".", "SliceOf", "(", "rt", ")", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "result", ":=", "reflect", ".", "New", "(", "slice", ".", "Type", "(", ")", ")", "\n", "result", ".", "Elem", "(", ")", ".", "Set", "(", "slice", ")", "\n\n", "// query all records using collected ids.", "err", ":=", "query", ".", "Where", "(", "c", ".", "In", "(", "c", ".", "I", "(", "column", ")", ",", "ids", "...", ")", ")", ".", "All", "(", "result", ".", "Interface", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// map results.", "result", "=", "result", ".", "Elem", "(", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "result", ".", "Len", "(", ")", ";", "i", "++", "{", "curr", ":=", "result", ".", "Index", "(", "i", ")", "\n", "id", ":=", "getPreloadID", "(", "curr", ".", "FieldByIndex", "(", "fkIndex", ")", ")", "\n\n", "for", "_", ",", "addr", ":=", "range", "addrs", "[", "id", "]", "{", "if", "addr", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "{", "addr", ".", "Set", "(", "reflect", ".", "Append", "(", "addr", ",", "curr", ")", ")", "\n", "}", "else", "if", "addr", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "currP", ":=", "reflect", ".", "New", "(", "curr", ".", "Type", "(", ")", ")", "\n", "currP", ".", "Elem", "(", ")", ".", "Set", "(", "curr", ")", "\n", "addr", ".", "Set", "(", "currP", ")", "\n", "}", "else", "{", "addr", ".", "Set", "(", "curr", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Preload", "loads", "association", "with", "given", "query", "." ]

[ "func", "(", "query", "Query", ")", "MustPreload", "(", "record", "interface", "{", "}", ",", "field", "string", ")", "{", "must", "(", "query", ".", "Preload", "(", "record", ",", "field", ")", ")", "\n", "}" ]

[ "MustPreload", "loads", "association", "with", "given", "query", ".", "It", "ll", "panic", "if", "any", "error", "occurred", "." ]

[ "func", "New", "(", "message", "string", ",", "field", "string", ",", "kind", "Kind", ")", "Error", "{", "return", "Error", "{", "message", ",", "field", ",", "0", ",", "kind", "}", "\n", "}" ]

[ "New", "creates", "an", "error", "." ]

[ "func", "NewWithCode", "(", "message", "string", ",", "field", "string", ",", "code", "int", ",", "kind", "Kind", ")", "Error", "{", "return", "Error", "{", "message", ",", "field", ",", "code", ",", "kind", "}", "\n", "}" ]

[ "NewWithCode", "creates", "an", "error", "with", "code", "." ]

[ "func", "UniqueConstraint", "(", "ch", "*", "Changeset", ",", "field", "string", ",", "opts", "...", "Option", ")", "{", "options", ":=", "Options", "{", "message", ":", "UniqueConstraintMessage", ",", "name", ":", "field", ",", "exact", ":", "false", ",", "}", "\n", "options", ".", "apply", "(", "opts", ")", "\n\n", "ch", ".", "constraints", "=", "append", "(", "ch", ".", "constraints", ",", "Constraint", "{", "Field", ":", "field", ",", "Message", ":", "strings", ".", "Replace", "(", "options", ".", "message", ",", "\"", "\"", ",", "field", ",", "1", ")", ",", "Code", ":", "options", ".", "code", ",", "Name", ":", "options", ".", "name", ",", "Exact", ":", "options", ".", "exact", ",", "Kind", ":", "errors", ".", "UniqueConstraint", ",", "}", ")", "\n", "}" ]

[ "UniqueConstraint", "adds", "an", "unique", "constraint", "to", "changeset", "." ]

[ "func", "PutAssoc", "(", "ch", "*", "Changeset", ",", "field", "string", ",", "value", "interface", "{", "}", ",", "opts", "...", "Option", ")", "{", "options", ":=", "Options", "{", "message", ":", "PutAssocErrorMessage", ",", "}", "\n", "options", ".", "apply", "(", "opts", ")", "\n", "if", "typ", ",", "exist", ":=", "ch", ".", "types", "[", "field", "]", ";", "exist", "{", "if", "typ", ".", "Kind", "(", ")", "==", "reflect", ".", "Struct", "{", "valTyp", ":=", "reflect", ".", "TypeOf", "(", "value", ")", "\n", "if", "valTyp", "==", "reflect", ".", "TypeOf", "(", "ch", ")", "{", "ch", ".", "changes", "[", "field", "]", "=", "value", "\n", "return", "\n", "}", "\n", "}", "else", "if", "typ", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "&&", "typ", ".", "Elem", "(", ")", ".", "Kind", "(", ")", "==", "reflect", ".", "Struct", "{", "valTyp", ":=", "reflect", ".", "TypeOf", "(", "value", ")", "\n", "if", "valTyp", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "&&", "valTyp", ".", "Elem", "(", ")", ".", "ConvertibleTo", "(", "reflect", ".", "TypeOf", "(", "ch", ")", ")", "{", "ch", ".", "changes", "[", "field", "]", "=", "value", "\n", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "msg", ":=", "strings", ".", "Replace", "(", "options", ".", "message", ",", "\"", "\"", ",", "field", ",", "1", ")", "\n", "AddError", "(", "ch", ",", "field", ",", "msg", ")", "\n", "}" ]

[ "PutAssoc", "to", "changeset", "." ]

[ "func", "UniqueConstraint", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "extra1", ":=", "Extra", "{", "}", "\n", "extra2", ":=", "Extra", "{", "}", "\n", "repo", ".", "From", "(", "extras", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "MustInsert", "(", "&", "extra1", ")", "\n", "repo", ".", "From", "(", "extras", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "MustInsert", "(", "&", "extra2", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "// inserting", "err", ":=", "repo", ".", "From", "(", "extras", ")", ".", "Set", "(", "\"", "\"", ",", "extra1", ".", "Slug", ")", ".", "Insert", "(", "nil", ")", "\n", "assertConstraint", "(", "t", ",", "err", ",", "errors", ".", "UniqueConstraint", ",", "\"", "\"", ")", "\n\n", "// updating", "err", "=", "repo", ".", "From", "(", "extras", ")", ".", "Find", "(", "extra2", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "extra1", ".", "Slug", ")", ".", "Update", "(", "nil", ")", "\n", "assertConstraint", "(", "t", ",", "err", ",", "errors", ".", "UniqueConstraint", ",", "\"", "\"", ")", "\n", "}", ")", "\n", "}" ]

[ "UniqueConstraint", "tests", "unique", "constraint", "specifications", "." ]

[ "func", "ForeignKeyConstraint", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "extra", ":=", "Extra", "{", "}", "\n", "repo", ".", "From", "(", "extras", ")", ".", "MustSave", "(", "&", "extra", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "// inserting", "err", ":=", "repo", ".", "From", "(", "extras", ")", ".", "Set", "(", "\"", "\"", ",", "1000", ")", ".", "Insert", "(", "nil", ")", "\n", "assertConstraint", "(", "t", ",", "err", ",", "errors", ".", "ForeignKeyConstraint", ",", "\"", "\"", ")", "\n\n", "// updating", "err", "=", "repo", ".", "From", "(", "extras", ")", ".", "Find", "(", "extra", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "1000", ")", ".", "Update", "(", "nil", ")", "\n", "assertConstraint", "(", "t", ",", "err", ",", "errors", ".", "ForeignKeyConstraint", ",", "\"", "\"", ")", "\n", "}", ")", "\n", "}" ]

[ "ForeignKeyConstraint", "tests", "foreign", "key", "constraint", "specifications", "." ]

[ "func", "Scan", "(", "value", "interface", "{", "}", ",", "rows", "Rows", ")", "(", "int64", ",", "error", ")", "{", "columns", ",", "err", ":=", "rows", ".", "Columns", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "rv", ":=", "reflect", ".", "ValueOf", "(", "value", ")", "\n", "if", "rv", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "||", "rv", ".", "IsNil", "(", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "count", ":=", "int64", "(", "0", ")", "\n", "rv", "=", "rv", ".", "Elem", "(", ")", "\n", "var", "index", "map", "[", "string", "]", "int", "\n", "isScanner", ":=", "rv", ".", "Addr", "(", ")", ".", "Type", "(", ")", ".", "Implements", "(", "typeScanner", ")", "\n", "isSlice", ":=", "rv", ".", "Kind", "(", ")", "==", "reflect", ".", "Slice", "&&", "rv", ".", "Type", "(", ")", ".", "Elem", "(", ")", ".", "Kind", "(", ")", "!=", "reflect", ".", "Uint8", "&&", "!", "isScanner", "\n\n", "if", "!", "isScanner", "{", "if", "isSlice", "{", "rv", ".", "Set", "(", "reflect", ".", "MakeSlice", "(", "rv", ".", "Type", "(", ")", ",", "0", ",", "0", ")", ")", "\n", "index", "=", "fieldIndex", "(", "rv", ".", "Type", "(", ")", ".", "Elem", "(", ")", ")", "\n", "}", "else", "{", "index", "=", "fieldIndex", "(", "rv", ".", "Type", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "for", "rows", ".", "Next", "(", ")", "{", "var", "elem", "reflect", ".", "Value", "\n", "if", "isSlice", "{", "elem", "=", "reflect", ".", "New", "(", "rv", ".", "Type", "(", ")", ".", "Elem", "(", ")", ")", ".", "Elem", "(", ")", "\n", "}", "else", "{", "elem", "=", "rv", "\n", "}", "\n\n", "var", "ptr", "[", "]", "interface", "{", "}", "\n", "var", "reset", "map", "[", "int", "]", "reflect", ".", "Value", "\n", "if", "isScanner", "{", "ptr", "=", "[", "]", "interface", "{", "}", "{", "elem", ".", "Addr", "(", ")", ".", "Interface", "(", ")", "}", "\n", "}", "else", "{", "ptr", ",", "reset", "=", "fieldPtr", "(", "elem", ",", "index", ",", "columns", ")", "\n", "}", "\n\n", "err", "=", "rows", ".", "Scan", "(", "ptr", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "count", "++", "\n\n", "for", "index", ",", "field", ":=", "range", "reset", "{", "if", "v", ":=", "reflect", ".", "ValueOf", "(", "ptr", "[", "index", "]", ")", ".", "Elem", "(", ")", ".", "Elem", "(", ")", ";", "v", ".", "IsValid", "(", ")", "{", "field", ".", "Set", "(", "v", ")", "\n", "}", "\n", "}", "\n\n", "if", "isSlice", "{", "rv", ".", "Set", "(", "reflect", ".", "Append", "(", "rv", ",", "elem", ")", ")", "\n", "}", "else", "{", "break", "\n", "}", "\n", "}", "\n\n", "return", "count", ",", "nil", "\n", "}" ]

[ "Scan", "rows", "into", "interface" ]

[ "func", "UnescapeString", "(", "ch", "*", "Changeset", ",", "field", "string", ")", "{", "ApplyString", "(", "ch", ",", "field", ",", "html", ".", "UnescapeString", ")", "\n", "}" ]

[ "UnescapeString", "unescapes", "entities", "like", "&lt", ";", "to", "become", "<", ".", "this", "is", "helper", "for", "html", ".", "UnescapeString", "." ]

[ "func", "PutDefault", "(", "ch", "*", "Changeset", ",", "field", "string", ",", "value", "interface", "{", "}", ",", "opts", "...", "Option", ")", "{", "options", ":=", "Options", "{", "message", ":", "PutDefaultErrorMessage", ",", "}", "\n", "options", ".", "apply", "(", "opts", ")", "\n\n", "if", "typ", ",", "exist", ":=", "ch", ".", "types", "[", "field", "]", ";", "exist", "{", "valTyp", ":=", "reflect", ".", "TypeOf", "(", "value", ")", "\n", "if", "valTyp", ".", "ConvertibleTo", "(", "typ", ")", "{", "if", "ch", ".", "changes", "[", "field", "]", "==", "nil", "{", "ch", ".", "changes", "[", "field", "]", "=", "value", "\n", "}", "\n", "return", "\n", "}", "\n", "}", "\n\n", "msg", ":=", "strings", ".", "Replace", "(", "options", ".", "message", ",", "\"", "\"", ",", "field", ",", "1", ")", "\n", "AddError", "(", "ch", ",", "field", ",", "msg", ")", "\n", "}" ]

[ "PutDefault", "to", "changeset", "." ]

[ "func", "(", "constraints", "Constraints", ")", "GetError", "(", "err", "errors", ".", "Error", ")", "error", "{", "if", "err", ".", "Kind", "(", ")", "==", "errors", ".", "Unexpected", "||", "err", ".", "Kind", "(", ")", "==", "errors", ".", "Changeset", "||", "err", ".", "Kind", "(", ")", "==", "errors", ".", "NotFound", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "c", ":=", "range", "constraints", "{", "if", "c", ".", "Kind", "==", "err", ".", "Kind", "(", ")", "{", "if", "c", ".", "Exact", "&&", "c", ".", "Name", "!=", "err", ".", "Field", "{", "continue", "\n", "}", "\n\n", "if", "!", "c", ".", "Exact", "&&", "!", "strings", ".", "Contains", "(", "err", ".", "Field", ",", "c", ".", "Name", ")", "{", "continue", "\n", "}", "\n\n", "return", "errors", ".", "NewWithCode", "(", "c", ".", "Message", ",", "c", ".", "Field", ",", "c", ".", "Code", ",", "c", ".", "Kind", ")", "\n", "}", "\n", "}", "\n\n", "return", "errors", ".", "NewUnexpected", "(", "err", ".", "Message", ")", "\n", "}" ]

[ "GetError", "converts", "error", "based", "on", "constraints", ".", "If", "the", "original", "error", "is", "constraint", "error", "and", "it", "s", "defined", "in", "the", "constraint", "list", "then", "it", "ll", "be", "updated", "with", "constraint", "s", "message", ".", "If", "the", "original", "error", "is", "constraint", "error", "but", "not", "defined", "in", "the", "constraint", "list", "it", "ll", "be", "converted", "to", "unexpected", "error", ".", "else", "it", "ll", "not", "modify", "the", "error", "." ]

[ "func", "SaveInsert", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "tests", ":=", "[", "]", "grimoire", ".", "Query", "{", "repo", ".", "From", "(", "users", ")", ",", "}", "\n\n", "for", "_", ",", "query", ":=", "range", "tests", "{", "record", ":=", "User", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "query", ".", "Save", "(", "&", "record", ")", ")", "\n\n", "var", "result", "User", "\n", "assert", ".", "Nil", "(", "t", ",", "query", ".", "Find", "(", "record", ".", "ID", ")", ".", "One", "(", "&", "result", ")", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "record", ",", "result", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "SaveInsert", "tests", "insert", "specifications", "." ]

[ "func", "SaveInsertAll", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "tests", ":=", "[", "]", "grimoire", ".", "Query", "{", "repo", ".", "From", "(", "users", ")", ",", "}", "\n\n", "for", "_", ",", "query", ":=", "range", "tests", "{", "records", ":=", "[", "]", "User", "{", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", ",", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", ",", "}", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "query", ".", "Save", "(", "&", "records", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "SaveInsertAll", "tests", "insert", "multiple", "recors", "specifications", "." ]

[ "func", "ParseForm", "(", "raw", "url", ".", "Values", ")", "Form", "{", "result", ":=", "make", "(", "Form", ",", "len", "(", "raw", ")", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "raw", "{", "if", "len", "(", "v", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "fields", ":=", "strings", ".", "FieldsFunc", "(", "k", ",", "fieldsExtractor", ")", "\n\n", "pfield", ",", "cfield", ":=", "\"", "\"", ",", "\"", "\"", "\n", "form", ":=", "result", "\n", "for", "i", ":=", "range", "fields", "{", "pfield", "=", "cfield", "\n", "cfield", "=", "fields", "[", "i", "]", "\n\n", "if", "index", ",", "err", ":=", "strconv", ".", "Atoi", "(", "cfield", ")", ";", "err", "==", "nil", "{", "if", "i", "==", "len", "(", "fields", ")", "-", "1", "{", "form", ".", "assigns", "(", "pfield", ",", "\"", "\"", ",", "index", ",", "v", "[", "0", "]", ")", "\n", "}", "else", "{", "form", ".", "assigns", "(", "pfield", ",", "\"", "\"", ",", "index", ",", "nil", ")", "\n", "form", "=", "form", "[", "pfield", "]", "[", "index", "]", ".", "(", "Form", ")", "\n", "cfield", "=", "\"", "\"", "// set cfield empty, so unnecesary nesting wont be created in the next loop", "\n", "}", "\n", "}", "else", "{", "if", "i", "==", "len", "(", "fields", ")", "-", "1", "{", "form", ".", "assigns", "(", "pfield", ",", "cfield", ",", "-", "1", ",", "v", ")", "\n", "}", "else", "{", "form", ".", "assigns", "(", "pfield", ",", "cfield", ",", "-", "1", ",", "nil", ")", "\n", "if", "pfield", "!=", "\"", "\"", "{", "index", ":=", "len", "(", "form", "[", "pfield", "]", ")", "-", "1", "\n", "form", "=", "form", "[", "pfield", "]", "[", "index", "]", ".", "(", "Form", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "ParseForm", "form", "from", "url", "values", "." ]

[ "func", "Open", "(", "dsn", "string", ")", "(", "*", "Adapter", ",", "error", ")", "{", "var", "err", "error", "\n\n", "adapter", ":=", "&", "Adapter", "{", "Adapter", ":", "&", "sql", ".", "Adapter", "{", "Config", ":", "&", "sql", ".", "Config", "{", "Placeholder", ":", "\"", "\"", ",", "EscapeChar", ":", "\"", "\"", ",", "IncrementFunc", ":", "incrementFunc", ",", "ErrorFunc", ":", "errorFunc", ",", "}", ",", "}", ",", "}", "\n", "adapter", ".", "DB", ",", "err", "=", "db", ".", "Open", "(", "\"", "\"", ",", "dsn", ")", "\n\n", "return", "adapter", ",", "err", "\n", "}" ]

[ "Open", "mysql", "connection", "using", "dsn", "." ]

[ "func", "ValidateRegexp", "(", "ch", "*", "Changeset", ",", "field", "string", ",", "exp", "*", "regexp", ".", "Regexp", ",", "opts", "...", "Option", ")", "{", "val", ",", "exist", ":=", "ch", ".", "changes", "[", "field", "]", "\n", "if", "!", "exist", "{", "return", "\n", "}", "\n\n", "options", ":=", "Options", "{", "message", ":", "ValidateRegexpErrorMessage", ",", "}", "\n", "options", ".", "apply", "(", "opts", ")", "\n\n", "if", "str", ",", "ok", ":=", "val", ".", "(", "string", ")", ";", "ok", "{", "match", ":=", "exp", ".", "MatchString", "(", "str", ")", "\n", "if", "!", "match", "{", "msg", ":=", "strings", ".", "Replace", "(", "options", ".", "message", ",", "\"", "\"", ",", "field", ",", "1", ")", "\n", "AddError", "(", "ch", ",", "field", ",", "msg", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "}" ]

[ "ValidateRegexp", "validates", "the", "value", "of", "given", "field", "to", "match", "given", "regexp", "." ]

[ "func", "UpdateWhere", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "user", ":=", "User", "{", "Name", ":", "\"", "\"", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "user", ")", "\n\n", "address", ":=", "Address", "{", "Address", ":", "\"", "\"", "}", "\n", "repo", ".", "From", "(", "addresses", ")", ".", "MustSave", "(", "&", "address", ")", "\n\n", "tests", ":=", "[", "]", "struct", "{", "query", "grimoire", ".", "Query", "\n", "schema", "interface", "{", "}", "\n", "record", "interface", "{", "}", "\n", "params", "params", ".", "Params", "\n", "}", "{", "{", "repo", ".", "From", "(", "users", ")", ".", "Where", "(", "c", ".", "Eq", "(", "name", ",", "\"", "\"", ")", ")", ",", "User", "{", "}", ",", "&", "[", "]", "User", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "100", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Where", "(", "c", ".", "Eq", "(", "c", ".", "I", "(", "\"", "\"", ")", ",", "\"", "\"", ")", ")", ",", "Address", "{", "}", ",", "&", "[", "]", "Address", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "user", ".", "ID", "}", "}", ",", "}", "\n\n", "for", "_", ",", "test", ":=", "range", "tests", "{", "ch", ":=", "changeset", ".", "Cast", "(", "test", ".", "schema", ",", "test", ".", "params", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ")", "\n", "statement", ",", "_", ":=", "builder", ".", "Update", "(", "test", ".", "query", ".", "Collection", ",", "ch", ".", "Changes", "(", ")", ",", "test", ".", "query", ".", "Condition", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", "+", "statement", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "ch", ".", "Error", "(", ")", ")", "\n\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Update", "(", "nil", ",", "ch", ")", ")", "\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Update", "(", "test", ".", "record", ",", "ch", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "UpdateWhere", "tests", "update", "specifications", "." ]

[ "func", "UpdateSet", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "user", ":=", "User", "{", "Name", ":", "\"", "\"", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "user", ")", "\n\n", "address", ":=", "Address", "{", "Address", ":", "\"", "\"", "}", "\n", "repo", ".", "From", "(", "addresses", ")", ".", "MustSave", "(", "&", "address", ")", "\n\n", "tests", ":=", "[", "]", "struct", "{", "query", "grimoire", ".", "Query", "\n", "record", "interface", "{", "}", "\n", "}", "{", "{", "repo", ".", "From", "(", "users", ")", ".", "Find", "(", "user", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ".", "Find", "(", "user", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Set", "(", "\"", "\"", ",", "18", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ".", "Find", "(", "user", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Find", "(", "address", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "Address", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Find", "(", "address", ".", "ID", ")", ".", "Set", "(", "\"", "\"", ",", "user", ".", "ID", ")", ",", "&", "Address", "{", "}", "}", ",", "}", "\n\n", "for", "_", ",", "test", ":=", "range", "tests", "{", "statement", ",", "_", ":=", "builder", ".", "Update", "(", "test", ".", "query", ".", "Collection", ",", "test", ".", "query", ".", "Changes", ",", "test", ".", "query", ".", "Condition", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", "+", "statement", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Update", "(", "nil", ")", ")", "\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Update", "(", "test", ".", "record", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "UpdateSet", "tests", "update", "specifications", "using", "Set", "query", "." ]

[ "func", "Insert", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "user", ":=", "User", "{", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "user", ")", "\n\n", "tests", ":=", "[", "]", "struct", "{", "query", "grimoire", ".", "Query", "\n", "record", "interface", "{", "}", "\n", "input", "params", ".", "Params", "\n", "}", "{", "{", "repo", ".", "From", "(", "users", ")", ",", "&", "User", "{", "}", ",", "params", ".", "Map", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ",", "&", "User", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "100", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ",", "&", "User", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "100", ",", "\"", "\"", ":", "\"", "\"", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ",", "&", "User", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ",", "&", "Address", "{", "}", ",", "params", ".", "Map", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ",", "&", "Address", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ",", "&", "Address", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "user", ".", "ID", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ",", "&", "Address", "{", "}", ",", "params", ".", "Map", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "user", ".", "ID", "}", "}", ",", "}", "\n\n", "for", "_", ",", "test", ":=", "range", "tests", "{", "ch", ":=", "changeset", ".", "Cast", "(", "test", ".", "record", ",", "test", ".", "input", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", ")", "\n", "statement", ",", "_", ":=", "builder", ".", "Insert", "(", "test", ".", "query", ".", "Collection", ",", "ch", ".", "Changes", "(", ")", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", "+", "statement", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "ch", ".", "Error", "(", ")", ")", "\n\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Insert", "(", "nil", ",", "ch", ")", ")", "\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Insert", "(", "test", ".", "record", ",", "ch", ")", ")", "\n\n", "// multiple insert", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Insert", "(", "nil", ",", "ch", ",", "ch", ",", "ch", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "Insert", "tests", "insert", "specifications", "." ]

[ "func", "InsertSet", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "user", ":=", "User", "{", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "user", ")", "\n", "now", ":=", "time", ".", "Now", "(", ")", "\n\n", "tests", ":=", "[", "]", "struct", "{", "query", "grimoire", ".", "Query", "\n", "record", "interface", "{", "}", "\n", "}", "{", "{", "repo", ".", "From", "(", "users", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Set", "(", "\"", "\"", ",", "100", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Set", "(", "\"", "\"", ",", "100", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "users", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "User", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ",", "&", "Address", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "\"", "\"", ")", ".", "Set", "(", "\"", "\"", ",", "user", ".", "ID", ")", ",", "&", "Address", "{", "}", "}", ",", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "now", ")", ".", "Set", "(", "\"", "\"", ",", "user", ".", "ID", ")", ",", "&", "Address", "{", "}", "}", ",", "}", "\n\n", "for", "_", ",", "test", ":=", "range", "tests", "{", "statement", ",", "_", ":=", "builder", ".", "Insert", "(", "test", ".", "query", ".", "Collection", ",", "test", ".", "query", ".", "Changes", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", "+", "statement", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Insert", "(", "nil", ")", ")", "\n", "assert", ".", "Nil", "(", "t", ",", "test", ".", "query", ".", "Insert", "(", "test", ".", "record", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "InsertSet", "tests", "insert", "specifications", "only", "using", "Set", "query", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "All", "(", "query", "grimoire", ".", "Query", ",", "doc", "interface", "{", "}", ",", "loggers", "...", "grimoire", ".", "Logger", ")", "(", "int", ",", "error", ")", "{", "statement", ",", "args", ":=", "NewBuilder", "(", "adapter", ".", "Config", ")", ".", "Find", "(", "query", ")", "\n", "count", ",", "err", ":=", "adapter", ".", "Query", "(", "doc", ",", "statement", ",", "args", ",", "loggers", "...", ")", "\n", "return", "int", "(", "count", ")", ",", "err", "\n", "}" ]

[ "All", "retrieves", "all", "record", "that", "match", "the", "query", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Aggregate", "(", "query", "grimoire", ".", "Query", ",", "doc", "interface", "{", "}", ",", "loggers", "...", "grimoire", ".", "Logger", ")", "error", "{", "statement", ",", "args", ":=", "NewBuilder", "(", "adapter", ".", "Config", ")", ".", "Aggregate", "(", "query", ")", "\n", "_", ",", "err", ":=", "adapter", ".", "Query", "(", "doc", ",", "statement", ",", "args", ",", "loggers", "...", ")", "\n", "return", "err", "\n", "}" ]

[ "Aggregate", "record", "using", "given", "query", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "InsertAll", "(", "query", "grimoire", ".", "Query", ",", "fields", "[", "]", "string", ",", "allchanges", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ",", "loggers", "...", "grimoire", ".", "Logger", ")", "(", "[", "]", "interface", "{", "}", ",", "error", ")", "{", "statement", ",", "args", ":=", "NewBuilder", "(", "adapter", ".", "Config", ")", ".", "InsertAll", "(", "query", ".", "Collection", ",", "fields", ",", "allchanges", ")", "\n", "id", ",", "_", ",", "err", ":=", "adapter", ".", "Exec", "(", "statement", ",", "args", ",", "loggers", "...", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "ids", ":=", "[", "]", "interface", "{", "}", "{", "id", "}", "\n", "inc", ":=", "1", "\n\n", "if", "adapter", ".", "Config", ".", "IncrementFunc", "!=", "nil", "{", "inc", "=", "adapter", ".", "Config", ".", "IncrementFunc", "(", "*", "adapter", ")", "\n", "}", "\n\n", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "allchanges", ")", ";", "i", "++", "{", "ids", "=", "append", "(", "ids", ",", "id", "+", "int64", "(", "inc", "*", "i", ")", ")", "\n", "}", "\n\n", "return", "ids", ",", "nil", "\n", "}" ]

[ "InsertAll", "inserts", "all", "record", "to", "database", "and", "returns", "its", "ids", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Commit", "(", ")", "error", "{", "var", "err", "error", "\n\n", "if", "adapter", ".", "Tx", "==", "nil", "{", "err", "=", "errors", ".", "NewUnexpected", "(", "\"", "\"", ")", "\n", "}", "else", "if", "adapter", ".", "savepoint", ">", "0", "{", "_", ",", "_", ",", "err", "=", "adapter", ".", "Exec", "(", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "adapter", ".", "savepoint", ")", "+", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "}", ")", "\n", "}", "else", "{", "err", "=", "adapter", ".", "Tx", ".", "Commit", "(", ")", "\n", "}", "\n\n", "return", "adapter", ".", "Config", ".", "ErrorFunc", "(", "err", ")", "\n", "}" ]

[ "Commit", "commits", "current", "transaction", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Query", "(", "out", "interface", "{", "}", ",", "statement", "string", ",", "args", "[", "]", "interface", "{", "}", ",", "loggers", "...", "grimoire", ".", "Logger", ")", "(", "int64", ",", "error", ")", "{", "var", "rows", "*", "sql", ".", "Rows", "\n", "var", "err", "error", "\n\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "if", "adapter", ".", "Tx", "!=", "nil", "{", "rows", ",", "err", "=", "adapter", ".", "Tx", ".", "Query", "(", "statement", ",", "args", "...", ")", "\n", "}", "else", "{", "rows", ",", "err", "=", "adapter", ".", "DB", ".", "Query", "(", "statement", ",", "args", "...", ")", "\n", "}", "\n", "go", "grimoire", ".", "Log", "(", "loggers", ",", "statement", ",", "time", ".", "Since", "(", "start", ")", ",", "err", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "adapter", ".", "Config", ".", "ErrorFunc", "(", "err", ")", "\n", "}", "\n\n", "defer", "rows", ".", "Close", "(", ")", "\n", "count", ",", "err", ":=", "Scan", "(", "out", ",", "rows", ")", "\n", "return", "count", ",", "adapter", ".", "Config", ".", "ErrorFunc", "(", "err", ")", "\n", "}" ]

[ "Query", "performs", "query", "operation", "." ]

[ "func", "(", "adapter", "*", "Adapter", ")", "Exec", "(", "statement", "string", ",", "args", "[", "]", "interface", "{", "}", ",", "loggers", "...", "grimoire", ".", "Logger", ")", "(", "int64", ",", "int64", ",", "error", ")", "{", "var", "res", "sql", ".", "Result", "\n", "var", "err", "error", "\n\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "if", "adapter", ".", "Tx", "!=", "nil", "{", "res", ",", "err", "=", "adapter", ".", "Tx", ".", "Exec", "(", "statement", ",", "args", "...", ")", "\n", "}", "else", "{", "res", ",", "err", "=", "adapter", ".", "DB", ".", "Exec", "(", "statement", ",", "args", "...", ")", "\n", "}", "\n", "go", "grimoire", ".", "Log", "(", "loggers", ",", "statement", ",", "time", ".", "Since", "(", "start", ")", ",", "err", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "0", ",", "adapter", ".", "Config", ".", "ErrorFunc", "(", "err", ")", "\n", "}", "\n\n", "lastID", ",", "_", ":=", "res", ".", "LastInsertId", "(", ")", "\n", "rowCount", ",", "_", ":=", "res", ".", "RowsAffected", "(", ")", "\n\n", "return", "lastID", ",", "rowCount", ",", "nil", "\n", "}" ]

[ "Exec", "performs", "exec", "operation", "." ]

[ "func", "EscapeString", "(", "ch", "*", "Changeset", ",", "fields", "...", "string", ")", "{", "for", "_", ",", "field", ":=", "range", "fields", "{", "ApplyString", "(", "ch", ",", "field", ",", "html", ".", "EscapeString", ")", "\n", "}", "\n", "}" ]

[ "EscapeString", "escapes", "special", "characters", "like", "<", "to", "become", "&lt", ";", ".", "this", "is", "helper", "for", "html", ".", "EscapeString" ]

[ "func", "Preload", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "// preparte tests data", "user", ":=", "User", "{", "Name", ":", "\"", "\"", ",", "Gender", ":", "\"", "\"", ",", "Age", ":", "10", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "user", ")", "\n\n", "userAddresses", ":=", "[", "]", "Address", "{", "{", "Address", ":", "\"", "\"", ",", "UserID", ":", "&", "user", ".", "ID", "}", ",", "{", "Address", ":", "\"", "\"", ",", "UserID", ":", "&", "user", ".", "ID", "}", ",", "{", "Address", ":", "\"", "\"", ",", "UserID", ":", "&", "user", ".", "ID", "}", ",", "}", "\n\n", "repo", ".", "From", "(", "addresses", ")", ".", "MustSave", "(", "&", "userAddresses", "[", "0", "]", ")", "\n", "repo", ".", "From", "(", "addresses", ")", ".", "MustSave", "(", "&", "userAddresses", "[", "1", "]", ")", "\n", "repo", ".", "From", "(", "addresses", ")", ".", "MustSave", "(", "&", "userAddresses", "[", "2", "]", ")", "\n\n", "assert", ".", "Nil", "(", "t", ",", "user", ".", "Addresses", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Preload", "(", "&", "user", ",", "\"", "\"", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "userAddresses", ",", "user", ".", "Addresses", ")", "\n", "}", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "repo", ".", "From", "(", "addresses", ")", ".", "Where", "(", "c", ".", "Eq", "(", "address", ",", "\"", "\"", ")", ")", ".", "Preload", "(", "&", "user", ",", "\"", "\"", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "1", ",", "len", "(", "user", ".", "Addresses", ")", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "userAddresses", "[", "0", "]", ",", "user", ".", "Addresses", "[", "0", "]", ")", "\n", "}", ")", "\n\n", "user", ".", "Addresses", "=", "nil", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "repo", ".", "From", "(", "users", ")", ".", "Preload", "(", "&", "userAddresses", "[", "0", "]", ",", "\"", "\"", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "user", ",", "userAddresses", "[", "0", "]", ".", "User", ")", "\n", "}", ")", "\n\n", "t", ".", "Run", "(", "\"", "\"", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "repo", ".", "From", "(", "users", ")", ".", "Preload", "(", "&", "userAddresses", ",", "\"", "\"", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "user", ",", "userAddresses", "[", "0", "]", ".", "User", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "user", ",", "userAddresses", "[", "1", "]", ".", "User", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "user", ",", "userAddresses", "[", "2", "]", ".", "User", ")", "\n", "}", ")", "\n", "}" ]

[ "Preload", "tests", "query", "specifications", "for", "preloading", "." ]

[ "func", "DefaultLogger", "(", "query", "string", ",", "duration", "time", ".", "Duration", ",", "err", "error", ")", "{", "if", "err", "!=", "nil", "{", "log", ".", "Print", "(", "\"", "\"", ",", "duration", ",", "\"", "\"", ",", "err", ",", "\"", "\"", ",", "query", ")", "\n", "}", "else", "{", "log", ".", "Print", "(", "\"", "\"", ",", "duration", ",", "\"", "\"", ",", "query", ")", "\n", "}", "\n", "}" ]

[ "DefaultLogger", "log", "query", "suing", "standard", "log", "library", "." ]

[ "func", "Log", "(", "logger", "[", "]", "Logger", ",", "statement", "string", ",", "duration", "time", ".", "Duration", ",", "err", "error", ")", "{", "for", "_", ",", "l", ":=", "range", "logger", "{", "l", "(", "statement", ",", "duration", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "Log", "using", "multiple", "logger", ".", "This", "function", "intended", "to", "be", "used", "within", "adapter", "." ]

[ "func", "(", "json", "*", "JSON", ")", "Get", "(", "name", "string", ")", "interface", "{", "}", "{", "return", "json", ".", "Result", ".", "Get", "(", "name", ")", ".", "Value", "(", ")", "\n", "}" ]

[ "Get", "returns", "value", "as", "interface", ".", "returns", "nil", "if", "value", "doens", "t", "exists", "." ]

[ "func", "Change", "(", "schema", "interface", "{", "}", ",", "changes", "...", "map", "[", "string", "]", "interface", "{", "}", ")", "*", "Changeset", "{", "ch", ":=", "&", "Changeset", "{", "}", "\n", "ch", ".", "changes", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "ch", ".", "values", ",", "ch", ".", "types", ",", "_", "=", "mapSchema", "(", "schema", ")", "\n\n", "if", "len", "(", "changes", ")", ">", "0", "{", "ch", ".", "changes", "=", "changes", "[", "0", "]", "\n", "}", "else", "{", "ch", ".", "changes", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n\n", "return", "ch", "\n", "}" ]

[ "Change", "make", "a", "new", "changeset", "without", "changes", "and", "build", "from", "given", "schema", ".", "Returns", "new", "Changeset", "." ]

[ "func", "ExtractString", "(", "s", ",", "left", ",", "right", "string", ")", "string", "{", "return", "strings", ".", "Split", "(", "strings", ".", "Split", "(", "s", ",", "left", ")", "[", "1", "]", ",", "right", ")", "[", "0", "]", "\n", "}" ]

[ "ExtractString", "between", "two", "string", "." ]

[ "func", "Delete", "(", "t", "*", "testing", ".", "T", ",", "repo", "grimoire", ".", "Repo", ")", "{", "record", ":=", "User", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "record", ")", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "User", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", ")", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "User", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "100", "}", ")", "\n", "repo", ".", "From", "(", "users", ")", ".", "MustSave", "(", "&", "User", "{", "Name", ":", "\"", "\"", ",", "Age", ":", "110", "}", ")", "\n\n", "tests", ":=", "[", "]", "grimoire", ".", "Query", "{", "repo", ".", "From", "(", "users", ")", ".", "Find", "(", "record", ".", "ID", ")", ",", "repo", ".", "From", "(", "users", ")", ".", "Where", "(", "c", ".", "Eq", "(", "name", ",", "\"", "\"", ")", ")", ",", "repo", ".", "From", "(", "users", ")", ".", "Where", "(", "c", ".", "Eq", "(", "name", ",", "\"", "\"", ")", ",", "c", ".", "Gt", "(", "age", ",", "100", ")", ")", ",", "}", "\n\n", "for", "_", ",", "query", ":=", "range", "tests", "{", "statement", ",", "_", ":=", "builder", ".", "Delete", "(", "query", ".", "Collection", ",", "query", ".", "Condition", ")", "\n", "t", ".", "Run", "(", "\"", "\"", "+", "statement", ",", "func", "(", "t", "*", "testing", ".", "T", ")", "{", "var", "result", "[", "]", "User", "\n", "assert", ".", "Nil", "(", "t", ",", "query", ".", "All", "(", "&", "result", ")", ")", "\n", "assert", ".", "NotEqual", "(", "t", ",", "0", ",", "len", "(", "result", ")", ")", "\n\n", "assert", ".", "Nil", "(", "t", ",", "query", ".", "Delete", "(", ")", ")", "\n\n", "assert", ".", "Nil", "(", "t", ",", "query", ".", "All", "(", "&", "result", ")", ")", "\n", "assert", ".", "Equal", "(", "t", ",", "0", ",", "len", "(", "result", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}" ]

[ "Delete", "tests", "delete", "specifications", "." ]

[ "func", "ValidatePattern", "(", "ch", "*", "Changeset", ",", "field", "string", ",", "pattern", "string", ",", "opts", "...", "Option", ")", "{", "val", ",", "exist", ":=", "ch", ".", "changes", "[", "field", "]", "\n", "if", "!", "exist", "{", "return", "\n", "}", "\n\n", "options", ":=", "Options", "{", "message", ":", "ValidatePatternErrorMessage", ",", "}", "\n", "options", ".", "apply", "(", "opts", ")", "\n\n", "if", "str", ",", "ok", ":=", "val", ".", "(", "string", ")", ";", "ok", "{", "match", ",", "_", ":=", "regexp", ".", "MatchString", "(", "pattern", ",", "str", ")", "\n", "if", "!", "match", "{", "msg", ":=", "strings", ".", "Replace", "(", "options", ".", "message", ",", "\"", "\"", ",", "field", ",", "1", ")", "\n", "AddError", "(", "ch", ",", "field", ",", "msg", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "}" ]

[ "ValidatePattern", "validates", "the", "value", "of", "given", "field", "to", "match", "given", "pattern", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Find", "(", "q", "grimoire", ".", "Query", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "qs", ",", "args", ":=", "builder", ".", "query", "(", "q", ")", "\n", "return", "builder", ".", "fields", "(", "q", ".", "AsDistinct", ",", "q", ".", "Fields", "...", ")", "+", "qs", ",", "args", "\n", "}" ]

[ "Find", "generates", "query", "for", "select", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Aggregate", "(", "q", "grimoire", ".", "Query", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "qs", ",", "args", ":=", "builder", ".", "query", "(", "q", ")", "\n", "field", ":=", "q", ".", "AggregateMode", "+", "\"", "\"", "+", "q", ".", "AggregateField", "+", "\"", "\"", "+", "q", ".", "AggregateMode", "\n\n", "return", "builder", ".", "fields", "(", "false", ",", "append", "(", "q", ".", "GroupFields", ",", "field", ")", "...", ")", "+", "qs", ",", "args", "\n", "}" ]

[ "Aggregate", "generates", "query", "for", "aggregation", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Insert", "(", "collection", "string", ",", "changes", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "length", ":=", "len", "(", "changes", ")", "\n\n", "var", "buffer", "bytes", ".", "Buffer", "\n", "var", "args", "=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "length", ")", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "collection", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n\n", "if", "len", "(", "changes", ")", "==", "0", "&&", "builder", ".", "config", ".", "InsertDefaultValues", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "else", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "curr", ":=", "0", "\n", "for", "field", ",", "value", ":=", "range", "changes", "{", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "field", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n\n", "args", "=", "append", "(", "args", ",", "value", ")", "\n\n", "if", "curr", "<", "length", "-", "1", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "curr", "++", "\n", "}", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "length", ";", "i", "++", "{", "buffer", ".", "WriteString", "(", "builder", ".", "ph", "(", ")", ")", "\n\n", "if", "i", "<", "length", "-", "1", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "builder", ".", "returnField", "!=", "\"", "\"", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "returnField", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "return", "buffer", ".", "String", "(", ")", ",", "args", "\n", "}" ]

[ "Insert", "generates", "query", "for", "insert", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "InsertAll", "(", "collection", "string", ",", "fields", "[", "]", "string", ",", "allchanges", "[", "]", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "var", "buffer", "bytes", ".", "Buffer", "\n", "var", "args", "=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "len", "(", "fields", ")", "*", "len", "(", "allchanges", ")", ")", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "collection", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n\n", "sep", ":=", "builder", ".", "config", ".", "EscapeChar", "+", "\"", "\"", "+", "builder", ".", "config", ".", "EscapeChar", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "strings", ".", "Join", "(", "fields", ",", "sep", ")", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "for", "i", ",", "changes", ":=", "range", "allchanges", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "for", "j", ",", "field", ":=", "range", "fields", "{", "if", "val", ",", "exist", ":=", "changes", "[", "field", "]", ";", "exist", "{", "buffer", ".", "WriteString", "(", "builder", ".", "ph", "(", ")", ")", "\n", "args", "=", "append", "(", "args", ",", "val", ")", "\n", "}", "else", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "j", "<", "len", "(", "fields", ")", "-", "1", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "i", "<", "len", "(", "allchanges", ")", "-", "1", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "else", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "if", "builder", ".", "returnField", "!=", "\"", "\"", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "returnField", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "return", "buffer", ".", "String", "(", ")", ",", "args", "\n", "}" ]

[ "InsertAll", "generates", "query", "for", "multiple", "insert", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Update", "(", "collection", "string", ",", "changes", "map", "[", "string", "]", "interface", "{", "}", ",", "cond", "c", ".", "Condition", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "length", ":=", "len", "(", "changes", ")", "\n\n", "var", "buffer", "bytes", ".", "Buffer", "\n", "var", "args", "=", "make", "(", "[", "]", "interface", "{", "}", ",", "0", ",", "length", ")", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "collection", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "curr", ":=", "0", "\n", "for", "field", ",", "value", ":=", "range", "changes", "{", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "field", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "ph", "(", ")", ")", "\n", "args", "=", "append", "(", "args", ",", "value", ")", "\n\n", "if", "curr", "<", "length", "-", "1", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "}", "\n\n", "curr", "++", "\n", "}", "\n\n", "if", "s", ",", "arg", ":=", "builder", ".", "where", "(", "cond", ")", ";", "s", "!=", "\"", "\"", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "s", ")", "\n", "args", "=", "append", "(", "args", ",", "arg", "...", ")", "\n", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "return", "buffer", ".", "String", "(", ")", ",", "args", "\n", "}" ]

[ "Update", "generates", "query", "for", "update", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Delete", "(", "collection", "string", ",", "cond", "c", ".", "Condition", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "var", "buffer", "bytes", ".", "Buffer", "\n", "var", "args", "[", "]", "interface", "{", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n", "buffer", ".", "WriteString", "(", "collection", ")", "\n", "buffer", ".", "WriteString", "(", "builder", ".", "config", ".", "EscapeChar", ")", "\n\n", "if", "s", ",", "arg", ":=", "builder", ".", "where", "(", "cond", ")", ";", "s", "!=", "\"", "\"", "{", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "buffer", ".", "WriteString", "(", "s", ")", "\n", "args", "=", "append", "(", "args", ",", "arg", "...", ")", "\n", "}", "\n\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n\n", "return", "buffer", ".", "String", "(", ")", ",", "args", "\n", "}" ]

[ "Delete", "generates", "query", "for", "delete", "." ]

[ "func", "(", "builder", "*", "Builder", ")", "Returning", "(", "field", "string", ")", "*", "Builder", "{", "builder", ".", "returnField", "=", "field", "\n", "return", "builder", "\n", "}" ]

[ "Returning", "append", "returning", "to", "insert", "query", "." ]

[ "func", "haveAVX", "(", ")", "bool", "{", "_", ",", "_", ",", "c", ",", "_", ":=", "cpuid", "(", "1", ")", "\n\n", "// Check XGETBV, OXSAVE and AVX bits", "if", "c", "&", "(", "1", "<<", "26", ")", "!=", "0", "&&", "c", "&", "(", "1", "<<", "27", ")", "!=", "0", "&&", "c", "&", "(", "1", "<<", "28", ")", "!=", "0", "{", "// Check for OS support", "eax", ",", "_", ":=", "xgetbv", "(", "0", ")", "\n", "return", "(", "eax", "&", "0x6", ")", "==", "0x6", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "haveAVX", "returns", "true", "when", "there", "is", "AVX", "support" ]

[ "func", "haveAVX2", "(", ")", "bool", "{", "mfi", ",", "_", ",", "_", ",", "_", ":=", "cpuid", "(", "0", ")", "\n\n", "// Check AVX2, AVX2 requires OS support, but BMI1/2 don't.", "if", "mfi", ">=", "7", "&&", "haveAVX", "(", ")", "{", "_", ",", "ebx", ",", "_", ",", "_", ":=", "cpuidex", "(", "7", ",", "0", ")", "\n", "return", "(", "ebx", "&", "0x00000020", ")", "!=", "0", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "haveAVX2", "returns", "true", "when", "there", "is", "AVX2", "support" ]

[ "func", "New", "(", "c", "*", "Config", ")", "(", "hash", ".", "Hash", ",", "error", ")", "{", "if", "c", "==", "nil", "{", "c", "=", "defaultConfig", "\n", "}", "else", "{", "if", "c", ".", "Size", "==", "0", "{", "// Set default size if it's zero.", "c", ".", "Size", "=", "Size", "\n", "}", "\n", "if", "err", ":=", "verifyConfig", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n", "d", ":=", "new", "(", "digest", ")", "\n", "d", ".", "initialize", "(", "c", ")", "\n", "return", "d", ",", "nil", "\n", "}" ]

[ "New", "returns", "a", "new", "hash", ".", "Hash", "configured", "with", "the", "given", "Config", ".", "Config", "can", "be", "nil", "in", "which", "case", "the", "default", "one", "is", "used", "calculating", "64", "-", "byte", "digest", ".", "Returns", "non", "-", "nil", "error", "if", "Config", "contains", "invalid", "parameters", "." ]

[ "func", "(", "d", "*", "digest", ")", "initialize", "(", "c", "*", "Config", ")", "{", "// Create parameter block.", "var", "p", "[", "BlockSize", "]", "byte", "\n", "p", "[", "0", "]", "=", "c", ".", "Size", "\n", "p", "[", "1", "]", "=", "uint8", "(", "len", "(", "c", ".", "Key", ")", ")", "\n", "if", "c", ".", "Salt", "!=", "nil", "{", "copy", "(", "p", "[", "32", ":", "]", ",", "c", ".", "Salt", ")", "\n", "}", "\n", "if", "c", ".", "Person", "!=", "nil", "{", "copy", "(", "p", "[", "48", ":", "]", ",", "c", ".", "Person", ")", "\n", "}", "\n", "if", "c", ".", "Tree", "!=", "nil", "{", "p", "[", "2", "]", "=", "c", ".", "Tree", ".", "Fanout", "\n", "p", "[", "3", "]", "=", "c", ".", "Tree", ".", "MaxDepth", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "p", "[", "4", ":", "]", ",", "c", ".", "Tree", ".", "LeafSize", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "p", "[", "8", ":", "]", ",", "c", ".", "Tree", ".", "NodeOffset", ")", "\n", "p", "[", "16", "]", "=", "c", ".", "Tree", ".", "NodeDepth", "\n", "p", "[", "17", "]", "=", "c", ".", "Tree", ".", "InnerHashSize", "\n", "}", "else", "{", "p", "[", "2", "]", "=", "1", "\n", "p", "[", "3", "]", "=", "1", "\n", "}", "\n\n", "// Initialize.", "d", ".", "size", "=", "c", ".", "Size", "\n", "for", "i", ":=", "0", ";", "i", "<", "8", ";", "i", "++", "{", "d", ".", "h", "[", "i", "]", "=", "iv", "[", "i", "]", "^", "binary", ".", "LittleEndian", ".", "Uint64", "(", "p", "[", "i", "*", "8", ":", "]", ")", "\n", "}", "\n", "if", "c", ".", "Tree", "!=", "nil", "&&", "c", ".", "Tree", ".", "IsLastNode", "{", "d", ".", "isLastNode", "=", "true", "\n", "}", "\n\n", "// Process key.", "if", "c", ".", "Key", "!=", "nil", "{", "copy", "(", "d", ".", "paddedKey", "[", ":", "]", ",", "c", ".", "Key", ")", "\n", "d", ".", "Write", "(", "d", ".", "paddedKey", "[", ":", "]", ")", "\n", "d", ".", "isKeyed", "=", "true", "\n", "}", "\n", "// Save a copy of initialized state.", "copy", "(", "d", ".", "ih", "[", ":", "]", ",", "d", ".", "h", "[", ":", "]", ")", "\n", "}" ]

[ "initialize", "initializes", "digest", "with", "the", "given", "config", "which", "must", "be", "non", "-", "nil", "and", "verified", "." ]

[ "func", "New512", "(", ")", "hash", ".", "Hash", "{", "d", ":=", "new", "(", "digest", ")", "\n", "d", ".", "initialize", "(", "defaultConfig", ")", "\n", "return", "d", "\n", "}" ]

[ "New512", "returns", "a", "new", "hash", ".", "Hash", "computing", "the", "BLAKE2b", "64", "-", "byte", "checksum", "." ]

[ "func", "New256", "(", ")", "hash", ".", "Hash", "{", "d", ":=", "new", "(", "digest", ")", "\n", "d", ".", "initialize", "(", "config256", ")", "\n", "return", "d", "\n", "}" ]

[ "New256", "returns", "a", "new", "hash", ".", "Hash", "computing", "the", "BLAKE2b", "32", "-", "byte", "checksum", "." ]

[ "func", "(", "d", "*", "digest", ")", "Reset", "(", ")", "{", "copy", "(", "d", ".", "h", "[", ":", "]", ",", "d", ".", "ih", "[", ":", "]", ")", "\n", "d", ".", "t", "[", "0", "]", "=", "0", "\n", "d", ".", "t", "[", "1", "]", "=", "0", "\n", "d", ".", "f", "[", "0", "]", "=", "0", "\n", "d", ".", "f", "[", "1", "]", "=", "0", "\n", "d", ".", "nx", "=", "0", "\n", "if", "d", ".", "isKeyed", "{", "d", ".", "Write", "(", "d", ".", "paddedKey", "[", ":", "]", ")", "\n", "}", "\n", "}" ]

[ "Reset", "resets", "the", "state", "of", "digest", "to", "the", "initial", "state", "after", "configuration", "and", "keying", "." ]

[ "func", "Sum512", "(", "data", "[", "]", "byte", ")", "[", "64", "]", "byte", "{", "var", "d", "digest", "\n", "d", ".", "initialize", "(", "defaultConfig", ")", "\n", "d", ".", "Write", "(", "data", ")", "\n", "return", "d", ".", "checkSum", "(", ")", "\n", "}" ]

[ "Sum512", "returns", "a", "64", "-", "byte", "BLAKE2b", "hash", "of", "data", "." ]

[ "func", "Sum256", "(", "data", "[", "]", "byte", ")", "(", "out", "[", "32", "]", "byte", ")", "{", "var", "d", "digest", "\n", "d", ".", "initialize", "(", "config256", ")", "\n", "d", ".", "Write", "(", "data", ")", "\n", "sum", ":=", "d", ".", "checkSum", "(", ")", "\n", "copy", "(", "out", "[", ":", "]", ",", "sum", "[", ":", "32", "]", ")", "\n", "return", "\n", "}" ]

[ "Sum256", "returns", "a", "32", "-", "byte", "BLAKE2b", "hash", "of", "data", "." ]

[ "func", "MakeTable", "(", "params", "Params", ")", "*", "Table", "{", "table", ":=", "new", "(", "Table", ")", "\n", "table", ".", "params", "=", "params", "\n", "for", "n", ":=", "0", ";", "n", "<", "256", ";", "n", "++", "{", "crc", ":=", "uint16", "(", "n", ")", "<<", "8", "\n", "for", "i", ":=", "0", ";", "i", "<", "8", ";", "i", "++", "{", "bit", ":=", "(", "crc", "&", "0x8000", ")", "!=", "0", "\n", "crc", "<<=", "1", "\n", "if", "bit", "{", "crc", "^=", "params", ".", "Poly", "\n", "}", "\n", "}", "\n", "table", ".", "data", "[", "n", "]", "=", "crc", "\n", "}", "\n", "return", "table", "\n", "}" ]

[ "MakeTable", "returns", "the", "Table", "constructed", "from", "the", "specified", "algorithm", "." ]

[ "func", "Update", "(", "crc", "uint16", ",", "data", "[", "]", "byte", ",", "table", "*", "Table", ")", "uint16", "{", "for", "_", ",", "d", ":=", "range", "data", "{", "if", "table", ".", "params", ".", "RefIn", "{", "d", "=", "utils", ".", "ReverseByte", "(", "d", ")", "\n", "}", "\n", "crc", "=", "crc", "<<", "8", "^", "table", ".", "data", "[", "byte", "(", "crc", ">>", "8", ")", "^", "d", "]", "\n", "}", "\n", "return", "crc", "\n", "}" ]

[ "Update", "returns", "the", "result", "of", "adding", "the", "bytes", "in", "data", "to", "the", "crc", "." ]

[ "func", "Checksum", "(", "data", "[", "]", "byte", ",", "table", "*", "Table", ")", "uint16", "{", "crc", ":=", "Init", "(", "table", ")", "\n", "crc", "=", "Update", "(", "crc", ",", "data", ",", "table", ")", "\n", "return", "Complete", "(", "crc", ",", "table", ")", "\n", "}" ]

[ "Checksum", "returns", "CRC", "checksum", "of", "data", "usign", "scpecified", "algorithm", "represented", "by", "the", "Table", "." ]

[ "func", "Sum", "(", "m", "[", "]", "byte", ",", "key", "nacl", ".", "Key", ")", "*", "[", "Size", "]", "byte", "{", "mac", ":=", "hmac", ".", "New", "(", "sha512", ".", "New", ",", "(", "*", "key", ")", "[", ":", "]", ")", "\n", "mac", ".", "Write", "(", "m", ")", "\n", "sum", ":=", "mac", ".", "Sum", "(", "nil", ")", "// first 256 bits of 512 bit sum", "\n", "out", ":=", "new", "(", "[", "32", "]", "byte", ")", "\n", "copy", "(", "out", "[", ":", "]", ",", "sum", "[", ":", "32", "]", ")", "\n", "return", "out", "\n", "}" ]

[ "Sum", "generates", "an", "authenticator", "for", "m", "using", "a", "secret", "key", "and", "returns", "the", "32", "-", "byte", "digest", "." ]

[ "func", "Verify", "(", "digest", "*", "[", "Size", "]", "byte", ",", "m", "[", "]", "byte", ",", "key", "nacl", ".", "Key", ")", "bool", "{", "mac", ":=", "hmac", ".", "New", "(", "sha512", ".", "New", ",", "(", "*", "key", ")", "[", ":", "]", ")", "\n", "mac", ".", "Write", "(", "m", ")", "\n", "expectedMAC", ":=", "mac", ".", "Sum", "(", "nil", ")", "// first 256 bits of 512 bit sum", "\n", "return", "hmac", ".", "Equal", "(", "(", "*", "digest", ")", "[", ":", "]", ",", "expectedMAC", "[", ":", "Size", "]", ")", "\n", "}" ]

[ "Verify", "checks", "that", "digest", "is", "a", "correct", "authenticator", "of", "a", "message", "m", "under", "the", "secret", "key", "key", ".", "If", "not", "the", "function", "returns", "false", ".", "Verify", "does", "not", "leak", "timing", "information", "." ]

[ "func", "MustRead", "(", "in", "[", "]", "byte", ")", "{", "n", ",", "err", ":=", "Read", "(", "in", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "if", "n", "!=", "len", "(", "in", ")", "{", "panic", "(", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "n", ")", "+", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "MustRead", "fills", "in", "entirely", "with", "random", "data", "or", "panics", "." ]

[ "func", "Load", "(", "hexkey", "string", ")", "(", "Key", ",", "error", ")", "{", "if", "len", "(", "hexkey", ")", "!=", "64", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "hexkey", ")", ")", "\n", "}", "\n", "keyBytes", ",", "err", ":=", "hex", ".", "DecodeString", "(", "hexkey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "keyBytes", ")", "!=", "KeySize", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "keyBytes", ")", ")", "\n", "}", "\n", "key", ":=", "new", "(", "[", "KeySize", "]", "byte", ")", "\n", "copy", "(", "key", "[", ":", "]", ",", "keyBytes", ")", "\n", "return", "key", ",", "nil", "\n", "}" ]

[ "Load", "decodes", "a", "64", "-", "byte", "hex", "string", "into", "a", "Key", ".", "A", "hex", "key", "is", "suitable", "for", "representation", "in", "a", "configuration", "file", ".", "You", "can", "generate", "one", "by", "running", "openssl", "rand", "-", "hex", "32", "." ]

[ "func", "NewKey", "(", ")", "Key", "{", "key", ":=", "new", "(", "[", "KeySize", "]", "byte", ")", "\n", "randombytes", ".", "MustRead", "(", "key", "[", ":", "]", ")", "\n", "return", "key", "\n", "}" ]

[ "NewKey", "returns", "a", "new", "Key", "with", "cryptographically", "random", "data", ".", "NewKey", "panics", "if", "we", "could", "not", "read", "the", "correct", "amount", "of", "random", "data", "into", "key", "." ]

[ "func", "NewNonce", "(", ")", "Nonce", "{", "nonce", ":=", "new", "(", "[", "NonceSize", "]", "byte", ")", "\n", "randombytes", ".", "MustRead", "(", "nonce", "[", ":", "]", ")", "\n", "return", "nonce", "\n", "}" ]

[ "NewNonce", "returns", "a", "new", "Nonce", "with", "cryptographically", "random", "data", ".", "It", "panics", "if", "we", "could", "not", "read", "the", "correct", "amount", "of", "random", "data", "into", "nonce", "." ]

[ "func", "Verify16", "(", "a", ",", "b", "*", "[", "16", "]", "byte", ")", "bool", "{", "if", "a", "==", "nil", "||", "b", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "subtle", ".", "ConstantTimeCompare", "(", "a", "[", ":", "]", ",", "b", "[", ":", "]", ")", "==", "1", "\n", "}" ]

[ "Verify16", "returns", "true", "if", "and", "only", "if", "a", "and", "b", "have", "equal", "contents", "without", "leaking", "timing", "information", "." ]

[ "func", "Verify32", "(", "a", ",", "b", "*", "[", "KeySize", "]", "byte", ")", "bool", "{", "if", "a", "==", "nil", "||", "b", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "subtle", ".", "ConstantTimeCompare", "(", "a", "[", ":", "]", ",", "b", "[", ":", "]", ")", "==", "1", "\n", "}" ]

[ "Verify32", "returns", "true", "if", "and", "only", "if", "a", "and", "b", "have", "equal", "contents", "without", "leaking", "timing", "information", "." ]

[ "func", "Hash", "(", "m", "[", "]", "byte", ")", "*", "[", "HashSize", "]", "byte", "{", "out", ":=", "sha512", ".", "Sum512", "(", "m", ")", "\n", "return", "&", "out", "\n", "}" ]

[ "Hash", "hashes", "a", "message", "m", ".", "The", "crypto_hash", "function", "is", "designed", "to", "be", "usable", "as", "a", "strong", "component", "of", "DSA", "RSA", "-", "PSS", "key", "derivation", "hash", "-", "based", "message", "-", "authentication", "codes", "hash", "-", "based", "ciphers", "and", "various", "other", "common", "applications", ".", "Strong", "means", "that", "the", "security", "of", "these", "applications", "when", "instantiated", "with", "crypto_hash", "is", "the", "same", "as", "the", "security", "of", "the", "applications", "against", "generic", "attacks", ".", "In", "particular", "the", "crypto_hash", "function", "is", "designed", "to", "make", "finding", "collisions", "difficult", ".", "Hash", "is", "currently", "an", "implementation", "of", "SHA", "-", "512", "." ]

[ "func", "Setup", "(", "nonce", "Nonce", ",", "key", "Key", ")", "(", "Key", ",", "*", "[", "16", "]", "byte", ")", "{", "// We use XSalsa20 for encryption so first we need to generate a", "// key and nonce with HSalsa20.", "var", "hNonce", "[", "16", "]", "byte", "\n", "copy", "(", "hNonce", "[", ":", "]", ",", "nonce", "[", ":", "]", ")", "\n", "var", "subKey", "[", "32", "]", "byte", "\n", "salsa", ".", "HSalsa20", "(", "&", "subKey", ",", "&", "hNonce", ",", "key", ",", "&", "salsa", ".", "Sigma", ")", "\n\n", "// The final 8 bytes of the original nonce form the new nonce.", "var", "counter", "[", "16", "]", "byte", "\n", "copy", "(", "counter", "[", ":", "]", ",", "nonce", "[", "16", ":", "]", ")", "\n", "return", "&", "subKey", ",", "&", "counter", "\n", "}" ]

[ "Setup", "produces", "a", "sub", "-", "key", "and", "Salsa20", "counter", "given", "a", "nonce", "and", "key", "." ]

[ "func", "Verify", "(", "mac", "*", "[", "Size", "]", "byte", ",", "m", "[", "]", "byte", ",", "key", "nacl", ".", "Key", ")", "bool", "{", "return", "poly1305", ".", "Verify", "(", "mac", ",", "m", ",", "key", ")", "\n", "}" ]

[ "Verify", "returns", "true", "if", "mac", "is", "a", "valid", "authenticator", "for", "m", "with", "the", "given", "key", "without", "leaking", "timing", "information", "." ]

[ "func", "ScMinimal", "(", "scalar", "*", "[", "32", "]", "byte", ")", "bool", "{", "for", "i", ":=", "3", ";", ";", "i", "--", "{", "v", ":=", "binary", ".", "LittleEndian", ".", "Uint64", "(", "scalar", "[", "i", "*", "8", ":", "]", ")", "\n", "if", "v", ">", "order", "[", "i", "]", "{", "return", "false", "\n", "}", "else", "if", "v", "<", "order", "[", "i", "]", "{", "break", "\n", "}", "else", "if", "i", "==", "0", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "ScMinimal", "returns", "true", "if", "the", "given", "scalar", "is", "less", "than", "the", "order", "of", "the", "curve", "." ]

[ "func", "sliceForAppend", "(", "in", "[", "]", "byte", ",", "n", "int", ")", "(", "head", ",", "tail", "[", "]", "byte", ")", "{", "if", "total", ":=", "len", "(", "in", ")", "+", "n", ";", "cap", "(", "in", ")", ">=", "total", "{", "head", "=", "in", "[", ":", "total", "]", "\n", "}", "else", "{", "head", "=", "make", "(", "[", "]", "byte", ",", "total", ")", "\n", "copy", "(", "head", ",", "in", ")", "\n", "}", "\n", "tail", "=", "head", "[", "len", "(", "in", ")", ":", "]", "\n", "return", "\n", "}" ]

[ "sliceForAppend", "takes", "a", "slice", "and", "a", "requested", "number", "of", "bytes", ".", "It", "returns", "a", "slice", "with", "the", "contents", "of", "the", "given", "slice", "followed", "by", "that", "many", "bytes", "and", "a", "second", "slice", "that", "aliases", "into", "it", "and", "contains", "only", "the", "extra", "bytes", ".", "If", "the", "original", "slice", "has", "sufficient", "capacity", "then", "no", "allocation", "is", "performed", "." ]

[ "func", "EasySeal", "(", "message", "[", "]", "byte", ",", "key", "nacl", ".", "Key", ")", "[", "]", "byte", "{", "nonce", ":=", "nacl", ".", "NewNonce", "(", ")", "\n", "return", "Seal", "(", "nonce", "[", ":", "]", ",", "message", ",", "nonce", ",", "key", ")", "\n", "}" ]

[ "EasySeal", "encrypts", "message", "using", "key", ".", "A", "24", "-", "byte", "nonce", "is", "generated", "and", "prepended", "to", "the", "output", ".", "The", "key", "and", "nonce", "pair", "must", "be", "unique", "for", "each", "distinct", "message", "and", "the", "output", "will", "be", "Overhead", "+", "24", "bytes", "longer", "than", "message", "." ]

[ "func", "Seal", "(", "out", ",", "message", "[", "]", "byte", ",", "nonce", "nacl", ".", "Nonce", ",", "key", "nacl", ".", "Key", ")", "[", "]", "byte", "{", "subKey", ",", "counter", ":=", "nacl", ".", "Setup", "(", "nonce", ",", "key", ")", "\n\n", "// The Poly1305 key is generated by encrypting 32 bytes of zeros. Since", "// Salsa20 works with 64-byte blocks, we also generate 32 bytes of", "// keystream as a side effect.", "var", "firstBlock", "[", "64", "]", "byte", "\n", "salsa", ".", "XORKeyStream", "(", "firstBlock", "[", ":", "]", ",", "firstBlock", "[", ":", "]", ",", "counter", ",", "subKey", ")", "\n\n", "var", "poly1305Key", "[", "32", "]", "byte", "\n", "copy", "(", "poly1305Key", "[", ":", "]", ",", "firstBlock", "[", ":", "]", ")", "\n\n", "ret", ",", "out", ":=", "sliceForAppend", "(", "out", ",", "len", "(", "message", ")", "+", "onetimeauth", ".", "Size", ")", "\n", "if", "subtle", ".", "AnyOverlap", "(", "out", ",", "message", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// We XOR up to 32 bytes of message with the keystream generated from", "// the first block.", "firstMessageBlock", ":=", "message", "\n", "if", "len", "(", "firstMessageBlock", ")", ">", "32", "{", "firstMessageBlock", "=", "firstMessageBlock", "[", ":", "32", "]", "\n", "}", "\n\n", "tagOut", ":=", "out", "\n", "out", "=", "out", "[", "onetimeauth", ".", "Size", ":", "]", "\n", "for", "i", ",", "x", ":=", "range", "firstMessageBlock", "{", "out", "[", "i", "]", "=", "firstBlock", "[", "32", "+", "i", "]", "^", "x", "\n", "}", "\n", "message", "=", "message", "[", "len", "(", "firstMessageBlock", ")", ":", "]", "\n", "ciphertext", ":=", "out", "\n", "out", "=", "out", "[", "len", "(", "firstMessageBlock", ")", ":", "]", "\n\n", "// Now encrypt the rest.", "counter", "[", "8", "]", "=", "1", "\n", "salsa", ".", "XORKeyStream", "(", "out", ",", "message", ",", "counter", ",", "subKey", ")", "\n\n", "tag", ":=", "onetimeauth", ".", "Sum", "(", "ciphertext", ",", "&", "poly1305Key", ")", "\n", "copy", "(", "tagOut", ",", "tag", "[", ":", "]", ")", "\n\n", "return", "ret", "\n", "}" ]

[ "Seal", "appends", "an", "encrypted", "and", "authenticated", "copy", "of", "message", "to", "out", "which", "must", "not", "overlap", "message", ".", "The", "key", "and", "nonce", "pair", "must", "be", "unique", "for", "each", "distinct", "message", "and", "the", "output", "will", "be", "Overhead", "bytes", "longer", "than", "message", "." ]

[ "func", "EasyOpen", "(", "box", "[", "]", "byte", ",", "key", "nacl", ".", "Key", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "len", "(", "box", ")", "<", "24", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "decryptNonce", ":=", "new", "(", "[", "24", "]", "byte", ")", "\n", "copy", "(", "decryptNonce", "[", ":", "]", ",", "box", "[", ":", "24", "]", ")", "\n", "decrypted", ",", "ok", ":=", "Open", "(", "[", "]", "byte", "{", "}", ",", "box", "[", "24", ":", "]", ",", "decryptNonce", ",", "key", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "errInvalidInput", "\n", "}", "\n", "return", "decrypted", ",", "nil", "\n", "}" ]

[ "EasyOpen", "decrypts", "box", "using", "key", ".", "We", "assume", "a", "24", "-", "byte", "nonce", "is", "prepended", "to", "the", "encrypted", "text", "in", "box", ".", "The", "key", "and", "nonce", "pair", "must", "be", "unique", "for", "each", "distinct", "message", "." ]

[ "func", "Precompute", "(", "peersPublicKey", ",", "privateKey", "nacl", ".", "Key", ")", "nacl", ".", "Key", "{", "sharedKey", ":=", "scalarmult", ".", "Mult", "(", "privateKey", ",", "peersPublicKey", ")", "\n", "salsa", ".", "HSalsa20", "(", "sharedKey", ",", "&", "zeros", ",", "sharedKey", ",", "&", "salsa", ".", "Sigma", ")", "\n", "return", "sharedKey", "\n", "}" ]

[ "Precompute", "calculates", "the", "shared", "key", "between", "peersPublicKey", "and", "privateKey", "and", "writes", "it", "to", "sharedKey", ".", "The", "shared", "key", "can", "be", "used", "with", "OpenAfterPrecomputation", "and", "SealAfterPrecomputation", "to", "speed", "up", "processing", "when", "using", "the", "same", "pair", "of", "keys", "repeatedly", "." ]

[ "func", "EasySeal", "(", "message", "[", "]", "byte", ",", "peersPublicKey", ",", "privateKey", "nacl", ".", "Key", ")", "[", "]", "byte", "{", "nonce", ":=", "nacl", ".", "NewNonce", "(", ")", "\n", "return", "Seal", "(", "nonce", "[", ":", "]", ",", "message", ",", "nonce", ",", "peersPublicKey", ",", "privateKey", ")", "\n", "}" ]

[ "EasySeal", "encrypts", "message", "using", "peersPublicKey", "and", "privateKey", ".", "The", "output", "will", "have", "a", "randomly", "generated", "nonce", "prepended", "to", "it", ".", "The", "output", "will", "be", "Overhead", "+", "24", "bytes", "longer", "than", "the", "original", "." ]

[ "func", "Seal", "(", "out", ",", "message", "[", "]", "byte", ",", "nonce", "nacl", ".", "Nonce", ",", "peersPublicKey", ",", "privateKey", "nacl", ".", "Key", ")", "[", "]", "byte", "{", "sharedKey", ":=", "Precompute", "(", "peersPublicKey", ",", "privateKey", ")", "\n", "return", "secretbox", ".", "Seal", "(", "out", ",", "message", ",", "nonce", ",", "sharedKey", ")", "\n", "}" ]

[ "Seal", "appends", "an", "encrypted", "and", "authenticated", "copy", "of", "message", "to", "out", "which", "will", "be", "Overhead", "bytes", "longer", "than", "the", "original", "and", "must", "not", "overlap", ".", "The", "nonce", "must", "be", "unique", "for", "each", "distinct", "message", "for", "a", "given", "pair", "of", "keys", "." ]

[ "func", "SealAfterPrecomputation", "(", "out", ",", "message", "[", "]", "byte", ",", "nonce", "nacl", ".", "Nonce", ",", "sharedKey", "nacl", ".", "Key", ")", "[", "]", "byte", "{", "return", "secretbox", ".", "Seal", "(", "out", ",", "message", ",", "nonce", ",", "sharedKey", ")", "\n", "}" ]

[ "SealAfterPrecomputation", "performs", "the", "same", "actions", "as", "Seal", "but", "takes", "a", "shared", "key", "as", "generated", "by", "Precompute", "." ]

[ "func", "OpenAfterPrecomputation", "(", "out", ",", "box", "[", "]", "byte", ",", "nonce", "nacl", ".", "Nonce", ",", "sharedKey", "nacl", ".", "Key", ")", "(", "[", "]", "byte", ",", "bool", ")", "{", "return", "secretbox", ".", "Open", "(", "out", ",", "box", ",", "nonce", ",", "sharedKey", ")", "\n", "}" ]

[ "OpenAfterPrecomputation", "performs", "the", "same", "actions", "as", "Open", "but", "takes", "a", "shared", "key", "as", "generated", "by", "Precompute", "." ]

[ "func", "(", "priv", "PrivateKey", ")", "Public", "(", ")", "crypto", ".", "PublicKey", "{", "pub", ":=", "ed25519", ".", "PrivateKey", "(", "priv", ")", ".", "Public", "(", ")", ".", "(", "ed25519", ".", "PublicKey", ")", "\n", "return", "PublicKey", "(", "pub", ")", "\n", "}" ]

[ "Public", "returns", "the", "PublicKey", "corresponding", "to", "priv", "." ]

[ "func", "(", "key", "PublicKey", ")", "Verify", "(", "signature", "[", "]", "byte", ")", "bool", "{", "if", "len", "(", "signature", ")", "<", "SignatureSize", "||", "signature", "[", "63", "]", "&", "224", "!=", "0", "{", "return", "false", "\n", "}", "\n", "return", "Verify", "(", "signature", ",", "key", ")", "\n", "}" ]

[ "Verify", "uses", "key", "to", "report", "whether", "signature", "is", "a", "valid", "signature", "of", "message", ".", "The", "first", "SignatureSize", "bytes", "of", "signature", "should", "be", "the", "signature", ";", "the", "remaining", "bytes", "are", "the", "message", "to", "verify", "." ]

[ "func", "(", "r", "*", "MemoryNoTS", ")", "Delete", "(", "key", "string", ")", "error", "{", "delete", "(", "r", ".", "items", ",", "key", ")", "\n", "return", "nil", "\n", "}" ]

[ "Delete", "deletes", "a", "given", "key", "it", "doesnt", "return", "error", "if", "the", "item", "is", "not", "in", "the", "system" ]

[ "func", "(", "m", "*", "MongoCache", ")", "Get", "(", "key", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "data", ",", "err", ":=", "m", ".", "get", "(", "key", ")", "\n", "if", "err", "==", "mgo", ".", "ErrNotFound", "{", "return", "nil", ",", "ErrNotFound", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "data", ".", "Value", ",", "nil", "\n", "}" ]

[ "Get", "returns", "a", "value", "of", "a", "given", "key", "if", "it", "exists" ]

[ "func", "(", "m", "*", "MongoCache", ")", "SetEx", "(", "key", "string", ",", "duration", "time", ".", "Duration", ",", "value", "interface", "{", "}", ")", "error", "{", "return", "m", ".", "set", "(", "key", ",", "duration", ",", "value", ")", "\n", "}" ]

[ "SetEx", "will", "persist", "a", "value", "to", "the", "cache", "or", "override", "existing", "one", "with", "the", "new", "one", "with", "ttl", "duration" ]

[ "func", "(", "m", "*", "MongoCache", ")", "EnsureIndex", "(", ")", "error", "{", "query", ":=", "func", "(", "c", "*", "mgo", ".", "Collection", ")", "error", "{", "return", "c", ".", "EnsureIndexKey", "(", "indexExpireAt", ")", "\n", "}", "\n\n", "return", "m", ".", "run", "(", "m", ".", "CollectionName", ",", "query", ")", "\n", "}" ]

[ "EnsureIndex", "ensures", "the", "index", "with", "expireAt", "key" ]

[ "func", "(", "m", "*", "MongoCache", ")", "StartGC", "(", "gcInterval", "time", ".", "Duration", ")", "{", "if", "gcInterval", "<=", "0", "{", "return", "\n", "}", "\n\n", "ticker", ":=", "time", ".", "NewTicker", "(", "gcInterval", ")", "\n", "done", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n\n", "m", ".", "Lock", "(", ")", "\n", "m", ".", "gcTicker", "=", "ticker", "\n", "m", ".", "done", "=", "done", "\n", "m", ".", "Unlock", "(", ")", "\n\n", "go", "func", "(", ")", "{", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "m", ".", "Lock", "(", ")", "\n", "m", ".", "deleteExpiredKeys", "(", ")", "\n", "m", ".", "Unlock", "(", ")", "\n", "case", "<-", "done", ":", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n", "}" ]

[ "StartGC", "starts", "the", "garbage", "collector", "with", "given", "time", "interval", "The", "expired", "data", "will", "be", "checked", "&", "deleted", "with", "given", "interval", "time" ]

[ "func", "NewLRUNoTS", "(", "size", "int", ")", "Cache", "{", "if", "size", "<", "1", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "LRUNoTS", "{", "list", ":", "list", ".", "New", "(", ")", ",", "cache", ":", "NewMemoryNoTS", "(", ")", ",", "size", ":", "size", ",", "}", "\n", "}" ]

[ "NewLRUNoTS", "creates", "a", "new", "LRU", "cache", "struct", "for", "further", "cache", "operations", ".", "Size", "is", "used", "for", "limiting", "the", "upper", "bound", "of", "the", "cache" ]

[ "func", "(", "l", "*", "LRUNoTS", ")", "Delete", "(", "key", "string", ")", "error", "{", "res", ",", "err", ":=", "l", ".", "cache", ".", "Get", "(", "key", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "ErrNotFound", "{", "return", "err", "\n", "}", "\n\n", "// item already deleted", "if", "err", "==", "ErrNotFound", "{", "// surpress not found errors", "return", "nil", "\n", "}", "\n\n", "elem", ":=", "res", ".", "(", "*", "list", ".", "Element", ")", "\n\n", "return", "l", ".", "removeElem", "(", "elem", ")", "\n", "}" ]

[ "Delete", "deletes", "the", "given", "key", "-", "value", "pair", "from", "cache", "this", "function", "doesnt", "return", "an", "error", "if", "item", "is", "not", "in", "the", "cache" ]

[ "func", "(", "r", "*", "Memory", ")", "Get", "(", "key", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "r", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "Unlock", "(", ")", "\n\n", "return", "r", ".", "cache", ".", "Get", "(", "key", ")", "\n", "}" ]

[ "Get", "returns", "the", "value", "of", "a", "given", "key", "if", "it", "exists" ]

[ "func", "(", "r", "*", "Memory", ")", "Set", "(", "key", "string", ",", "value", "interface", "{", "}", ")", "error", "{", "r", ".", "Lock", "(", ")", "\n", "defer", "r", ".", "Unlock", "(", ")", "\n\n", "return", "r", ".", "cache", ".", "Set", "(", "key", ",", "value", ")", "\n", "}" ]

[ "Set", "sets", "a", "value", "to", "the", "cache", "or", "overrides", "existing", "one", "with", "the", "given", "value" ]

[ "func", "NewShardedNoTS", "(", "c", "func", "(", ")", "Cache", ")", "*", "ShardedNoTS", "{", "return", "&", "ShardedNoTS", "{", "constructor", ":", "c", ",", "cache", ":", "make", "(", "map", "[", "string", "]", "Cache", ")", ",", "itemCount", ":", "make", "(", "map", "[", "string", "]", "int", ")", ",", "}", "\n", "}" ]

[ "NewShardedNoTS", "inits", "ShardedNoTS", "struct" ]

[ "func", "(", "l", "*", "ShardedNoTS", ")", "Delete", "(", "tenantID", ",", "key", "string", ")", "error", "{", "_", ",", "ok", ":=", "l", ".", "cache", "[", "tenantID", "]", "\n", "if", "!", "ok", "{", "return", "nil", "\n", "}", "\n\n", "l", ".", "itemCount", "[", "tenantID", "]", "--", "\n\n", "if", "l", ".", "itemCount", "[", "tenantID", "]", "==", "0", "{", "return", "l", ".", "DeleteShard", "(", "tenantID", ")", "\n", "}", "\n\n", "return", "l", ".", "cache", "[", "tenantID", "]", ".", "Delete", "(", "key", ")", "\n", "}" ]

[ "Delete", "deletes", "a", "given", "key" ]

[ "func", "(", "l", "*", "ShardedNoTS", ")", "DeleteShard", "(", "tenantID", "string", ")", "error", "{", "delete", "(", "l", ".", "cache", ",", "tenantID", ")", "\n", "delete", "(", "l", ".", "itemCount", ",", "tenantID", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "DeleteShard", "deletes", "the", "keys", "inside", "from", "maps", "of", "cache", "&", "itemCount" ]