Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "PgOpfamilyByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgOpfamily", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner `", "+", "`FROM pg_catalog.pg_opfamily `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "po", ":=", "PgOpfamily", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "po", ".", "Tableoid", ",", "&", "po", ".", "Cmax", ",", "&", "po", ".", "Xmax", ",", "&", "po", ".", "Cmin", ",", "&", "po", ".", "Xmin", ",", "&", "po", ".", "Oid", ",", "&", "po", ".", "Ctid", ",", "&", "po", ".", "Opfmethod", ",", "&", "po", ".", "Opfname", ",", "&", "po", ".", "Opfnamespace", ",", "&", "po", ".", "Opfowner", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "po", ",", "nil", "\n", "}" ]

[ "PgOpfamilyByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_opfamily", "as", "a", "PgOpfamily", ".", "Generated", "from", "index", "pg_opfamily_oid_index", "." ]

[ "func", "PgPltemplateByTmplname", "(", "db", "XODB", ",", "tmplname", "pgtypes", ".", "Name", ")", "(", "*", "PgPltemplate", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl `", "+", "`FROM pg_catalog.pg_pltemplate `", "+", "`WHERE tmplname = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "tmplname", ")", "\n", "pp", ":=", "PgPltemplate", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "tmplname", ")", ".", "Scan", "(", "&", "pp", ".", "Tableoid", ",", "&", "pp", ".", "Cmax", ",", "&", "pp", ".", "Xmax", ",", "&", "pp", ".", "Cmin", ",", "&", "pp", ".", "Xmin", ",", "&", "pp", ".", "Ctid", ",", "&", "pp", ".", "Tmplname", ",", "&", "pp", ".", "Tmpltrusted", ",", "&", "pp", ".", "Tmpldbacreate", ",", "&", "pp", ".", "Tmplhandler", ",", "&", "pp", ".", "Tmplinline", ",", "&", "pp", ".", "Tmplvalidator", ",", "&", "pp", ".", "Tmpllibrary", ",", "&", "pp", ".", "Tmplacl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pp", ",", "nil", "\n", "}" ]

[ "PgPltemplateByTmplname", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_pltemplate", "as", "a", "PgPltemplate", ".", "Generated", "from", "index", "pg_pltemplate_name_index", "." ]

[ "func", "PgPolicyByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgPolicy", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck `", "+", "`FROM pg_catalog.pg_policy `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pp", ":=", "PgPolicy", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pp", ".", "Tableoid", ",", "&", "pp", ".", "Cmax", ",", "&", "pp", ".", "Xmax", ",", "&", "pp", ".", "Cmin", ",", "&", "pp", ".", "Xmin", ",", "&", "pp", ".", "Oid", ",", "&", "pp", ".", "Ctid", ",", "&", "pp", ".", "Polname", ",", "&", "pp", ".", "Polrelid", ",", "&", "pp", ".", "Polcmd", ",", "&", "pp", ".", "Polroles", ",", "&", "pp", ".", "Polqual", ",", "&", "pp", ".", "Polwithcheck", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pp", ",", "nil", "\n", "}" ]

[ "PgPolicyByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_policy", "as", "a", "PgPolicy", ".", "Generated", "from", "index", "pg_policy_oid_index", "." ]

[ "func", "PgProcByPronameProargtypesPronamespace", "(", "db", "XODB", ",", "proname", "pgtypes", ".", "Name", ",", "proargtypes", "pgtypes", ".", "Oidvector", ",", "pronamespace", "pgtypes", ".", "Oid", ")", "(", "*", "PgProc", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl `", "+", "`FROM pg_catalog.pg_proc `", "+", "`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "proname", ",", "proargtypes", ",", "pronamespace", ")", "\n", "pp", ":=", "PgProc", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "proname", ",", "proargtypes", ",", "pronamespace", ")", ".", "Scan", "(", "&", "pp", ".", "Tableoid", ",", "&", "pp", ".", "Cmax", ",", "&", "pp", ".", "Xmax", ",", "&", "pp", ".", "Cmin", ",", "&", "pp", ".", "Xmin", ",", "&", "pp", ".", "Oid", ",", "&", "pp", ".", "Ctid", ",", "&", "pp", ".", "Proname", ",", "&", "pp", ".", "Pronamespace", ",", "&", "pp", ".", "Proowner", ",", "&", "pp", ".", "Prolang", ",", "&", "pp", ".", "Procost", ",", "&", "pp", ".", "Prorows", ",", "&", "pp", ".", "Provariadic", ",", "&", "pp", ".", "Protransform", ",", "&", "pp", ".", "Proisagg", ",", "&", "pp", ".", "Proiswindow", ",", "&", "pp", ".", "Prosecdef", ",", "&", "pp", ".", "Proleakproof", ",", "&", "pp", ".", "Proisstrict", ",", "&", "pp", ".", "Proretset", ",", "&", "pp", ".", "Provolatile", ",", "&", "pp", ".", "Pronargs", ",", "&", "pp", ".", "Pronargdefaults", ",", "&", "pp", ".", "Prorettype", ",", "&", "pp", ".", "Proargtypes", ",", "&", "pp", ".", "Proallargtypes", ",", "&", "pp", ".", "Proargmodes", ",", "&", "pp", ".", "Proargnames", ",", "&", "pp", ".", "Proargdefaults", ",", "&", "pp", ".", "Protrftypes", ",", "&", "pp", ".", "Prosrc", ",", "&", "pp", ".", "Probin", ",", "&", "pp", ".", "Proconfig", ",", "&", "pp", ".", "Proacl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pp", ",", "nil", "\n", "}" ]

[ "PgProcByPronameProargtypesPronamespace", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_proc", "as", "a", "PgProc", ".", "Generated", "from", "index", "pg_proc_proname_args_nsp_index", "." ]

[ "func", "PgRangeByRngtypid", "(", "db", "XODB", ",", "rngtypid", "pgtypes", ".", "Oid", ")", "(", "*", "PgRange", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff `", "+", "`FROM pg_catalog.pg_range `", "+", "`WHERE rngtypid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "rngtypid", ")", "\n", "pr", ":=", "PgRange", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "rngtypid", ")", ".", "Scan", "(", "&", "pr", ".", "Tableoid", ",", "&", "pr", ".", "Cmax", ",", "&", "pr", ".", "Xmax", ",", "&", "pr", ".", "Cmin", ",", "&", "pr", ".", "Xmin", ",", "&", "pr", ".", "Ctid", ",", "&", "pr", ".", "Rngtypid", ",", "&", "pr", ".", "Rngsubtype", ",", "&", "pr", ".", "Rngcollation", ",", "&", "pr", ".", "Rngsubopc", ",", "&", "pr", ".", "Rngcanonical", ",", "&", "pr", ".", "Rngsubdiff", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pr", ",", "nil", "\n", "}" ]

[ "PgRangeByRngtypid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_range", "as", "a", "PgRange", ".", "Generated", "from", "index", "pg_range_rngtypid_index", "." ]

[ "func", "PgReplicationOriginByRoident", "(", "db", "XODB", ",", "roident", "pgtypes", ".", "Oid", ")", "(", "*", "PgReplicationOrigin", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `", "+", "`FROM pg_catalog.pg_replication_origin `", "+", "`WHERE roident = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "roident", ")", "\n", "pro", ":=", "PgReplicationOrigin", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "roident", ")", ".", "Scan", "(", "&", "pro", ".", "Tableoid", ",", "&", "pro", ".", "Cmax", ",", "&", "pro", ".", "Xmax", ",", "&", "pro", ".", "Cmin", ",", "&", "pro", ".", "Xmin", ",", "&", "pro", ".", "Ctid", ",", "&", "pro", ".", "Roident", ",", "&", "pro", ".", "Roname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pro", ",", "nil", "\n", "}" ]

[ "PgReplicationOriginByRoident", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_replication_origin", "as", "a", "PgReplicationOrigin", ".", "Generated", "from", "index", "pg_replication_origin_roiident_index", "." ]

[ "func", "PgReplicationOriginByRoname", "(", "db", "XODB", ",", "roname", "string", ")", "(", "*", "PgReplicationOrigin", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `", "+", "`FROM pg_catalog.pg_replication_origin `", "+", "`WHERE roname = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "roname", ")", "\n", "pro", ":=", "PgReplicationOrigin", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "roname", ")", ".", "Scan", "(", "&", "pro", ".", "Tableoid", ",", "&", "pro", ".", "Cmax", ",", "&", "pro", ".", "Xmax", ",", "&", "pro", ".", "Cmin", ",", "&", "pro", ".", "Xmin", ",", "&", "pro", ".", "Ctid", ",", "&", "pro", ".", "Roident", ",", "&", "pro", ".", "Roname", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pro", ",", "nil", "\n", "}" ]

[ "PgReplicationOriginByRoname", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_replication_origin", "as", "a", "PgReplicationOrigin", ".", "Generated", "from", "index", "pg_replication_origin_roname_index", "." ]

[ "func", "PgRewriteByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgRewrite", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action `", "+", "`FROM pg_catalog.pg_rewrite `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pr", ":=", "PgRewrite", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pr", ".", "Tableoid", ",", "&", "pr", ".", "Cmax", ",", "&", "pr", ".", "Xmax", ",", "&", "pr", ".", "Cmin", ",", "&", "pr", ".", "Xmin", ",", "&", "pr", ".", "Oid", ",", "&", "pr", ".", "Ctid", ",", "&", "pr", ".", "Rulename", ",", "&", "pr", ".", "EvClass", ",", "&", "pr", ".", "EvType", ",", "&", "pr", ".", "EvEnabled", ",", "&", "pr", ".", "IsInstead", ",", "&", "pr", ".", "EvQual", ",", "&", "pr", ".", "EvAction", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pr", ",", "nil", "\n", "}" ]

[ "PgRewriteByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_rewrite", "as", "a", "PgRewrite", ".", "Generated", "from", "index", "pg_rewrite_oid_index", "." ]

[ "func", "PgSeclabelByObjoidClassoidObjsubidProvider", "(", "db", "XODB", ",", "objoid", "pgtypes", ".", "Oid", ",", "classoid", "pgtypes", ".", "Oid", ",", "objsubid", "int", ",", "provider", "string", ")", "(", "*", "PgSeclabel", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label `", "+", "`FROM pg_catalog.pg_seclabel `", "+", "`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "objoid", ",", "classoid", ",", "objsubid", ",", "provider", ")", "\n", "ps", ":=", "PgSeclabel", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "objoid", ",", "classoid", ",", "objsubid", ",", "provider", ")", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Objoid", ",", "&", "ps", ".", "Classoid", ",", "&", "ps", ".", "Objsubid", ",", "&", "ps", ".", "Provider", ",", "&", "ps", ".", "Label", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ps", ",", "nil", "\n", "}" ]

[ "PgSeclabelByObjoidClassoidObjsubidProvider", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_seclabel", "as", "a", "PgSeclabel", ".", "Generated", "from", "index", "pg_seclabel_object_index", "." ]

[ "func", "PgShdependsByDbidClassidObjidObjsubid", "(", "db", "XODB", ",", "dbid", "pgtypes", ".", "Oid", ",", "classid", "pgtypes", ".", "Oid", ",", "objid", "pgtypes", ".", "Oid", ",", "objsubid", "int", ")", "(", "[", "]", "*", "PgShdepend", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `", "+", "`FROM pg_catalog.pg_shdepend `", "+", "`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "dbid", ",", "classid", ",", "objid", ",", "objsubid", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "dbid", ",", "classid", ",", "objid", ",", "objsubid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "PgShdepend", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ps", ":=", "PgShdepend", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Dbid", ",", "&", "ps", ".", "Classid", ",", "&", "ps", ".", "Objid", ",", "&", "ps", ".", "Objsubid", ",", "&", "ps", ".", "Refclassid", ",", "&", "ps", ".", "Refobjid", ",", "&", "ps", ".", "Deptype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ps", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgShdependsByDbidClassidObjidObjsubid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_shdepend", "as", "a", "PgShdepend", ".", "Generated", "from", "index", "pg_shdepend_depender_index", "." ]

[ "func", "PgShdependsByRefclassidRefobjid", "(", "db", "XODB", ",", "refclassid", "pgtypes", ".", "Oid", ",", "refobjid", "pgtypes", ".", "Oid", ")", "(", "[", "]", "*", "PgShdepend", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `", "+", "`FROM pg_catalog.pg_shdepend `", "+", "`WHERE refclassid = $1 AND refobjid = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "refclassid", ",", "refobjid", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "refclassid", ",", "refobjid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "PgShdepend", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ps", ":=", "PgShdepend", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Dbid", ",", "&", "ps", ".", "Classid", ",", "&", "ps", ".", "Objid", ",", "&", "ps", ".", "Objsubid", ",", "&", "ps", ".", "Refclassid", ",", "&", "ps", ".", "Refobjid", ",", "&", "ps", ".", "Deptype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ps", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgShdependsByRefclassidRefobjid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_shdepend", "as", "a", "PgShdepend", ".", "Generated", "from", "index", "pg_shdepend_reference_index", "." ]

[ "func", "PgShdescriptionByObjoidClassoid", "(", "db", "XODB", ",", "objoid", "pgtypes", ".", "Oid", ",", "classoid", "pgtypes", ".", "Oid", ")", "(", "*", "PgShdescription", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description `", "+", "`FROM pg_catalog.pg_shdescription `", "+", "`WHERE objoid = $1 AND classoid = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "objoid", ",", "classoid", ")", "\n", "ps", ":=", "PgShdescription", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "objoid", ",", "classoid", ")", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Objoid", ",", "&", "ps", ".", "Classoid", ",", "&", "ps", ".", "Description", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ps", ",", "nil", "\n", "}" ]

[ "PgShdescriptionByObjoidClassoid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_shdescription", "as", "a", "PgShdescription", ".", "Generated", "from", "index", "pg_shdescription_o_c_index", "." ]

[ "func", "PgShseclabelByObjoidClassoidProvider", "(", "db", "XODB", ",", "objoid", "pgtypes", ".", "Oid", ",", "classoid", "pgtypes", ".", "Oid", ",", "provider", "string", ")", "(", "*", "PgShseclabel", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label `", "+", "`FROM pg_catalog.pg_shseclabel `", "+", "`WHERE objoid = $1 AND classoid = $2 AND provider = $3`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "objoid", ",", "classoid", ",", "provider", ")", "\n", "ps", ":=", "PgShseclabel", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "objoid", ",", "classoid", ",", "provider", ")", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Objoid", ",", "&", "ps", ".", "Classoid", ",", "&", "ps", ".", "Provider", ",", "&", "ps", ".", "Label", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ps", ",", "nil", "\n", "}" ]

[ "PgShseclabelByObjoidClassoidProvider", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_shseclabel", "as", "a", "PgShseclabel", ".", "Generated", "from", "index", "pg_shseclabel_object_index", "." ]

[ "func", "PgStatisticByStarelidStaattnumStainherit", "(", "db", "XODB", ",", "starelid", "pgtypes", ".", "Oid", ",", "staattnum", "int16", ",", "stainherit", "bool", ")", "(", "*", "PgStatistic", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 `", "+", "`FROM pg_catalog.pg_statistic `", "+", "`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "starelid", ",", "staattnum", ",", "stainherit", ")", "\n", "ps", ":=", "PgStatistic", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "starelid", ",", "staattnum", ",", "stainherit", ")", ".", "Scan", "(", "&", "ps", ".", "Tableoid", ",", "&", "ps", ".", "Cmax", ",", "&", "ps", ".", "Xmax", ",", "&", "ps", ".", "Cmin", ",", "&", "ps", ".", "Xmin", ",", "&", "ps", ".", "Ctid", ",", "&", "ps", ".", "Starelid", ",", "&", "ps", ".", "Staattnum", ",", "&", "ps", ".", "Stainherit", ",", "&", "ps", ".", "Stanullfrac", ",", "&", "ps", ".", "Stawidth", ",", "&", "ps", ".", "Stadistinct", ",", "&", "ps", ".", "Stakind1", ",", "&", "ps", ".", "Stakind2", ",", "&", "ps", ".", "Stakind3", ",", "&", "ps", ".", "Stakind4", ",", "&", "ps", ".", "Stakind5", ",", "&", "ps", ".", "Staop1", ",", "&", "ps", ".", "Staop2", ",", "&", "ps", ".", "Staop3", ",", "&", "ps", ".", "Staop4", ",", "&", "ps", ".", "Staop5", ",", "&", "ps", ".", "Stanumbers1", ",", "&", "ps", ".", "Stanumbers2", ",", "&", "ps", ".", "Stanumbers3", ",", "&", "ps", ".", "Stanumbers4", ",", "&", "ps", ".", "Stanumbers5", ",", "&", "ps", ".", "Stavalues1", ",", "&", "ps", ".", "Stavalues2", ",", "&", "ps", ".", "Stavalues3", ",", "&", "ps", ".", "Stavalues4", ",", "&", "ps", ".", "Stavalues5", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ps", ",", "nil", "\n", "}" ]

[ "PgStatisticByStarelidStaattnumStainherit", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_statistic", "as", "a", "PgStatistic", ".", "Generated", "from", "index", "pg_statistic_relid_att_inh_index", "." ]

[ "func", "PgTablespaceByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTablespace", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions `", "+", "`FROM pg_catalog.pg_tablespace `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pt", ":=", "PgTablespace", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pt", ".", "Tableoid", ",", "&", "pt", ".", "Cmax", ",", "&", "pt", ".", "Xmax", ",", "&", "pt", ".", "Cmin", ",", "&", "pt", ".", "Xmin", ",", "&", "pt", ".", "Oid", ",", "&", "pt", ".", "Ctid", ",", "&", "pt", ".", "Spcname", ",", "&", "pt", ".", "Spcowner", ",", "&", "pt", ".", "Spcacl", ",", "&", "pt", ".", "Spcoptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pt", ",", "nil", "\n", "}" ]

[ "PgTablespaceByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_tablespace", "as", "a", "PgTablespace", ".", "Generated", "from", "index", "pg_tablespace_oid_index", "." ]

[ "func", "PgTransformByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTransform", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql `", "+", "`FROM pg_catalog.pg_transform `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pt", ":=", "PgTransform", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pt", ".", "Tableoid", ",", "&", "pt", ".", "Cmax", ",", "&", "pt", ".", "Xmax", ",", "&", "pt", ".", "Cmin", ",", "&", "pt", ".", "Xmin", ",", "&", "pt", ".", "Oid", ",", "&", "pt", ".", "Ctid", ",", "&", "pt", ".", "Trftype", ",", "&", "pt", ".", "Trflang", ",", "&", "pt", ".", "Trffromsql", ",", "&", "pt", ".", "Trftosql", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pt", ",", "nil", "\n", "}" ]

[ "PgTransformByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_transform", "as", "a", "PgTransform", ".", "Generated", "from", "index", "pg_transform_oid_index", "." ]

[ "func", "PgTriggerByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTrigger", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `", "+", "`FROM pg_catalog.pg_trigger `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pt", ":=", "PgTrigger", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pt", ".", "Tableoid", ",", "&", "pt", ".", "Cmax", ",", "&", "pt", ".", "Xmax", ",", "&", "pt", ".", "Cmin", ",", "&", "pt", ".", "Xmin", ",", "&", "pt", ".", "Oid", ",", "&", "pt", ".", "Ctid", ",", "&", "pt", ".", "Tgrelid", ",", "&", "pt", ".", "Tgname", ",", "&", "pt", ".", "Tgfoid", ",", "&", "pt", ".", "Tgtype", ",", "&", "pt", ".", "Tgenabled", ",", "&", "pt", ".", "Tgisinternal", ",", "&", "pt", ".", "Tgconstrrelid", ",", "&", "pt", ".", "Tgconstrindid", ",", "&", "pt", ".", "Tgconstraint", ",", "&", "pt", ".", "Tgdeferrable", ",", "&", "pt", ".", "Tginitdeferred", ",", "&", "pt", ".", "Tgnargs", ",", "&", "pt", ".", "Tgattr", ",", "&", "pt", ".", "Tgargs", ",", "&", "pt", ".", "Tgqual", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pt", ",", "nil", "\n", "}" ]

[ "PgTriggerByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_trigger", "as", "a", "PgTrigger", ".", "Generated", "from", "index", "pg_trigger_oid_index", "." ]

[ "func", "PgTriggersByTgconstraint", "(", "db", "XODB", ",", "tgconstraint", "pgtypes", ".", "Oid", ")", "(", "[", "]", "*", "PgTrigger", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `", "+", "`FROM pg_catalog.pg_trigger `", "+", "`WHERE tgconstraint = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "tgconstraint", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "tgconstraint", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "PgTrigger", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "pt", ":=", "PgTrigger", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "pt", ".", "Tableoid", ",", "&", "pt", ".", "Cmax", ",", "&", "pt", ".", "Xmax", ",", "&", "pt", ".", "Cmin", ",", "&", "pt", ".", "Xmin", ",", "&", "pt", ".", "Oid", ",", "&", "pt", ".", "Ctid", ",", "&", "pt", ".", "Tgrelid", ",", "&", "pt", ".", "Tgname", ",", "&", "pt", ".", "Tgfoid", ",", "&", "pt", ".", "Tgtype", ",", "&", "pt", ".", "Tgenabled", ",", "&", "pt", ".", "Tgisinternal", ",", "&", "pt", ".", "Tgconstrrelid", ",", "&", "pt", ".", "Tgconstrindid", ",", "&", "pt", ".", "Tgconstraint", ",", "&", "pt", ".", "Tgdeferrable", ",", "&", "pt", ".", "Tginitdeferred", ",", "&", "pt", ".", "Tgnargs", ",", "&", "pt", ".", "Tgattr", ",", "&", "pt", ".", "Tgargs", ",", "&", "pt", ".", "Tgqual", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "pt", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgTriggersByTgconstraint", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_trigger", "as", "a", "PgTrigger", ".", "Generated", "from", "index", "pg_trigger_tgconstraint_index", "." ]

[ "func", "PgTsConfigByCfgnameCfgnamespace", "(", "db", "XODB", ",", "cfgname", "pgtypes", ".", "Name", ",", "cfgnamespace", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsConfig", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `", "+", "`FROM pg_catalog.pg_ts_config `", "+", "`WHERE cfgname = $1 AND cfgnamespace = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "cfgname", ",", "cfgnamespace", ")", "\n", "ptc", ":=", "PgTsConfig", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "cfgname", ",", "cfgnamespace", ")", ".", "Scan", "(", "&", "ptc", ".", "Tableoid", ",", "&", "ptc", ".", "Cmax", ",", "&", "ptc", ".", "Xmax", ",", "&", "ptc", ".", "Cmin", ",", "&", "ptc", ".", "Xmin", ",", "&", "ptc", ".", "Oid", ",", "&", "ptc", ".", "Ctid", ",", "&", "ptc", ".", "Cfgname", ",", "&", "ptc", ".", "Cfgnamespace", ",", "&", "ptc", ".", "Cfgowner", ",", "&", "ptc", ".", "Cfgparser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptc", ",", "nil", "\n", "}" ]

[ "PgTsConfigByCfgnameCfgnamespace", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_config", "as", "a", "PgTsConfig", ".", "Generated", "from", "index", "pg_ts_config_cfgname_index", "." ]

[ "func", "PgTsConfigByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsConfig", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `", "+", "`FROM pg_catalog.pg_ts_config `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "ptc", ":=", "PgTsConfig", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "ptc", ".", "Tableoid", ",", "&", "ptc", ".", "Cmax", ",", "&", "ptc", ".", "Xmax", ",", "&", "ptc", ".", "Cmin", ",", "&", "ptc", ".", "Xmin", ",", "&", "ptc", ".", "Oid", ",", "&", "ptc", ".", "Ctid", ",", "&", "ptc", ".", "Cfgname", ",", "&", "ptc", ".", "Cfgnamespace", ",", "&", "ptc", ".", "Cfgowner", ",", "&", "ptc", ".", "Cfgparser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptc", ",", "nil", "\n", "}" ]

[ "PgTsConfigByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_config", "as", "a", "PgTsConfig", ".", "Generated", "from", "index", "pg_ts_config_oid_index", "." ]

[ "func", "PgTsConfigMapByMapcfgMaptokentypeMapseqno", "(", "db", "XODB", ",", "mapcfg", "pgtypes", ".", "Oid", ",", "maptokentype", "int", ",", "mapseqno", "int", ")", "(", "*", "PgTsConfigMap", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict `", "+", "`FROM pg_catalog.pg_ts_config_map `", "+", "`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "mapcfg", ",", "maptokentype", ",", "mapseqno", ")", "\n", "ptcm", ":=", "PgTsConfigMap", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "mapcfg", ",", "maptokentype", ",", "mapseqno", ")", ".", "Scan", "(", "&", "ptcm", ".", "Tableoid", ",", "&", "ptcm", ".", "Cmax", ",", "&", "ptcm", ".", "Xmax", ",", "&", "ptcm", ".", "Cmin", ",", "&", "ptcm", ".", "Xmin", ",", "&", "ptcm", ".", "Ctid", ",", "&", "ptcm", ".", "Mapcfg", ",", "&", "ptcm", ".", "Maptokentype", ",", "&", "ptcm", ".", "Mapseqno", ",", "&", "ptcm", ".", "Mapdict", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptcm", ",", "nil", "\n", "}" ]

[ "PgTsConfigMapByMapcfgMaptokentypeMapseqno", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_config_map", "as", "a", "PgTsConfigMap", ".", "Generated", "from", "index", "pg_ts_config_map_index", "." ]

[ "func", "PgTsDictByDictnameDictnamespace", "(", "db", "XODB", ",", "dictname", "pgtypes", ".", "Name", ",", "dictnamespace", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsDict", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption `", "+", "`FROM pg_catalog.pg_ts_dict `", "+", "`WHERE dictname = $1 AND dictnamespace = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "dictname", ",", "dictnamespace", ")", "\n", "ptd", ":=", "PgTsDict", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "dictname", ",", "dictnamespace", ")", ".", "Scan", "(", "&", "ptd", ".", "Tableoid", ",", "&", "ptd", ".", "Cmax", ",", "&", "ptd", ".", "Xmax", ",", "&", "ptd", ".", "Cmin", ",", "&", "ptd", ".", "Xmin", ",", "&", "ptd", ".", "Oid", ",", "&", "ptd", ".", "Ctid", ",", "&", "ptd", ".", "Dictname", ",", "&", "ptd", ".", "Dictnamespace", ",", "&", "ptd", ".", "Dictowner", ",", "&", "ptd", ".", "Dicttemplate", ",", "&", "ptd", ".", "Dictinitoption", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptd", ",", "nil", "\n", "}" ]

[ "PgTsDictByDictnameDictnamespace", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_dict", "as", "a", "PgTsDict", ".", "Generated", "from", "index", "pg_ts_dict_dictname_index", "." ]

[ "func", "PgTsParserByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsParser", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype `", "+", "`FROM pg_catalog.pg_ts_parser `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "ptp", ":=", "PgTsParser", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "ptp", ".", "Tableoid", ",", "&", "ptp", ".", "Cmax", ",", "&", "ptp", ".", "Xmax", ",", "&", "ptp", ".", "Cmin", ",", "&", "ptp", ".", "Xmin", ",", "&", "ptp", ".", "Oid", ",", "&", "ptp", ".", "Ctid", ",", "&", "ptp", ".", "Prsname", ",", "&", "ptp", ".", "Prsnamespace", ",", "&", "ptp", ".", "Prsstart", ",", "&", "ptp", ".", "Prstoken", ",", "&", "ptp", ".", "Prsend", ",", "&", "ptp", ".", "Prsheadline", ",", "&", "ptp", ".", "Prslextype", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptp", ",", "nil", "\n", "}" ]

[ "PgTsParserByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_parser", "as", "a", "PgTsParser", ".", "Generated", "from", "index", "pg_ts_parser_oid_index", "." ]

[ "func", "PgTsTemplateByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsTemplate", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize `", "+", "`FROM pg_catalog.pg_ts_template `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "ptt", ":=", "PgTsTemplate", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "ptt", ".", "Tableoid", ",", "&", "ptt", ".", "Cmax", ",", "&", "ptt", ".", "Xmax", ",", "&", "ptt", ".", "Cmin", ",", "&", "ptt", ".", "Xmin", ",", "&", "ptt", ".", "Oid", ",", "&", "ptt", ".", "Ctid", ",", "&", "ptt", ".", "Tmplname", ",", "&", "ptt", ".", "Tmplnamespace", ",", "&", "ptt", ".", "Tmplinit", ",", "&", "ptt", ".", "Tmpllexize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptt", ",", "nil", "\n", "}" ]

[ "PgTsTemplateByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_template", "as", "a", "PgTsTemplate", ".", "Generated", "from", "index", "pg_ts_template_oid_index", "." ]

[ "func", "PgTsTemplateByTmplnameTmplnamespace", "(", "db", "XODB", ",", "tmplname", "pgtypes", ".", "Name", ",", "tmplnamespace", "pgtypes", ".", "Oid", ")", "(", "*", "PgTsTemplate", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize `", "+", "`FROM pg_catalog.pg_ts_template `", "+", "`WHERE tmplname = $1 AND tmplnamespace = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "tmplname", ",", "tmplnamespace", ")", "\n", "ptt", ":=", "PgTsTemplate", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "tmplname", ",", "tmplnamespace", ")", ".", "Scan", "(", "&", "ptt", ".", "Tableoid", ",", "&", "ptt", ".", "Cmax", ",", "&", "ptt", ".", "Xmax", ",", "&", "ptt", ".", "Cmin", ",", "&", "ptt", ".", "Xmin", ",", "&", "ptt", ".", "Oid", ",", "&", "ptt", ".", "Ctid", ",", "&", "ptt", ".", "Tmplname", ",", "&", "ptt", ".", "Tmplnamespace", ",", "&", "ptt", ".", "Tmplinit", ",", "&", "ptt", ".", "Tmpllexize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ptt", ",", "nil", "\n", "}" ]

[ "PgTsTemplateByTmplnameTmplnamespace", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_ts_template", "as", "a", "PgTsTemplate", ".", "Generated", "from", "index", "pg_ts_template_tmplname_index", "." ]

[ "func", "PgTypeByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgType", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, typname, typnamespace, typowner, typlen, typbyval, typtype, typcategory, typispreferred, typisdefined, typdelim, typrelid, typelem, typarray, typinput, typoutput, typreceive, typsend, typmodin, typmodout, typanalyze, typalign, typstorage, typnotnull, typbasetype, typtypmod, typndims, typcollation, typdefaultbin, typdefault, typacl `", "+", "`FROM pg_catalog.pg_type `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pt", ":=", "PgType", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pt", ".", "Tableoid", ",", "&", "pt", ".", "Cmax", ",", "&", "pt", ".", "Xmax", ",", "&", "pt", ".", "Cmin", ",", "&", "pt", ".", "Xmin", ",", "&", "pt", ".", "Oid", ",", "&", "pt", ".", "Ctid", ",", "&", "pt", ".", "Typname", ",", "&", "pt", ".", "Typnamespace", ",", "&", "pt", ".", "Typowner", ",", "&", "pt", ".", "Typlen", ",", "&", "pt", ".", "Typbyval", ",", "&", "pt", ".", "Typtype", ",", "&", "pt", ".", "Typcategory", ",", "&", "pt", ".", "Typispreferred", ",", "&", "pt", ".", "Typisdefined", ",", "&", "pt", ".", "Typdelim", ",", "&", "pt", ".", "Typrelid", ",", "&", "pt", ".", "Typelem", ",", "&", "pt", ".", "Typarray", ",", "&", "pt", ".", "Typinput", ",", "&", "pt", ".", "Typoutput", ",", "&", "pt", ".", "Typreceive", ",", "&", "pt", ".", "Typsend", ",", "&", "pt", ".", "Typmodin", ",", "&", "pt", ".", "Typmodout", ",", "&", "pt", ".", "Typanalyze", ",", "&", "pt", ".", "Typalign", ",", "&", "pt", ".", "Typstorage", ",", "&", "pt", ".", "Typnotnull", ",", "&", "pt", ".", "Typbasetype", ",", "&", "pt", ".", "Typtypmod", ",", "&", "pt", ".", "Typndims", ",", "&", "pt", ".", "Typcollation", ",", "&", "pt", ".", "Typdefaultbin", ",", "&", "pt", ".", "Typdefault", ",", "&", "pt", ".", "Typacl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pt", ",", "nil", "\n", "}" ]

[ "PgTypeByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_type", "as", "a", "PgType", ".", "Generated", "from", "index", "pg_type_oid_index", "." ]

[ "func", "PgUserMappingByOid", "(", "db", "XODB", ",", "oid", "pgtypes", ".", "Oid", ")", "(", "*", "PgUserMapping", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`tableoid, cmax, xmax, cmin, xmin, oid, ctid, umuser, umserver, umoptions `", "+", "`FROM pg_catalog.pg_user_mapping `", "+", "`WHERE oid = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "oid", ")", "\n", "pum", ":=", "PgUserMapping", "{", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "oid", ")", ".", "Scan", "(", "&", "pum", ".", "Tableoid", ",", "&", "pum", ".", "Cmax", ",", "&", "pum", ".", "Xmax", ",", "&", "pum", ".", "Cmin", ",", "&", "pum", ".", "Xmin", ",", "&", "pum", ".", "Oid", ",", "&", "pum", ".", "Ctid", ",", "&", "pum", ".", "Umuser", ",", "&", "pum", ".", "Umserver", ",", "&", "pum", ".", "Umoptions", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pum", ",", "nil", "\n", "}" ]

[ "PgUserMappingByOid", "retrieves", "a", "row", "from", "pg_catalog", ".", "pg_user_mapping", "as", "a", "PgUserMapping", ".", "Generated", "from", "index", "pg_user_mapping_oid_index", "." ]

[ "func", "(", "ss", "*", "StringSlice", ")", "Scan", "(", "src", "interface", "{", "}", ")", "error", "{", "buf", ",", "ok", ":=", "src", ".", "(", "[", "]", "byte", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// change quote escapes for csv parser", "str", ":=", "quoteEscapeRegex", ".", "ReplaceAllString", "(", "string", "(", "buf", ")", ",", "`$1\"\"`", ")", "\n", "str", "=", "strings", ".", "Replace", "(", "str", ",", "`\\\\`", ",", "`\\`", ",", "-", "1", ")", "\n\n", "// remove braces", "str", "=", "str", "[", "1", ":", "len", "(", "str", ")", "-", "1", "]", "\n\n", "// bail if only one", "if", "len", "(", "str", ")", "==", "0", "{", "*", "ss", "=", "StringSlice", "(", "[", "]", "string", "{", "}", ")", "\n", "return", "nil", "\n", "}", "\n\n", "// parse with csv reader", "cr", ":=", "csv", ".", "NewReader", "(", "strings", ".", "NewReader", "(", "str", ")", ")", "\n", "slice", ",", "err", ":=", "cr", ".", "Read", "(", ")", "\n", "if", "err", "!=", "nil", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "*", "ss", "=", "StringSlice", "(", "slice", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Scan", "satisfies", "the", "sql", ".", "Scanner", "interface", "for", "StringSlice", "." ]

[ "func", "(", "ss", "StringSlice", ")", "Value", "(", ")", "(", "driver", ".", "Value", ",", "error", ")", "{", "v", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "ss", ")", ")", "\n", "for", "i", ",", "s", ":=", "range", "ss", "{", "v", "[", "i", "]", "=", "`\"`", "+", "strings", ".", "Replace", "(", "strings", ".", "Replace", "(", "s", ",", "`\\`", ",", "`\\\\\\`", ",", "-", "1", ")", ",", "`\"`", ",", "`\\\"`", ",", "-", "1", ")", "+", "`\"`", "\n", "}", "\n", "return", "\"", "\"", "+", "strings", ".", "Join", "(", "v", ",", "\"", "\"", ")", "+", "\"", "\"", ",", "nil", "\n", "}" ]

[ "Value", "satisfies", "the", "driver", ".", "Valuer", "interface", "for", "StringSlice", "." ]

[ "func", "(", "dct", "*", "DjangoContentType", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "dct", ".", "Exists", "(", ")", "{", "return", "dct", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "dct", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "DjangoContentType", "to", "the", "database", "." ]

[ "func", "DjangoContentTypeByAppLabelModel", "(", "db", "XODB", ",", "appLabel", "string", ",", "model", "string", ")", "(", "*", "DjangoContentType", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, app_label, model `", "+", "`FROM django.django_content_type `", "+", "`WHERE app_label = ? AND model = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "appLabel", ",", "model", ")", "\n", "dct", ":=", "DjangoContentType", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "appLabel", ",", "model", ")", ".", "Scan", "(", "&", "dct", ".", "ID", ",", "&", "dct", ".", "AppLabel", ",", "&", "dct", ".", "Model", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "dct", ",", "nil", "\n", "}" ]

[ "DjangoContentTypeByAppLabelModel", "retrieves", "a", "row", "from", "django", ".", "django_content_type", "as", "a", "DjangoContentType", ".", "Generated", "from", "index", "django_content_type_app_label_76bd3d3b_uniq", "." ]

[ "func", "(", "ag", "*", "AuthGroup", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "ag", ".", "Exists", "(", ")", "{", "return", "ag", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "ag", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "AuthGroup", "to", "the", "database", "." ]

[ "func", "AuthGroupByID", "(", "db", "XODB", ",", "id", "int", ")", "(", "*", "AuthGroup", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, name `", "+", "`FROM django.auth_group `", "+", "`WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "id", ")", "\n", "ag", ":=", "AuthGroup", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "id", ")", ".", "Scan", "(", "&", "ag", ".", "ID", ",", "&", "ag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ag", ",", "nil", "\n", "}" ]

[ "AuthGroupByID", "retrieves", "a", "row", "from", "django", ".", "auth_group", "as", "a", "AuthGroup", ".", "Generated", "from", "index", "auth_group_id_pkey", "." ]

[ "func", "(", "ds", "*", "DjangoSession", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "ds", ".", "Exists", "(", ")", "{", "return", "ds", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "ds", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "DjangoSession", "to", "the", "database", "." ]

[ "func", "(", "ds", "*", "DjangoSession", ")", "Delete", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "ds", ".", "_exists", "{", "return", "nil", "\n", "}", "\n\n", "// if deleted, bail", "if", "ds", ".", "_deleted", "{", "return", "nil", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`DELETE FROM django.django_session WHERE session_key = :1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "ds", ".", "SessionKey", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "ds", ".", "SessionKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// set deleted", "ds", ".", "_deleted", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "deletes", "the", "DjangoSession", "from", "the", "database", "." ]

[ "func", "(", "ap", "*", "AuthPermission", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "ap", ".", "Exists", "(", ")", "{", "return", "ap", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "ap", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "AuthPermission", "to", "the", "database", "." ]

[ "func", "AuthPermissionsByContentTypeID", "(", "db", "XODB", ",", "contentTypeID", "float64", ")", "(", "[", "]", "*", "AuthPermission", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, name, content_type_id, codename `", "+", "`FROM django.auth_permission `", "+", "`WHERE content_type_id = :1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "contentTypeID", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "contentTypeID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "AuthPermission", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ap", ":=", "AuthPermission", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ap", ".", "ID", ",", "&", "ap", ".", "Name", ",", "&", "ap", ".", "ContentTypeID", ",", "&", "ap", ".", "Codename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ap", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "AuthPermissionsByContentTypeID", "retrieves", "a", "row", "from", "django", ".", "auth_permission", "as", "a", "AuthPermission", ".", "Generated", "from", "index", "auth_permission_417f1b1c", "." ]

[ "func", "PgGetColOrder", "(", "db", "XODB", ",", "schema", "string", ",", "index", "string", ")", "(", "*", "PgColOrder", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`i.indkey `", "+", "// ::varchar AS ord", "`FROM pg_index i `", "+", "`JOIN ONLY pg_class c ON c.oid = i.indrelid `", "+", "`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `", "+", "`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `", "+", "`WHERE n.nspname = $1 AND ic.relname = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "index", ")", "\n", "var", "pco", "PgColOrder", "\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "schema", ",", "index", ")", ".", "Scan", "(", "&", "pco", ".", "Ord", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "pco", ",", "nil", "\n", "}" ]

[ "PgGetColOrder", "runs", "a", "custom", "query", "returning", "results", "as", "PgColOrder", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "NewTemplateFuncs", "(", ")", "template", ".", "FuncMap", "{", "return", "template", ".", "FuncMap", "{", "\"", "\"", ":", "a", ".", "colcount", ",", "\"", "\"", ":", "a", ".", "colnames", ",", "\"", "\"", ":", "a", ".", "colnamesmulti", ",", "\"", "\"", ":", "a", ".", "colnamesquery", ",", "\"", "\"", ":", "a", ".", "colnamesquerymulti", ",", "\"", "\"", ":", "a", ".", "colprefixnames", ",", "\"", "\"", ":", "a", ".", "colvals", ",", "\"", "\"", ":", "a", ".", "colvalsmulti", ",", "\"", "\"", ":", "a", ".", "fieldnames", ",", "\"", "\"", ":", "a", ".", "fieldnamesmulti", ",", "\"", "\"", ":", "a", ".", "goparamlist", ",", "\"", "\"", ":", "a", ".", "reniltype", ",", "\"", "\"", ":", "a", ".", "retype", ",", "\"", "\"", ":", "a", ".", "shortname", ",", "\"", "\"", ":", "a", ".", "convext", ",", "\"", "\"", ":", "a", ".", "schemafn", ",", "\"", "\"", ":", "a", ".", "colname", ",", "\"", "\"", ":", "a", ".", "hascolumn", ",", "\"", "\"", ":", "a", ".", "hasfield", ",", "\"", "\"", ":", "a", ".", "getstartcount", ",", "}", "\n", "}" ]

[ "NewTemplateFuncs", "returns", "a", "set", "of", "template", "funcs", "bound", "to", "the", "supplied", "args", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "colcount", "(", "fields", "[", "]", "*", "Field", ",", "ignoreNames", "...", "string", ")", "int", "{", "ignore", ":=", "map", "[", "string", "]", "bool", "{", "}", "\n", "for", "_", ",", "n", ":=", "range", "ignoreNames", "{", "ignore", "[", "n", "]", "=", "true", "\n", "}", "\n\n", "i", ":=", "1", "\n", "for", "_", ",", "f", ":=", "range", "fields", "{", "if", "ignore", "[", "f", ".", "Name", "]", "{", "continue", "\n", "}", "\n\n", "i", "++", "\n", "}", "\n", "return", "i", "\n", "}" ]

[ "colcount", "returns", "the", "1", "-", "based", "count", "of", "fields", "excluding", "any", "Field", "with", "Name", "contained", "in", "ignoreNames", ".", "Used", "to", "get", "the", "count", "of", "fields", "and", "useful", "for", "specifying", "the", "last", "SQL", "parameter", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "schemafn", "(", "s", "string", ",", "names", "...", "string", ")", "string", "{", "// escape table names", "if", "a", ".", "EscapeTableNames", "{", "for", "i", ",", "t", ":=", "range", "names", "{", "names", "[", "i", "]", "=", "a", ".", "Loader", ".", "Escape", "(", "TableEsc", ",", "t", ")", "\n", "}", "\n", "}", "\n\n", "n", ":=", "strings", ".", "Join", "(", "names", ",", "\"", "\"", ")", "\n\n", "if", "s", "==", "\"", "\"", "&&", "n", "==", "\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n\n", "if", "s", "!=", "\"", "\"", "&&", "n", "!=", "\"", "\"", "{", "if", "a", ".", "EscapeSchemaName", "{", "s", "=", "a", ".", "Loader", ".", "Escape", "(", "SchemaEsc", ",", "s", ")", "\n", "}", "\n", "s", "=", "s", "+", "\"", "\"", "\n", "}", "\n\n", "return", "s", "+", "n", "\n", "}" ]

[ "schemafn", "takes", "a", "series", "of", "names", "and", "joins", "them", "with", "the", "schema", "name", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "colname", "(", "col", "*", "models", ".", "Column", ")", "string", "{", "if", "a", ".", "EscapeColumnNames", "{", "return", "a", ".", "Loader", ".", "Escape", "(", "ColumnEsc", ",", "col", ".", "ColumnName", ")", "\n", "}", "\n\n", "return", "col", ".", "ColumnName", "\n", "}" ]

[ "colname", "returns", "the", "ColumnName", "of", "col", "optionally", "escaping", "it", "if", "ArgType", ".", "EscapeColumnNames", "is", "toggled", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "hascolumn", "(", "fields", "[", "]", "*", "Field", ",", "name", "string", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "fields", "{", "if", "f", ".", "Col", ".", "ColumnName", "==", "name", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "hascolumn", "takes", "a", "list", "of", "fields", "and", "determines", "if", "field", "with", "the", "specified", "column", "name", "is", "in", "the", "list", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "hasfield", "(", "fields", "[", "]", "*", "Field", ",", "name", "string", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "fields", "{", "if", "f", ".", "Name", "==", "name", "{", "return", "true", "\n", "}", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "hasfield", "takes", "a", "list", "of", "fields", "and", "determines", "if", "field", "with", "the", "specified", "field", "name", "is", "in", "the", "list", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "getstartcount", "(", "fields", "[", "]", "*", "Field", ",", "pkFields", "[", "]", "*", "Field", ")", "int", "{", "return", "len", "(", "fields", ")", "-", "len", "(", "pkFields", ")", "\n", "}" ]

[ "getstartcount", "returns", "a", "starting", "count", "for", "numbering", "columsn", "in", "queries" ]

[ "func", "PgEnums", "(", "db", "XODB", ",", "schema", "string", ")", "(", "[", "]", "*", "Enum", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`t.typname `", "+", "// ::varchar AS enum_name", "`FROM pg_type t `", "+", "`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace `", "+", "`JOIN ONLY pg_enum e ON t.oid = e.enumtypid `", "+", "`WHERE n.nspname = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "Enum", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "e", ":=", "Enum", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "e", ".", "EnumName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "e", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgEnums", "runs", "a", "custom", "query", "returning", "results", "as", "Enum", "." ]

[ "func", "(", "tt", "TemplateType", ")", "String", "(", ")", "string", "{", "var", "s", "string", "\n", "switch", "tt", "{", "case", "XOTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "EnumTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "ProcTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "TypeTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "ForeignKeyTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "IndexTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "QueryTypeTemplate", ":", "s", "=", "\"", "\"", "\n", "case", "QueryTemplate", ":", "s", "=", "\"", "\"", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "String", "returns", "the", "name", "for", "the", "associated", "template", "type", "." ]

[ "func", "(", "rt", "RelType", ")", "String", "(", ")", "string", "{", "var", "s", "string", "\n", "switch", "rt", "{", "case", "Table", ":", "s", "=", "\"", "\"", "\n", "case", "View", ":", "s", "=", "\"", "\"", "\n", "default", ":", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "String", "provides", "the", "string", "representation", "of", "RelType", "." ]

[ "func", "(", "dal", "*", "DjangoAdminLog", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "dal", ".", "Exists", "(", ")", "{", "return", "dal", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "dal", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "DjangoAdminLog", "to", "the", "database", "." ]

[ "func", "DjangoAdminLogsByUserID", "(", "db", "XODB", ",", "userID", "float64", ")", "(", "[", "]", "*", "DjangoAdminLog", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id `", "+", "`FROM django.django_admin_log `", "+", "`WHERE user_id = :1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "userID", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "userID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "DjangoAdminLog", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "dal", ":=", "DjangoAdminLog", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "dal", ".", "ID", ",", "&", "dal", ".", "ActionTime", ",", "&", "dal", ".", "ObjectID", ",", "&", "dal", ".", "ObjectRepr", ",", "&", "dal", ".", "ActionFlag", ",", "&", "dal", ".", "ChangeMessage", ",", "&", "dal", ".", "ContentTypeID", ",", "&", "dal", ".", "UserID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "dal", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "DjangoAdminLogsByUserID", "retrieves", "a", "row", "from", "django", ".", "django_admin_log", "as", "a", "DjangoAdminLog", ".", "Generated", "from", "index", "django_admin_log_e8701ad4", "." ]

[ "func", "(", "au", "*", "AuthUser", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "au", ".", "Exists", "(", ")", "{", "return", "au", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "au", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "AuthUser", "to", "the", "database", "." ]

[ "func", "DjangoAdminLogByID", "(", "db", "XODB", ",", "id", "int", ")", "(", "*", "DjangoAdminLog", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, object_id, object_repr, action_flag, change_message, content_type_id, user_id, action_time `", "+", "`FROM django_admin_log `", "+", "`WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "id", ")", "\n", "dal", ":=", "DjangoAdminLog", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "id", ")", ".", "Scan", "(", "&", "dal", ".", "ID", ",", "&", "dal", ".", "ObjectID", ",", "&", "dal", ".", "ObjectRepr", ",", "&", "dal", ".", "ActionFlag", ",", "&", "dal", ".", "ChangeMessage", ",", "&", "dal", ".", "ContentTypeID", ",", "&", "dal", ".", "UserID", ",", "&", "dal", ".", "ActionTime", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "dal", ",", "nil", "\n", "}" ]

[ "DjangoAdminLogByID", "retrieves", "a", "row", "from", "django_admin_log", "as", "a", "DjangoAdminLog", ".", "Generated", "from", "index", "django_admin_log_id_pkey", "." ]

[ "func", "AuthGroupsByName", "(", "db", "XODB", ",", "name", "string", ")", "(", "[", "]", "*", "AuthGroup", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, name `", "+", "`FROM public.auth_group `", "+", "`WHERE name = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "name", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "AuthGroup", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ag", ":=", "AuthGroup", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ag", ".", "ID", ",", "&", "ag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ag", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "AuthGroupsByName", "retrieves", "a", "row", "from", "public", ".", "auth_group", "as", "a", "AuthGroup", ".", "Generated", "from", "index", "auth_group_name_a6ea08ec_like", "." ]

[ "func", "AuthGroupByName", "(", "db", "XODB", ",", "name", "string", ")", "(", "*", "AuthGroup", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, name `", "+", "`FROM public.auth_group `", "+", "`WHERE name = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "name", ")", "\n", "ag", ":=", "AuthGroup", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "name", ")", ".", "Scan", "(", "&", "ag", ".", "ID", ",", "&", "ag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "ag", ",", "nil", "\n", "}" ]

[ "AuthGroupByName", "retrieves", "a", "row", "from", "public", ".", "auth_group", "as", "a", "AuthGroup", ".", "Generated", "from", "index", "auth_group_name_key", "." ]

[ "func", "PgTableIndexes", "(", "db", "XODB", ",", "schema", "string", ",", "table", "string", ")", "(", "[", "]", "*", "Index", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`DISTINCT ic.relname, `", "+", "// ::varchar AS index_name", "`i.indisunique, `", "+", "// ::boolean AS is_unique", "`i.indisprimary, `", "+", "// ::boolean AS is_primary", "`0, `", "+", "// ::integer AS seq_no", "`'', `", "+", "// ::varchar AS origin", "`false `", "+", "// ::boolean AS is_partial", "`FROM pg_index i `", "+", "`JOIN ONLY pg_class c ON c.oid = i.indrelid `", "+", "`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `", "+", "`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `", "+", "`WHERE i.indkey <> '0' AND n.nspname = $1 AND c.relname = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "Index", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "i", ":=", "Index", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "i", ".", "IndexName", ",", "&", "i", ".", "IsUnique", ",", "&", "i", ".", "IsPrimary", ",", "&", "i", ".", "SeqNo", ",", "&", "i", ".", "Origin", ",", "&", "i", ".", "IsPartial", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "i", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgTableIndexes", "runs", "a", "custom", "query", "returning", "results", "as", "Index", "." ]

[ "func", "MsTables", "(", "db", "XODB", ",", "schema", "string", ",", "relkind", "string", ")", "(", "[", "]", "*", "Table", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`xtype AS type, `", "+", "`name AS table_name `", "+", "`FROM sysobjects `", "+", "`WHERE SCHEMA_NAME(uid) = $1 AND xtype = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "relkind", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "relkind", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "Table", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "t", ":=", "Table", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "t", ".", "Type", ",", "&", "t", ".", "TableName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "t", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "MsTables", "runs", "a", "custom", "query", "returning", "results", "as", "Table", "." ]

[ "func", "PgEnumValues", "(", "db", "XODB", ",", "schema", "string", ",", "enum", "string", ")", "(", "[", "]", "*", "EnumValue", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`e.enumlabel, `", "+", "// ::varchar AS enum_value", "`e.enumsortorder `", "+", "// ::integer AS const_value", "`FROM pg_type t `", "+", "`JOIN ONLY pg_namespace n ON n.oid = t.typnamespace `", "+", "`LEFT JOIN pg_enum e ON t.oid = e.enumtypid `", "+", "`WHERE n.nspname = $1 AND t.typname = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "enum", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "enum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "EnumValue", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ev", ":=", "EnumValue", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ev", ".", "EnumValue", ",", "&", "ev", ".", "ConstValue", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ev", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgEnumValues", "runs", "a", "custom", "query", "returning", "results", "as", "EnumValue", "." ]

[ "func", "OrParseType", "(", "args", "*", "internal", ".", "ArgType", ",", "dt", "string", ",", "nullable", "bool", ")", "(", "int", ",", "string", ",", "string", ")", "{", "nilVal", ":=", "\"", "\"", "\n\n", "dt", "=", "strings", ".", "ToLower", "(", "dt", ")", "\n\n", "// extract precision", "dt", ",", "precision", ",", "scale", ":=", "args", ".", "ParsePrecision", "(", "dt", ")", "\n\n", "var", "typ", "string", "\n", "// strip remaining length (on things like timestamp)", "switch", "OrLenRE", ".", "ReplaceAllString", "(", "dt", ",", "\"", "\"", ")", "{", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "`\"\"`", "\n", "typ", "=", "\"", "\"", "\n\n", "case", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "case", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "args", ".", "Int32Type", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "case", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "if", "0", "<", "precision", "&&", "precision", "<", "18", "&&", "scale", ">", "0", "{", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "}", "else", "if", "0", "<", "precision", "&&", "precision", "<=", "19", "&&", "scale", "==", "0", "{", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "}", "else", "{", "nilVal", "=", "`\"\"`", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "typ", "=", "\"", "\"", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "typ", "=", "\"", "\"", "\n", "nilVal", "=", "\"", "\"", "\n\n", "default", ":", "// bail", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "dt", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n\n", "// special case for bool", "if", "typ", "==", "\"", "\"", "&&", "precision", "==", "1", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "return", "precision", ",", "nilVal", ",", "typ", "\n", "}" ]

[ "OrParseType", "parse", "a", "oracle", "type", "into", "a", "Go", "type", "based", "on", "the", "column", "definition", "." ]

[ "func", "PgIndexColumns", "(", "db", "XODB", ",", "schema", "string", ",", "index", "string", ")", "(", "[", "]", "*", "IndexColumn", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`(row_number() over()), `", "+", "// ::integer AS seq_no", "`a.attnum, `", "+", "// ::integer AS cid", "`a.attname `", "+", "// ::varchar AS column_name", "`FROM pg_index i `", "+", "`JOIN ONLY pg_class c ON c.oid = i.indrelid `", "+", "`JOIN ONLY pg_namespace n ON n.oid = c.relnamespace `", "+", "`JOIN ONLY pg_class ic ON ic.oid = i.indexrelid `", "+", "`LEFT JOIN pg_attribute a ON i.indrelid = a.attrelid AND a.attnum = ANY(i.indkey) AND a.attisdropped = false `", "+", "`WHERE i.indkey <> '0' AND n.nspname = $1 AND ic.relname = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "index", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "index", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "IndexColumn", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ic", ":=", "IndexColumn", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ic", ".", "SeqNo", ",", "&", "ic", ".", "Cid", ",", "&", "ic", ".", "ColumnName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ic", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgIndexColumns", "runs", "a", "custom", "query", "returning", "results", "as", "IndexColumn", "." ]

[ "func", "PgTableForeignKeys", "(", "db", "XODB", ",", "schema", "string", ",", "table", "string", ")", "(", "[", "]", "*", "ForeignKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`r.conname, `", "+", "// ::varchar AS foreign_key_name", "`b.attname, `", "+", "// ::varchar AS column_name", "`i.relname, `", "+", "// ::varchar AS ref_index_name", "`c.relname, `", "+", "// ::varchar AS ref_table_name", "`d.attname, `", "+", "// ::varchar AS ref_column_name", "`0, `", "+", "// ::integer AS key_id", "`0, `", "+", "// ::integer AS seq_no", "`'', `", "+", "// ::varchar AS on_update", "`'', `", "+", "// ::varchar AS on_delete", "`'' `", "+", "// ::varchar AS match", "`FROM pg_constraint r `", "+", "`JOIN ONLY pg_class a ON a.oid = r.conrelid `", "+", "`JOIN ONLY pg_attribute b ON b.attisdropped = false AND b.attnum = ANY(r.conkey) AND b.attrelid = r.conrelid `", "+", "`JOIN ONLY pg_class i on i.oid = r.conindid `", "+", "`JOIN ONLY pg_class c on c.oid = r.confrelid `", "+", "`JOIN ONLY pg_attribute d ON d.attisdropped = false AND d.attnum = ANY(r.confkey) AND d.attrelid = r.confrelid `", "+", "`JOIN ONLY pg_namespace n ON n.oid = r.connamespace `", "+", "`WHERE r.contype = 'f' AND n.nspname = $1 AND a.relname = $2 `", "+", "`ORDER BY r.conname, b.attname`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "ForeignKey", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "fk", ":=", "ForeignKey", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "fk", ".", "ForeignKeyName", ",", "&", "fk", ".", "ColumnName", ",", "&", "fk", ".", "RefIndexName", ",", "&", "fk", ".", "RefTableName", ",", "&", "fk", ".", "RefColumnName", ",", "&", "fk", ".", "KeyID", ",", "&", "fk", ".", "SeqNo", ",", "&", "fk", ".", "OnUpdate", ",", "&", "fk", ".", "OnDelete", ",", "&", "fk", ".", "Match", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "fk", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "PgTableForeignKeys", "runs", "a", "custom", "query", "returning", "results", "as", "ForeignKey", "." ]

[ "func", "MsTableForeignKeys", "(", "db", "XODB", ",", "schema", "string", ",", "table", "string", ")", "(", "[", "]", "*", "ForeignKey", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`f.name AS foreign_key_name, `", "+", "`c.name AS column_name, `", "+", "`o.name AS ref_table_name, `", "+", "`x.name AS ref_column_name `", "+", "`FROM sysobjects f `", "+", "`INNER JOIN sysobjects t ON f.parent_obj = t.id `", "+", "`INNER JOIN sysreferences r ON f.id = r.constid `", "+", "`INNER JOIN sysobjects o ON r.rkeyid = o.id `", "+", "`INNER JOIN syscolumns c ON r.rkeyid = c.id AND r.rkey1 = c.colid `", "+", "`INNER JOIN syscolumns x ON r.fkeyid = x.id AND r.fkey1 = x.colid `", "+", "`WHERE f.type = 'F' AND t.type = 'U' AND SCHEMA_NAME(t.uid) = $1 AND t.name = $2`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ",", "table", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "ForeignKey", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "fk", ":=", "ForeignKey", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "fk", ".", "ForeignKeyName", ",", "&", "fk", ".", "ColumnName", ",", "&", "fk", ".", "RefTableName", ",", "&", "fk", ".", "RefColumnName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "fk", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "MsTableForeignKeys", "runs", "a", "custom", "query", "returning", "results", "as", "ForeignKey", "." ]

[ "func", "(", "ap", "*", "AuthPermission", ")", "Update", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "ap", ".", "_exists", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// if deleted, bail", "if", "ap", ".", "_deleted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`UPDATE auth_permission SET `", "+", "`content_type_id = ?, codename = ?, name = ?`", "+", "` WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "ap", ".", "ContentTypeID", ",", "ap", ".", "Codename", ",", "ap", ".", "Name", ",", "ap", ".", "ID", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "ap", ".", "ContentTypeID", ",", "ap", ".", "Codename", ",", "ap", ".", "Name", ",", "ap", ".", "ID", ")", "\n", "return", "err", "\n", "}" ]

[ "Update", "updates", "the", "AuthPermission", "in", "the", "database", "." ]

[ "func", "(", "ap", "*", "AuthPermission", ")", "Delete", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "ap", ".", "_exists", "{", "return", "nil", "\n", "}", "\n\n", "// if deleted, bail", "if", "ap", ".", "_deleted", "{", "return", "nil", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`DELETE FROM auth_permission WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "ap", ".", "ID", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "ap", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// set deleted", "ap", ".", "_deleted", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "deletes", "the", "AuthPermission", "from", "the", "database", "." ]

[ "func", "(", "agp", "*", "AuthGroupPermission", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "agp", ".", "Exists", "(", ")", "{", "return", "agp", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "agp", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "AuthGroupPermission", "to", "the", "database", "." ]

[ "func", "AuthGroupPermissionsByPermissionID", "(", "db", "XODB", ",", "permissionID", "int", ")", "(", "[", "]", "*", "AuthGroupPermission", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, group_id, permission_id `", "+", "`FROM django.auth_group_permissions `", "+", "`WHERE permission_id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "permissionID", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "permissionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "AuthGroupPermission", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "agp", ":=", "AuthGroupPermission", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "agp", ".", "ID", ",", "&", "agp", ".", "GroupID", ",", "&", "agp", ".", "PermissionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "agp", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "AuthGroupPermissionsByPermissionID", "retrieves", "a", "row", "from", "django", ".", "auth_group_permissions", "as", "a", "AuthGroupPermission", ".", "Generated", "from", "index", "auth_group_permissi_permission_id_84c5c92e_fk_auth_permission_id", "." ]

[ "func", "processArgs", "(", "args", "*", "internal", ".", "ArgType", ")", "error", "{", "var", "err", "error", "\n\n", "// get working directory", "cwd", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// determine out path", "if", "args", ".", "Out", "==", "\"", "\"", "{", "args", ".", "Path", "=", "cwd", "\n", "}", "else", "{", "// determine what to do with Out", "fi", ",", "err", ":=", "os", ".", "Stat", "(", "args", ".", "Out", ")", "\n", "if", "err", "==", "nil", "&&", "fi", ".", "IsDir", "(", ")", "{", "// out is directory", "args", ".", "Path", "=", "args", ".", "Out", "\n", "}", "else", "if", "err", "==", "nil", "&&", "!", "fi", ".", "IsDir", "(", ")", "{", "// file exists (will truncate later)", "args", ".", "Path", "=", "path", ".", "Dir", "(", "args", ".", "Out", ")", "\n", "args", ".", "Filename", "=", "path", ".", "Base", "(", "args", ".", "Out", ")", "\n\n", "// error if not split was set, but destination is not a directory", "if", "!", "args", ".", "SingleFile", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "os", ".", "PathError", ")", ";", "ok", "{", "// path error (ie, file doesn't exist yet)", "args", ".", "Path", "=", "path", ".", "Dir", "(", "args", ".", "Out", ")", "\n", "args", ".", "Filename", "=", "path", ".", "Base", "(", "args", ".", "Out", ")", "\n\n", "// error if split was set, but dest doesn't exist", "if", "!", "args", ".", "SingleFile", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "else", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// check user template path", "if", "args", ".", "TemplatePath", "!=", "\"", "\"", "{", "fi", ",", "err", ":=", "os", ".", "Stat", "(", "args", ".", "TemplatePath", ")", "\n", "if", "err", "==", "nil", "&&", "!", "fi", ".", "IsDir", "(", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "// fix path", "if", "args", ".", "Path", "==", "\"", "\"", "{", "args", ".", "Path", "=", "cwd", "\n", "}", "\n\n", "// determine package name", "if", "args", ".", "Package", "==", "\"", "\"", "{", "args", ".", "Package", "=", "path", ".", "Base", "(", "args", ".", "Path", ")", "\n", "}", "\n\n", "// determine filename if not previously set", "if", "args", ".", "Filename", "==", "\"", "\"", "{", "args", ".", "Filename", "=", "args", ".", "Package", "+", "args", ".", "Suffix", "\n", "}", "\n\n", "// if query mode toggled, but no query, read Stdin.", "if", "args", ".", "QueryMode", "&&", "args", ".", "Query", "==", "\"", "\"", "{", "buf", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "os", ".", "Stdin", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "args", ".", "Query", "=", "string", "(", "buf", ")", "\n", "}", "\n\n", "// query mode parsing", "if", "args", ".", "Query", "!=", "\"", "\"", "{", "args", ".", "QueryMode", "=", "true", "\n", "}", "\n\n", "// check that query type was specified", "if", "args", ".", "QueryMode", "&&", "args", ".", "QueryType", "==", "\"", "\"", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// query trim", "if", "args", ".", "QueryMode", "&&", "args", ".", "QueryTrim", "{", "args", ".", "Query", "=", "strings", ".", "TrimSpace", "(", "args", ".", "Query", ")", "\n", "}", "\n\n", "// escape all", "if", "args", ".", "EscapeAll", "{", "args", ".", "EscapeSchemaName", "=", "true", "\n", "args", ".", "EscapeTableNames", "=", "true", "\n", "args", ".", "EscapeColumnNames", "=", "true", "\n", "}", "\n\n", "// if verbose", "if", "args", ".", "Verbose", "{", "models", ".", "XOLog", "=", "func", "(", "s", "string", ",", "p", "...", "interface", "{", "}", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\\n", "\\n", "\\n", "\\n", "\"", ",", "s", ",", "p", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "processArgs", "processs", "cli", "args", "." ]

[ "func", "openDB", "(", "args", "*", "internal", ".", "ArgType", ")", "error", "{", "var", "err", "error", "\n\n", "// parse dsn", "u", ",", "err", ":=", "dburl", ".", "Parse", "(", "args", ".", "DSN", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// save driver type", "args", ".", "LoaderType", "=", "u", ".", "Driver", "\n\n", "// grab loader", "var", "ok", "bool", "\n", "args", ".", "Loader", ",", "ok", "=", "internal", ".", "SchemaLoaders", "[", "u", ".", "Driver", "]", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// open database connection", "args", ".", "DB", ",", "err", "=", "sql", ".", "Open", "(", "u", ".", "Driver", ",", "u", ".", "DSN", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "openDB", "attempts", "to", "open", "a", "database", "connection", "." ]

[ "func", "getFile", "(", "args", "*", "internal", ".", "ArgType", ",", "t", "*", "internal", ".", "TBuf", ")", "(", "*", "os", ".", "File", ",", "error", ")", "{", "var", "f", "*", "os", ".", "File", "\n", "var", "err", "error", "\n\n", "// determine filename", "var", "filename", "=", "strings", ".", "ToLower", "(", "t", ".", "Name", ")", "+", "args", ".", "Suffix", "\n", "if", "args", ".", "SingleFile", "{", "filename", "=", "args", ".", "Filename", "\n", "}", "\n", "filename", "=", "path", ".", "Join", "(", "args", ".", "Path", ",", "filename", ")", "\n\n", "// lookup file", "f", ",", "ok", ":=", "files", "[", "filename", "]", "\n", "if", "ok", "{", "return", "f", ",", "nil", "\n", "}", "\n\n", "// default open mode", "mode", ":=", "os", ".", "O_RDWR", "|", "os", ".", "O_CREATE", "|", "os", ".", "O_TRUNC", "\n\n", "// stat file to determine if file already exists", "fi", ",", "err", ":=", "os", ".", "Stat", "(", "filename", ")", "\n", "if", "err", "==", "nil", "&&", "fi", ".", "IsDir", "(", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "else", "if", "_", ",", "ok", "=", "err", ".", "(", "*", "os", ".", "PathError", ")", ";", "!", "ok", "&&", "args", ".", "Append", "&&", "t", ".", "TemplateType", "!=", "internal", ".", "XOTemplate", "{", "// file exists so append if append is set and not XO type", "mode", "=", "os", ".", "O_APPEND", "|", "os", ".", "O_WRONLY", "\n", "}", "\n\n", "// skip", "if", "t", ".", "TemplateType", "==", "internal", ".", "XOTemplate", "&&", "fi", "!=", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// open file", "f", ",", "err", "=", "os", ".", "OpenFile", "(", "filename", ",", "mode", ",", "0666", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// file didn't originally exist, so add package header", "if", "fi", "==", "nil", "||", "!", "args", ".", "Append", "{", "// add build tags", "if", "args", ".", "Tags", "!=", "\"", "\"", "{", "f", ".", "WriteString", "(", "`// +build `", "+", "args", ".", "Tags", "+", "\"", "\\n", "\\n", "\"", ")", "\n", "}", "\n\n", "// execute", "err", "=", "args", ".", "TemplateSet", "(", ")", ".", "Execute", "(", "f", ",", "\"", "\"", ",", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "// store file", "files", "[", "filename", "]", "=", "f", "\n\n", "return", "f", ",", "nil", "\n", "}" ]

[ "getFile", "builds", "the", "filepath", "from", "the", "TBuf", "information", "and", "retrieves", "the", "file", "from", "files", ".", "If", "the", "built", "filename", "is", "not", "already", "defined", "then", "it", "calls", "the", "os", ".", "OpenFile", "with", "the", "correct", "parameters", "depending", "on", "the", "state", "of", "args", "." ]

[ "func", "writeTypes", "(", "args", "*", "internal", ".", "ArgType", ")", "error", "{", "var", "err", "error", "\n\n", "out", ":=", "internal", ".", "TBufSlice", "(", "args", ".", "Generated", ")", "\n\n", "// sort segments", "sort", ".", "Sort", "(", "out", ")", "\n\n", "// loop, writing in order", "for", "_", ",", "t", ":=", "range", "out", "{", "var", "f", "*", "os", ".", "File", "\n\n", "// skip when in append and type is XO", "if", "args", ".", "Append", "&&", "t", ".", "TemplateType", "==", "internal", ".", "XOTemplate", "{", "continue", "\n", "}", "\n\n", "// check if generated template is only whitespace/empty", "bufStr", ":=", "strings", ".", "TrimSpace", "(", "t", ".", "Buf", ".", "String", "(", ")", ")", "\n", "if", "len", "(", "bufStr", ")", "==", "0", "{", "continue", "\n", "}", "\n\n", "// get file and filename", "f", ",", "err", "=", "getFile", "(", "args", ",", "&", "t", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// should only be nil when type == xo", "if", "f", "==", "nil", "{", "continue", "\n", "}", "\n\n", "// write segment", "if", "!", "args", ".", "Append", "||", "(", "t", ".", "TemplateType", "!=", "internal", ".", "TypeTemplate", "&&", "t", ".", "TemplateType", "!=", "internal", ".", "QueryTypeTemplate", ")", "{", "_", ",", "err", "=", "t", ".", "Buf", ".", "WriteTo", "(", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// build goimports parameters, closing files", "params", ":=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "for", "k", ",", "f", ":=", "range", "files", "{", "params", "=", "append", "(", "params", ",", "k", ")", "\n\n", "// close", "err", "=", "f", ".", "Close", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// process written files with goimports", "output", ",", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "params", "...", ")", ".", "CombinedOutput", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "New", "(", "string", "(", "output", ")", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "writeTypes", "writes", "the", "generated", "definitions", "." ]

[ "func", "MyAutoIncrements", "(", "db", "XODB", ",", "schema", "string", ")", "(", "[", "]", "*", "MyAutoIncrement", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`table_name `", "+", "`FROM information_schema.tables `", "+", "`WHERE auto_increment IS NOT null AND table_schema = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "schema", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "schema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "MyAutoIncrement", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "mai", ":=", "MyAutoIncrement", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "mai", ".", "TableName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "mai", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "MyAutoIncrements", "runs", "a", "custom", "query", "returning", "results", "as", "MyAutoIncrement", "." ]

[ "func", "SqAutoIncrements", "(", "db", "XODB", ")", "(", "[", "]", "*", "SqAutoIncrement", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`name as table_name, sql `", "+", "`FROM sqlite_master `", "+", "`WHERE type='table' `", "+", "`ORDER BY name`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "SqAutoIncrement", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "sai", ":=", "SqAutoIncrement", "{", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "sai", ".", "TableName", ",", "&", "sai", ".", "SQL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "sai", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "SqAutoIncrements", "runs", "a", "custom", "query", "returning", "results", "as", "SqAutoIncrement", "." ]

[ "func", "fmtIndexName", "(", "ixName", "string", ",", "tableName", "string", ")", "string", "{", "// chop off _ix, _idx, _index, _pkey, or _key", "m", ":=", "IndexChopSuffixRE", ".", "FindStringIndex", "(", "ixName", ")", "\n", "if", "m", "!=", "nil", "{", "ixName", "=", "ixName", "[", ":", "m", "[", "0", "]", "]", "\n", "}", "\n\n", "// check tableName", "if", "ixName", "==", "tableName", "{", "return", "\"", "\"", "\n", "}", "\n\n", "// chop off tablename_", "if", "strings", ".", "HasPrefix", "(", "ixName", ",", "tableName", "+", "\"", "\"", ")", "{", "ixName", "=", "ixName", "[", "len", "(", "tableName", ")", "+", "1", ":", "]", "\n", "}", "\n\n", "// camel case name", "return", "snaker", ".", "SnakeToCamelIdentifier", "(", "ixName", ")", "\n", "}" ]

[ "fmtIndexName", "formats", "the", "index", "name", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "BuildIndexFuncName", "(", "ixTpl", "*", "Index", ")", "{", "// build func name", "funcName", ":=", "ixTpl", ".", "Type", ".", "Name", "\n", "if", "!", "ixTpl", ".", "Index", ".", "IsUnique", "{", "funcName", "=", "inflector", ".", "Pluralize", "(", "ixTpl", ".", "Type", ".", "Name", ")", "\n", "}", "\n", "funcName", "=", "funcName", "+", "\"", "\"", "\n\n", "// add param names", "paramNames", ":=", "[", "]", "string", "{", "}", "\n\n", "ixName", ":=", "fmtIndexName", "(", "ixTpl", ".", "Index", ".", "IndexName", ",", "ixTpl", ".", "Type", ".", "Table", ".", "TableName", ")", "\n", "if", "a", ".", "UseIndexNames", "&&", "ixName", "!=", "\"", "\"", "{", "paramNames", "=", "append", "(", "paramNames", ",", "ixName", ")", "\n", "}", "else", "{", "for", "_", ",", "f", ":=", "range", "ixTpl", ".", "Fields", "{", "paramNames", "=", "append", "(", "paramNames", ",", "f", ".", "Name", ")", "\n", "}", "\n", "}", "\n\n", "// store resulting name back", "ixTpl", ".", "FuncName", "=", "funcName", "+", "strings", ".", "Join", "(", "paramNames", ",", "\"", "\"", ")", "\n", "}" ]

[ "BuildIndexFuncName", "builds", "the", "index", "func", "name", "for", "an", "index", "and", "its", "supplied", "fields", "." ]

[ "func", "reverseIndexRune", "(", "s", "string", ",", "r", "rune", ")", "int", "{", "if", "s", "==", "\"", "\"", "{", "return", "-", "1", "\n", "}", "\n\n", "rs", ":=", "[", "]", "rune", "(", "s", ")", "\n", "for", "i", ":=", "len", "(", "rs", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", "{", "if", "rs", "[", "i", "]", "==", "r", "{", "return", "i", "\n", "}", "\n", "}", "\n\n", "return", "-", "1", "\n", "}" ]

[ "reverseIndexRune", "finds", "the", "last", "rune", "r", "in", "s", "returning", "-", "1", "if", "not", "present", "." ]

[ "func", "SingularizeIdentifier", "(", "s", "string", ")", "string", "{", "if", "i", ":=", "reverseIndexRune", "(", "s", ",", "'_'", ")", ";", "i", "!=", "-", "1", "{", "s", "=", "s", "[", ":", "i", "]", "+", "\"", "\"", "+", "inflector", ".", "Singularize", "(", "s", "[", "i", "+", "1", ":", "]", ")", "\n", "}", "else", "{", "s", "=", "inflector", ".", "Singularize", "(", "s", ")", "\n", "}", "\n\n", "return", "snaker", ".", "SnakeToCamelIdentifier", "(", "s", ")", "\n", "}" ]

[ "SinguralizeIdentifier", "will", "singularize", "a", "identifier", "returning", "it", "in", "CamelCase", "." ]

[ "func", "SqParseType", "(", "args", "*", "internal", ".", "ArgType", ",", "dt", "string", ",", "nullable", "bool", ")", "(", "int", ",", "string", ",", "string", ")", "{", "precision", ":=", "0", "\n", "nilVal", ":=", "\"", "\"", "\n", "unsigned", ":=", "false", "\n\n", "dt", "=", "strings", ".", "ToLower", "(", "dt", ")", "\n\n", "// extract precision", "dt", ",", "precision", ",", "_", "=", "args", ".", "ParsePrecision", "(", "dt", ")", "\n\n", "if", "uRE", ".", "MatchString", "(", "dt", ")", "{", "unsigned", "=", "true", "\n", "uRE", ".", "ReplaceAllString", "(", "dt", ",", "\"", "\"", ")", "\n", "}", "\n\n", "var", "typ", "string", "\n", "switch", "dt", "{", "case", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "args", ".", "Int32Type", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "case", "\"", "\"", ":", "typ", "=", "\"", "\"", "\n\n", "case", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ":", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n\n", "default", ":", "// case \"varchar\", \"character\", \"varying character\", \"nchar\", \"native character\", \"nvarchar\", \"text\", \"clob\", \"datetime\", \"date\", \"time\":", "nilVal", "=", "`\"\"`", "\n", "typ", "=", "\"", "\"", "\n", "if", "nullable", "{", "nilVal", "=", "\"", "\"", "\n", "typ", "=", "\"", "\"", "\n", "}", "\n", "}", "\n\n", "// if unsigned ...", "if", "internal", ".", "IntRE", ".", "MatchString", "(", "typ", ")", "&&", "unsigned", "{", "typ", "=", "\"", "\"", "+", "typ", "\n", "}", "\n\n", "return", "precision", ",", "nilVal", ",", "typ", "\n", "}" ]

[ "SqParseType", "parse", "a", "sqlite", "type", "into", "a", "Go", "type", "based", "on", "the", "column", "definition", "." ]

[ "func", "SqTables", "(", "db", "models", ".", "XODB", ",", "schema", "string", ",", "relkind", "string", ")", "(", "[", "]", "*", "models", ".", "Table", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// get the tables", "rows", ",", "err", ":=", "models", ".", "SqTables", "(", "db", ",", "relkind", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// get the SQL for the Autoincrement detection", "autoIncrements", ",", "err", ":=", "models", ".", "SqAutoIncrements", "(", "db", ")", "\n", "if", "err", "!=", "nil", "{", "// Set it to an empty set on error.", "autoIncrements", "=", "[", "]", "*", "models", ".", "SqAutoIncrement", "{", "}", "\n", "}", "\n\n", "// Add information about manual FK.", "var", "tables", "[", "]", "*", "models", ".", "Table", "\n", "for", "_", ",", "row", ":=", "range", "rows", "{", "manualPk", ":=", "true", "\n", "// Look for a match in the table name where it contains the autoincrement", "// keyword for the given table in the SQL.", "for", "_", ",", "autoInc", ":=", "range", "autoIncrements", "{", "lSQL", ":=", "strings", ".", "ToLower", "(", "autoInc", ".", "SQL", ")", "\n", "if", "autoInc", ".", "TableName", "==", "row", ".", "TableName", "&&", "strings", ".", "Contains", "(", "lSQL", ",", "\"", "\"", ")", "{", "manualPk", "=", "false", "\n", "}", "else", "{", "cols", ",", "err", ":=", "SqTableColumns", "(", "db", ",", "schema", ",", "row", ".", "TableName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "for", "_", ",", "col", ":=", "range", "cols", "{", "if", "col", ".", "IsPrimaryKey", "==", "true", "{", "dt", ":=", "strings", ".", "ToUpper", "(", "col", ".", "DataType", ")", "\n", "if", "dt", "==", "\"", "\"", "{", "manualPk", "=", "false", "\n", "}", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "tables", "=", "append", "(", "tables", ",", "&", "models", ".", "Table", "{", "TableName", ":", "row", ".", "TableName", ",", "Type", ":", "row", ".", "Type", ",", "ManualPk", ":", "manualPk", ",", "}", ")", "\n", "}", "\n\n", "return", "tables", ",", "nil", "\n", "}" ]

[ "SqTables", "returns", "the", "sqlite", "tables", "with", "the", "manual", "PK", "information", "added", ".", "ManualPk", "is", "true", "when", "the", "table", "s", "primary", "key", "is", "not", "autoincrement", "." ]

[ "func", "SqTableColumns", "(", "db", "models", ".", "XODB", ",", "schema", "string", ",", "table", "string", ")", "(", "[", "]", "*", "models", ".", "Column", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// grab", "rows", ",", "err", ":=", "models", ".", "SqTableColumns", "(", "db", ",", "table", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// fix columns", "var", "cols", "[", "]", "*", "models", ".", "Column", "\n", "for", "_", ",", "row", ":=", "range", "rows", "{", "cols", "=", "append", "(", "cols", ",", "&", "models", ".", "Column", "{", "FieldOrdinal", ":", "row", ".", "FieldOrdinal", ",", "ColumnName", ":", "row", ".", "ColumnName", ",", "DataType", ":", "row", ".", "DataType", ",", "NotNull", ":", "row", ".", "NotNull", ",", "DefaultValue", ":", "row", ".", "DefaultValue", ",", "IsPrimaryKey", ":", "row", ".", "PkColIndex", "!=", "0", ",", "}", ")", "\n", "}", "\n\n", "return", "cols", ",", "nil", "\n", "}" ]

[ "SqTableColumns", "returns", "the", "sqlite", "table", "column", "info", "." ]

[ "func", "SqQueryColumns", "(", "args", "*", "internal", ".", "ArgType", ",", "inspect", "[", "]", "string", ")", "(", "[", "]", "*", "models", ".", "Column", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// create temporary view xoid", "xoid", ":=", "\"", "\"", "+", "internal", ".", "GenRandomID", "(", ")", "\n", "viewq", ":=", "`CREATE TEMPORARY VIEW `", "+", "xoid", "+", "` AS `", "+", "strings", ".", "Join", "(", "inspect", ",", "\"", "\\n", "\"", ")", "\n", "models", ".", "XOLog", "(", "viewq", ")", "\n", "_", ",", "err", "=", "args", ".", "DB", ".", "Exec", "(", "viewq", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// load column information", "return", "SqTableColumns", "(", "args", ".", "DB", ",", "\"", "\"", ",", "xoid", ")", "\n", "}" ]

[ "SqQueryColumns", "parses", "a", "sqlite", "query", "and", "generates", "a", "type", "for", "it", "." ]

[ "func", "AuthGroupPermissionByID", "(", "db", "XODB", ",", "id", "int", ")", "(", "*", "AuthGroupPermission", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, group_id, permission_id `", "+", "`FROM public.auth_group_permissions `", "+", "`WHERE id = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "id", ")", "\n", "agp", ":=", "AuthGroupPermission", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "id", ")", ".", "Scan", "(", "&", "agp", ".", "ID", ",", "&", "agp", ".", "GroupID", ",", "&", "agp", ".", "PermissionID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "agp", ",", "nil", "\n", "}" ]

[ "AuthGroupPermissionByID", "retrieves", "a", "row", "from", "public", ".", "auth_group_permissions", "as", "a", "AuthGroupPermission", ".", "Generated", "from", "index", "auth_group_permissions_pkey", "." ]

[ "func", "(", "ds", "*", "DjangoSession", ")", "Update", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "ds", ".", "_exists", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// if deleted, bail", "if", "ds", ".", "_deleted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`UPDATE public.django_session SET (`", "+", "`session_data, expire_date`", "+", "`) = ( `", "+", "`$1, $2`", "+", "`) WHERE session_key = $3`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "ds", ".", "SessionData", ",", "ds", ".", "ExpireDate", ",", "ds", ".", "SessionKey", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "ds", ".", "SessionData", ",", "ds", ".", "ExpireDate", ",", "ds", ".", "SessionKey", ")", "\n", "return", "err", "\n", "}" ]

[ "Update", "updates", "the", "DjangoSession", "in", "the", "database", "." ]

[ "func", "DjangoSessionsBySessionKey", "(", "db", "XODB", ",", "sessionKey", "string", ")", "(", "[", "]", "*", "DjangoSession", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`session_key, session_data, expire_date `", "+", "`FROM public.django_session `", "+", "`WHERE session_key = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "sessionKey", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "sessionKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "DjangoSession", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "ds", ":=", "DjangoSession", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "ds", ".", "SessionKey", ",", "&", "ds", ".", "SessionData", ",", "&", "ds", ".", "ExpireDate", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "ds", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "DjangoSessionsBySessionKey", "retrieves", "a", "row", "from", "public", ".", "django_session", "as", "a", "DjangoSession", ".", "Generated", "from", "index", "django_session_session_key_c0390e0f_like", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "TemplateLoader", "(", "name", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "// no template path specified", "if", "a", ".", "TemplatePath", "==", "\"", "\"", "{", "return", "templates", ".", "Asset", "(", "name", ")", "\n", "}", "\n\n", "return", "ioutil", ".", "ReadFile", "(", "path", ".", "Join", "(", "a", ".", "TemplatePath", ",", "name", ")", ")", "\n", "}" ]

[ "TemplateLoader", "loads", "templates", "from", "the", "specified", "name", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "TemplateSet", "(", ")", "*", "TemplateSet", "{", "if", "a", ".", "templateSet", "==", "nil", "{", "a", ".", "templateSet", "=", "&", "TemplateSet", "{", "funcs", ":", "a", ".", "NewTemplateFuncs", "(", ")", ",", "l", ":", "a", ".", "TemplateLoader", ",", "tpls", ":", "map", "[", "string", "]", "*", "template", ".", "Template", "{", "}", ",", "}", "\n", "}", "\n\n", "return", "a", ".", "templateSet", "\n", "}" ]

[ "TemplateSet", "retrieves", "the", "created", "template", "set", "." ]

[ "func", "(", "a", "*", "ArgType", ")", "ExecuteTemplate", "(", "tt", "TemplateType", ",", "name", "string", ",", "sub", "string", ",", "obj", "interface", "{", "}", ")", "error", "{", "var", "err", "error", "\n\n", "// setup generated", "if", "a", ".", "Generated", "==", "nil", "{", "a", ".", "Generated", "=", "[", "]", "TBuf", "{", "}", "\n", "}", "\n\n", "// create store", "v", ":=", "TBuf", "{", "TemplateType", ":", "tt", ",", "Name", ":", "name", ",", "Subname", ":", "sub", ",", "Buf", ":", "new", "(", "bytes", ".", "Buffer", ")", ",", "}", "\n\n", "// build template name", "loaderType", ":=", "\"", "\"", "\n", "if", "tt", "!=", "XOTemplate", "{", "if", "a", ".", "LoaderType", "==", "\"", "\"", "||", "a", ".", "LoaderType", "==", "\"", "\"", "{", "// force oracle for oci8 since the oracle driver doesn't recognize", "// 'oracle' as valid protocol", "loaderType", "=", "\"", "\"", "\n", "}", "else", "{", "loaderType", "=", "a", ".", "LoaderType", "+", "\"", "\"", "\n", "}", "\n", "}", "\n", "templateName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "loaderType", ",", "tt", ")", "\n\n", "// execute template", "err", "=", "a", ".", "TemplateSet", "(", ")", ".", "Execute", "(", "v", ".", "Buf", ",", "templateName", ",", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "a", ".", "Generated", "=", "append", "(", "a", ".", "Generated", ",", "v", ")", "\n", "return", "nil", "\n", "}" ]

[ "ExecuteTemplate", "loads", "and", "parses", "the", "supplied", "template", "with", "name", "and", "executes", "it", "with", "obj", "as", "the", "context", "." ]

[ "func", "(", "ts", "*", "TemplateSet", ")", "Execute", "(", "w", "io", ".", "Writer", ",", "name", "string", ",", "obj", "interface", "{", "}", ")", "error", "{", "tpl", ",", "ok", ":=", "ts", ".", "tpls", "[", "name", "]", "\n", "if", "!", "ok", "{", "// attempt to load and parse the template", "buf", ",", "err", ":=", "ts", ".", "l", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// parse template", "tpl", ",", "err", "=", "template", ".", "New", "(", "name", ")", ".", "Funcs", "(", "ts", ".", "funcs", ")", ".", "Parse", "(", "string", "(", "buf", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "tpl", ".", "Execute", "(", "w", ",", "obj", ")", "\n", "}" ]

[ "Execute", "executes", "a", "specified", "template", "in", "the", "template", "set", "using", "the", "supplied", "obj", "as", "its", "parameters", "and", "writing", "the", "output", "to", "w", "." ]

[ "func", "(", "aug", "*", "AuthUserGroup", ")", "Save", "(", "db", "XODB", ")", "error", "{", "if", "aug", ".", "Exists", "(", ")", "{", "return", "aug", ".", "Update", "(", "db", ")", "\n", "}", "\n\n", "return", "aug", ".", "Insert", "(", "db", ")", "\n", "}" ]

[ "Save", "saves", "the", "AuthUserGroup", "to", "the", "database", "." ]

[ "func", "AuthUserGroupByUserIDGroupID", "(", "db", "XODB", ",", "userID", "int", ",", "groupID", "int", ")", "(", "*", "AuthUserGroup", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, user_id, group_id `", "+", "`FROM auth_user_groups `", "+", "`WHERE user_id = ? AND group_id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "userID", ",", "groupID", ")", "\n", "aug", ":=", "AuthUserGroup", "{", "_exists", ":", "true", ",", "}", "\n\n", "err", "=", "db", ".", "QueryRow", "(", "sqlstr", ",", "userID", ",", "groupID", ")", ".", "Scan", "(", "&", "aug", ".", "ID", ",", "&", "aug", ".", "UserID", ",", "&", "aug", ".", "GroupID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "aug", ",", "nil", "\n", "}" ]

[ "AuthUserGroupByUserIDGroupID", "retrieves", "a", "row", "from", "auth_user_groups", "as", "a", "AuthUserGroup", ".", "Generated", "from", "index", "auth_user_groups_user_id_94350c0c_uniq", "." ]

[ "func", "(", "agp", "*", "AuthGroupPermission", ")", "Update", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "agp", ".", "_exists", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// if deleted, bail", "if", "agp", ".", "_deleted", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`UPDATE auth_group_permissions SET `", "+", "`group_id = ?, permission_id = ?`", "+", "` WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "agp", ".", "GroupID", ",", "agp", ".", "PermissionID", ",", "agp", ".", "ID", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "agp", ".", "GroupID", ",", "agp", ".", "PermissionID", ",", "agp", ".", "ID", ")", "\n", "return", "err", "\n", "}" ]

[ "Update", "updates", "the", "AuthGroupPermission", "in", "the", "database", "." ]

[ "func", "(", "agp", "*", "AuthGroupPermission", ")", "Delete", "(", "db", "XODB", ")", "error", "{", "var", "err", "error", "\n\n", "// if doesn't exist, bail", "if", "!", "agp", ".", "_exists", "{", "return", "nil", "\n", "}", "\n\n", "// if deleted, bail", "if", "agp", ".", "_deleted", "{", "return", "nil", "\n", "}", "\n\n", "// sql query", "const", "sqlstr", "=", "`DELETE FROM auth_group_permissions WHERE id = ?`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "agp", ".", "ID", ")", "\n", "_", ",", "err", "=", "db", ".", "Exec", "(", "sqlstr", ",", "agp", ".", "ID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// set deleted", "agp", ".", "_deleted", "=", "true", "\n\n", "return", "nil", "\n", "}" ]

[ "Delete", "deletes", "the", "AuthGroupPermission", "from", "the", "database", "." ]

[ "func", "AuthUsersByUsername", "(", "db", "XODB", ",", "username", "string", ")", "(", "[", "]", "*", "AuthUser", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// sql query", "const", "sqlstr", "=", "`SELECT `", "+", "`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined `", "+", "`FROM public.auth_user `", "+", "`WHERE username = $1`", "\n\n", "// run query", "XOLog", "(", "sqlstr", ",", "username", ")", "\n", "q", ",", "err", ":=", "db", ".", "Query", "(", "sqlstr", ",", "username", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "q", ".", "Close", "(", ")", "\n\n", "// load results", "res", ":=", "[", "]", "*", "AuthUser", "{", "}", "\n", "for", "q", ".", "Next", "(", ")", "{", "au", ":=", "AuthUser", "{", "_exists", ":", "true", ",", "}", "\n\n", "// scan", "err", "=", "q", ".", "Scan", "(", "&", "au", ".", "ID", ",", "&", "au", ".", "Password", ",", "&", "au", ".", "LastLogin", ",", "&", "au", ".", "IsSuperuser", ",", "&", "au", ".", "Username", ",", "&", "au", ".", "FirstName", ",", "&", "au", ".", "LastName", ",", "&", "au", ".", "Email", ",", "&", "au", ".", "IsStaff", ",", "&", "au", ".", "IsActive", ",", "&", "au", ".", "DateJoined", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "=", "append", "(", "res", ",", "&", "au", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "AuthUsersByUsername", "retrieves", "a", "row", "from", "public", ".", "auth_user", "as", "a", "AuthUser", ".", "Generated", "from", "index", "auth_user_username_6821ab7c_like", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "NthParam", "(", "i", "int", ")", "string", "{", "if", "tl", ".", "ParamN", "!=", "nil", "{", "return", "tl", ".", "ParamN", "(", "i", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", "+", "1", ")", "\n", "}" ]

[ "NthParam", "satisifies", "Loader", "s", "NthParam", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "Escape", "(", "typ", "EscType", ",", "s", "string", ")", "string", "{", "if", "e", ",", "ok", ":=", "tl", ".", "Esc", "[", "typ", "]", ";", "ok", "&&", "e", "!=", "nil", "{", "return", "e", "(", "s", ")", "\n", "}", "\n\n", "return", "`\"`", "+", "s", "+", "`\"`", "\n", "}" ]

[ "Escape", "escapes", "the", "provided", "identifier", "based", "on", "the", "EscType", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "Relkind", "(", "rt", "RelType", ")", "string", "{", "if", "tl", ".", "ProcessRelkind", "!=", "nil", "{", "return", "tl", ".", "ProcessRelkind", "(", "rt", ")", "\n", "}", "\n\n", "return", "rt", ".", "String", "(", ")", "\n", "}" ]

[ "Relkind", "satisfies", "Loader", "s", "Relkind", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "SchemaName", "(", "args", "*", "ArgType", ")", "(", "string", ",", "error", ")", "{", "if", "tl", ".", "Schema", "!=", "nil", "{", "return", "tl", ".", "Schema", "(", "args", ")", "\n", "}", "\n\n", "return", "\"", "\"", ",", "nil", "\n", "}" ]

[ "SchemaName", "returns", "the", "active", "schema", "name", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "LoadSchema", "(", "args", "*", "ArgType", ")", "error", "{", "var", "err", "error", "\n\n", "// load enums", "_", ",", "err", "=", "tl", ".", "LoadEnums", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// load procs", "_", ",", "err", "=", "tl", ".", "LoadProcs", "(", "args", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// load tables", "tableMap", ",", "err", ":=", "tl", ".", "LoadRelkind", "(", "args", ",", "Table", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// load views", "viewMap", ",", "err", ":=", "tl", ".", "LoadRelkind", "(", "args", ",", "View", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// merge views with the tableMap", "for", "k", ",", "v", ":=", "range", "viewMap", "{", "tableMap", "[", "k", "]", "=", "v", "\n", "}", "\n\n", "// load foreign keys", "_", ",", "err", "=", "tl", ".", "LoadForeignKeys", "(", "args", ",", "tableMap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// load indexes", "_", ",", "err", "=", "tl", ".", "LoadIndexes", "(", "args", ",", "tableMap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "LoadSchema", "loads", "schema", "definitions", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "LoadEnums", "(", "args", "*", "ArgType", ")", "(", "map", "[", "string", "]", "*", "Enum", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// not supplied, so bail", "if", "tl", ".", "EnumList", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// load enums", "enumList", ",", "err", ":=", "tl", ".", "EnumList", "(", "args", ".", "DB", ",", "args", ".", "Schema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// process enums", "enumMap", ":=", "map", "[", "string", "]", "*", "Enum", "{", "}", "\n", "for", "_", ",", "e", ":=", "range", "enumList", "{", "enumTpl", ":=", "&", "Enum", "{", "Name", ":", "SingularizeIdentifier", "(", "e", ".", "EnumName", ")", ",", "Schema", ":", "args", ".", "Schema", ",", "Values", ":", "[", "]", "*", "EnumValue", "{", "}", ",", "Enum", ":", "e", ",", "ReverseConstNames", ":", "args", ".", "UseReversedEnumConstNames", ",", "}", "\n\n", "err", "=", "tl", ".", "LoadEnumValues", "(", "args", ",", "enumTpl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "enumMap", "[", "enumTpl", ".", "Name", "]", "=", "enumTpl", "\n", "args", ".", "KnownTypeMap", "[", "enumTpl", ".", "Name", "]", "=", "true", "\n", "}", "\n\n", "// generate enum templates", "for", "_", ",", "e", ":=", "range", "enumMap", "{", "err", "=", "args", ".", "ExecuteTemplate", "(", "EnumTemplate", ",", "e", ".", "Name", ",", "\"", "\"", ",", "e", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "enumMap", ",", "nil", "\n", "}" ]

[ "LoadEnums", "loads", "schema", "enums", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "LoadEnumValues", "(", "args", "*", "ArgType", ",", "enumTpl", "*", "Enum", ")", "error", "{", "var", "err", "error", "\n\n", "// load enum values", "enumValues", ",", "err", ":=", "tl", ".", "EnumValueList", "(", "args", ".", "DB", ",", "args", ".", "Schema", ",", "enumTpl", ".", "Enum", ".", "EnumName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// process enum values", "for", "_", ",", "ev", ":=", "range", "enumValues", "{", "// chop off redundant enum name if applicable", "name", ":=", "snaker", ".", "SnakeToCamelIdentifier", "(", "ev", ".", "EnumValue", ")", "\n", "if", "strings", ".", "HasSuffix", "(", "strings", ".", "ToLower", "(", "name", ")", ",", "strings", ".", "ToLower", "(", "enumTpl", ".", "Name", ")", ")", "{", "n", ":=", "name", "[", ":", "len", "(", "name", ")", "-", "len", "(", "enumTpl", ".", "Name", ")", "]", "\n", "if", "len", "(", "n", ")", ">", "0", "{", "name", "=", "n", "\n", "}", "\n", "}", "\n\n", "enumTpl", ".", "Values", "=", "append", "(", "enumTpl", ".", "Values", ",", "&", "EnumValue", "{", "Name", ":", "name", ",", "Val", ":", "ev", ",", "}", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "LoadEnumValues", "loads", "schema", "enum", "values", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "LoadProcs", "(", "args", "*", "ArgType", ")", "(", "map", "[", "string", "]", "*", "Proc", ",", "error", ")", "{", "var", "err", "error", "\n\n", "// not supplied, so bail", "if", "tl", ".", "ProcList", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// load procs", "procList", ",", "err", ":=", "tl", ".", "ProcList", "(", "args", ".", "DB", ",", "args", ".", "Schema", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// process procs", "procMap", ":=", "map", "[", "string", "]", "*", "Proc", "{", "}", "\n", "for", "_", ",", "p", ":=", "range", "procList", "{", "// fix the name if it starts with one or more underscores", "name", ":=", "p", ".", "ProcName", "\n", "for", "strings", ".", "HasPrefix", "(", "name", ",", "\"", "\"", ")", "{", "name", "=", "name", "[", "1", ":", "]", "\n", "}", "\n\n", "// create template", "procTpl", ":=", "&", "Proc", "{", "Name", ":", "snaker", ".", "SnakeToCamelIdentifier", "(", "name", ")", ",", "Schema", ":", "args", ".", "Schema", ",", "Params", ":", "[", "]", "*", "Field", "{", "}", ",", "Return", ":", "&", "Field", "{", "}", ",", "Proc", ":", "p", ",", "}", "\n\n", "// parse return type into template", "// TODO: fix this so that nullable types can be returned", "_", ",", "procTpl", ".", "Return", ".", "NilType", ",", "procTpl", ".", "Return", ".", "Type", "=", "tl", ".", "ParseType", "(", "args", ",", "p", ".", "ReturnType", ",", "false", ")", "\n\n", "// load proc parameters", "err", "=", "tl", ".", "LoadProcParams", "(", "args", ",", "procTpl", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "procMap", "[", "p", ".", "ProcName", "]", "=", "procTpl", "\n", "}", "\n\n", "// generate proc templates", "for", "_", ",", "p", ":=", "range", "procMap", "{", "err", "=", "args", ".", "ExecuteTemplate", "(", "ProcTemplate", ",", "\"", "\"", "+", "p", ".", "Name", ",", "\"", "\"", ",", "p", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "procMap", ",", "nil", "\n", "}" ]

[ "LoadProcs", "loads", "schema", "stored", "procedures", "definitions", "." ]

[ "func", "(", "tl", "TypeLoader", ")", "LoadProcParams", "(", "args", "*", "ArgType", ",", "procTpl", "*", "Proc", ")", "error", "{", "var", "err", "error", "\n\n", "// load proc params", "paramList", ",", "err", ":=", "tl", ".", "ProcParamList", "(", "args", ".", "DB", ",", "args", ".", "Schema", ",", "procTpl", ".", "Proc", ".", "ProcName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// process params", "for", "i", ",", "p", ":=", "range", "paramList", "{", "// TODO: some databases support named parameters in procs (MySQL)", "paramTpl", ":=", "&", "Field", "{", "Name", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "i", ")", ",", "}", "\n\n", "// TODO: fix this so that nullable types can be used as parameters", "_", ",", "_", ",", "paramTpl", ".", "Type", "=", "tl", ".", "ParseType", "(", "args", ",", "strings", ".", "TrimSpace", "(", "p", ".", "ParamType", ")", ",", "false", ")", "\n\n", "// add to proc params", "if", "procTpl", ".", "ProcParams", "!=", "\"", "\"", "{", "procTpl", ".", "ProcParams", "=", "procTpl", ".", "ProcParams", "+", "\"", "\"", "\n", "}", "\n", "procTpl", ".", "ProcParams", "=", "procTpl", ".", "ProcParams", "+", "p", ".", "ParamType", "\n\n", "procTpl", ".", "Params", "=", "append", "(", "procTpl", ".", "Params", ",", "paramTpl", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "LoadProcParams", "loads", "schema", "stored", "procedure", "parameters", "." ]