repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
docker/libnetwork | sandbox.go | OptionIngress | func OptionIngress() SandboxOption {
return func(sb *sandbox) {
sb.ingress = true
sb.oslTypes = append(sb.oslTypes, osl.SandboxTypeIngress)
}
} | go | func OptionIngress() SandboxOption {
return func(sb *sandbox) {
sb.ingress = true
sb.oslTypes = append(sb.oslTypes, osl.SandboxTypeIngress)
}
} | [
"func",
"OptionIngress",
"(",
")",
"SandboxOption",
"{",
"return",
"func",
"(",
"sb",
"*",
"sandbox",
")",
"{",
"sb",
".",
"ingress",
"=",
"true",
"\n",
"sb",
".",
"oslTypes",
"=",
"append",
"(",
"sb",
".",
"oslTypes",
",",
"osl",
".",
"SandboxTypeIngress",
")",
"\n",
"}",
"\n",
"}"
] | // OptionIngress function returns an option setter for marking a
// sandbox as the controller's ingress sandbox. | [
"OptionIngress",
"function",
"returns",
"an",
"option",
"setter",
"for",
"marking",
"a",
"sandbox",
"as",
"the",
"controller",
"s",
"ingress",
"sandbox",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/sandbox.go#L1186-L1191 | train |
docker/libnetwork | sandbox.go | OptionLoadBalancer | func OptionLoadBalancer(nid string) SandboxOption {
return func(sb *sandbox) {
sb.loadBalancerNID = nid
sb.oslTypes = append(sb.oslTypes, osl.SandboxTypeLoadBalancer)
}
} | go | func OptionLoadBalancer(nid string) SandboxOption {
return func(sb *sandbox) {
sb.loadBalancerNID = nid
sb.oslTypes = append(sb.oslTypes, osl.SandboxTypeLoadBalancer)
}
} | [
"func",
"OptionLoadBalancer",
"(",
"nid",
"string",
")",
"SandboxOption",
"{",
"return",
"func",
"(",
"sb",
"*",
"sandbox",
")",
"{",
"sb",
".",
"loadBalancerNID",
"=",
"nid",
"\n",
"sb",
".",
"oslTypes",
"=",
"append",
"(",
"sb",
".",
"oslTypes",
",",
"osl",
".",
"SandboxTypeLoadBalancer",
")",
"\n",
"}",
"\n",
"}"
] | // OptionLoadBalancer function returns an option setter for marking a
// sandbox as a load balancer sandbox. | [
"OptionLoadBalancer",
"function",
"returns",
"an",
"option",
"setter",
"for",
"marking",
"a",
"sandbox",
"as",
"a",
"load",
"balancer",
"sandbox",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/sandbox.go#L1195-L1200 | train |
docker/libnetwork | ns/init_linux.go | Init | func Init() {
var err error
initNs, err = netns.Get()
if err != nil {
logrus.Errorf("could not get initial namespace: %v", err)
}
initNl, err = netlink.NewHandle(getSupportedNlFamilies()...)
if err != nil {
logrus.Errorf("could not create netlink handle on initial namespace: %v", err)
}
err = initNl.SetSocketTimeout(NetlinkSocketsTimeout)
if err != nil {
logrus.Warnf("Failed to set the timeout on the default netlink handle sockets: %v", err)
}
} | go | func Init() {
var err error
initNs, err = netns.Get()
if err != nil {
logrus.Errorf("could not get initial namespace: %v", err)
}
initNl, err = netlink.NewHandle(getSupportedNlFamilies()...)
if err != nil {
logrus.Errorf("could not create netlink handle on initial namespace: %v", err)
}
err = initNl.SetSocketTimeout(NetlinkSocketsTimeout)
if err != nil {
logrus.Warnf("Failed to set the timeout on the default netlink handle sockets: %v", err)
}
} | [
"func",
"Init",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"initNs",
",",
"err",
"=",
"netns",
".",
"Get",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"initNl",
",",
"err",
"=",
"netlink",
".",
"NewHandle",
"(",
"getSupportedNlFamilies",
"(",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"initNl",
".",
"SetSocketTimeout",
"(",
"NetlinkSocketsTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Init initializes a new network namespace | [
"Init",
"initializes",
"a",
"new",
"network",
"namespace"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ns/init_linux.go#L26-L40 | train |
docker/libnetwork | ns/init_linux.go | SetNamespace | func SetNamespace() error {
initOnce.Do(Init)
if err := netns.Set(initNs); err != nil {
linkInfo, linkErr := getLink()
if linkErr != nil {
linkInfo = linkErr.Error()
}
return fmt.Errorf("failed to set to initial namespace, %v, initns fd %d: %v", linkInfo, initNs, err)
}
return nil
} | go | func SetNamespace() error {
initOnce.Do(Init)
if err := netns.Set(initNs); err != nil {
linkInfo, linkErr := getLink()
if linkErr != nil {
linkInfo = linkErr.Error()
}
return fmt.Errorf("failed to set to initial namespace, %v, initns fd %d: %v", linkInfo, initNs, err)
}
return nil
} | [
"func",
"SetNamespace",
"(",
")",
"error",
"{",
"initOnce",
".",
"Do",
"(",
"Init",
")",
"\n",
"if",
"err",
":=",
"netns",
".",
"Set",
"(",
"initNs",
")",
";",
"err",
"!=",
"nil",
"{",
"linkInfo",
",",
"linkErr",
":=",
"getLink",
"(",
")",
"\n",
"if",
"linkErr",
"!=",
"nil",
"{",
"linkInfo",
"=",
"linkErr",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"linkInfo",
",",
"initNs",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // SetNamespace sets the initial namespace handler | [
"SetNamespace",
"sets",
"the",
"initial",
"namespace",
"handler"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ns/init_linux.go#L43-L53 | train |
docker/libnetwork | osl/route_linux.go | programRoute | func (n *networkNamespace) programRoute(path string, dest *net.IPNet, nh net.IP) error {
gwRoutes, err := n.nlHandle.RouteGet(nh)
if err != nil {
return fmt.Errorf("route for the next hop %s could not be found: %v", nh, err)
}
return n.nlHandle.RouteAdd(&netlink.Route{
Scope: netlink.SCOPE_UNIVERSE,
LinkIndex: gwRoutes[0].LinkIndex,
Gw: nh,
Dst: dest,
})
} | go | func (n *networkNamespace) programRoute(path string, dest *net.IPNet, nh net.IP) error {
gwRoutes, err := n.nlHandle.RouteGet(nh)
if err != nil {
return fmt.Errorf("route for the next hop %s could not be found: %v", nh, err)
}
return n.nlHandle.RouteAdd(&netlink.Route{
Scope: netlink.SCOPE_UNIVERSE,
LinkIndex: gwRoutes[0].LinkIndex,
Gw: nh,
Dst: dest,
})
} | [
"func",
"(",
"n",
"*",
"networkNamespace",
")",
"programRoute",
"(",
"path",
"string",
",",
"dest",
"*",
"net",
".",
"IPNet",
",",
"nh",
"net",
".",
"IP",
")",
"error",
"{",
"gwRoutes",
",",
"err",
":=",
"n",
".",
"nlHandle",
".",
"RouteGet",
"(",
"nh",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"nh",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"n",
".",
"nlHandle",
".",
"RouteAdd",
"(",
"&",
"netlink",
".",
"Route",
"{",
"Scope",
":",
"netlink",
".",
"SCOPE_UNIVERSE",
",",
"LinkIndex",
":",
"gwRoutes",
"[",
"0",
"]",
".",
"LinkIndex",
",",
"Gw",
":",
"nh",
",",
"Dst",
":",
"dest",
",",
"}",
")",
"\n",
"}"
] | // Program a route in to the namespace routing table. | [
"Program",
"a",
"route",
"in",
"to",
"the",
"namespace",
"routing",
"table",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/osl/route_linux.go#L114-L126 | train |
docker/libnetwork | cmd/proxy/sctp_proxy.go | NewSCTPProxy | func NewSCTPProxy(frontendAddr, backendAddr *sctp.SCTPAddr) (*SCTPProxy, error) {
listener, err := sctp.ListenSCTP("sctp", frontendAddr)
if err != nil {
return nil, err
}
// If the port in frontendAddr was 0 then ListenSCTP will have a picked
// a port to listen on, hence the call to Addr to get that actual port:
return &SCTPProxy{
listener: listener,
frontendAddr: listener.Addr().(*sctp.SCTPAddr),
backendAddr: backendAddr,
}, nil
} | go | func NewSCTPProxy(frontendAddr, backendAddr *sctp.SCTPAddr) (*SCTPProxy, error) {
listener, err := sctp.ListenSCTP("sctp", frontendAddr)
if err != nil {
return nil, err
}
// If the port in frontendAddr was 0 then ListenSCTP will have a picked
// a port to listen on, hence the call to Addr to get that actual port:
return &SCTPProxy{
listener: listener,
frontendAddr: listener.Addr().(*sctp.SCTPAddr),
backendAddr: backendAddr,
}, nil
} | [
"func",
"NewSCTPProxy",
"(",
"frontendAddr",
",",
"backendAddr",
"*",
"sctp",
".",
"SCTPAddr",
")",
"(",
"*",
"SCTPProxy",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"sctp",
".",
"ListenSCTP",
"(",
"\"",
"\"",
",",
"frontendAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// If the port in frontendAddr was 0 then ListenSCTP will have a picked",
"// a port to listen on, hence the call to Addr to get that actual port:",
"return",
"&",
"SCTPProxy",
"{",
"listener",
":",
"listener",
",",
"frontendAddr",
":",
"listener",
".",
"Addr",
"(",
")",
".",
"(",
"*",
"sctp",
".",
"SCTPAddr",
")",
",",
"backendAddr",
":",
"backendAddr",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewSCTPProxy creates a new SCTPProxy. | [
"NewSCTPProxy",
"creates",
"a",
"new",
"SCTPProxy",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/cmd/proxy/sctp_proxy.go#L21-L33 | train |
docker/libnetwork | cmd/proxy/sctp_proxy.go | Run | func (proxy *SCTPProxy) Run() {
quit := make(chan bool)
defer close(quit)
for {
client, err := proxy.listener.Accept()
if err != nil {
log.Printf("Stopping proxy on sctp/%v for sctp/%v (%s)", proxy.frontendAddr, proxy.backendAddr, err)
return
}
go proxy.clientLoop(client.(*sctp.SCTPConn), quit)
}
} | go | func (proxy *SCTPProxy) Run() {
quit := make(chan bool)
defer close(quit)
for {
client, err := proxy.listener.Accept()
if err != nil {
log.Printf("Stopping proxy on sctp/%v for sctp/%v (%s)", proxy.frontendAddr, proxy.backendAddr, err)
return
}
go proxy.clientLoop(client.(*sctp.SCTPConn), quit)
}
} | [
"func",
"(",
"proxy",
"*",
"SCTPProxy",
")",
"Run",
"(",
")",
"{",
"quit",
":=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"defer",
"close",
"(",
"quit",
")",
"\n",
"for",
"{",
"client",
",",
"err",
":=",
"proxy",
".",
"listener",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"proxy",
".",
"frontendAddr",
",",
"proxy",
".",
"backendAddr",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"go",
"proxy",
".",
"clientLoop",
"(",
"client",
".",
"(",
"*",
"sctp",
".",
"SCTPConn",
")",
",",
"quit",
")",
"\n",
"}",
"\n",
"}"
] | // Run starts forwarding the traffic using SCTP. | [
"Run",
"starts",
"forwarding",
"the",
"traffic",
"using",
"SCTP",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/cmd/proxy/sctp_proxy.go#L73-L84 | train |
docker/libnetwork | drivers/windows/port_mapping.go | AllocatePorts | func AllocatePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding, containerIP net.IP) ([]types.PortBinding, error) {
bs := make([]types.PortBinding, 0, len(bindings))
for _, c := range bindings {
b := c.GetCopy()
if err := allocatePort(portMapper, &b, containerIP); err != nil {
// On allocation failure, release previously allocated ports. On cleanup error, just log a warning message
if cuErr := ReleasePorts(portMapper, bs); cuErr != nil {
logrus.Warnf("Upon allocation failure for %v, failed to clear previously allocated port bindings: %v", b, cuErr)
}
return nil, err
}
bs = append(bs, b)
}
return bs, nil
} | go | func AllocatePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding, containerIP net.IP) ([]types.PortBinding, error) {
bs := make([]types.PortBinding, 0, len(bindings))
for _, c := range bindings {
b := c.GetCopy()
if err := allocatePort(portMapper, &b, containerIP); err != nil {
// On allocation failure, release previously allocated ports. On cleanup error, just log a warning message
if cuErr := ReleasePorts(portMapper, bs); cuErr != nil {
logrus.Warnf("Upon allocation failure for %v, failed to clear previously allocated port bindings: %v", b, cuErr)
}
return nil, err
}
bs = append(bs, b)
}
return bs, nil
} | [
"func",
"AllocatePorts",
"(",
"portMapper",
"*",
"portmapper",
".",
"PortMapper",
",",
"bindings",
"[",
"]",
"types",
".",
"PortBinding",
",",
"containerIP",
"net",
".",
"IP",
")",
"(",
"[",
"]",
"types",
".",
"PortBinding",
",",
"error",
")",
"{",
"bs",
":=",
"make",
"(",
"[",
"]",
"types",
".",
"PortBinding",
",",
"0",
",",
"len",
"(",
"bindings",
")",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"bindings",
"{",
"b",
":=",
"c",
".",
"GetCopy",
"(",
")",
"\n",
"if",
"err",
":=",
"allocatePort",
"(",
"portMapper",
",",
"&",
"b",
",",
"containerIP",
")",
";",
"err",
"!=",
"nil",
"{",
"// On allocation failure, release previously allocated ports. On cleanup error, just log a warning message",
"if",
"cuErr",
":=",
"ReleasePorts",
"(",
"portMapper",
",",
"bs",
")",
";",
"cuErr",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"",
"\"",
",",
"b",
",",
"cuErr",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"bs",
"=",
"append",
"(",
"bs",
",",
"b",
")",
"\n",
"}",
"\n",
"return",
"bs",
",",
"nil",
"\n",
"}"
] | // AllocatePorts allocates ports specified in bindings from the portMapper | [
"AllocatePorts",
"allocates",
"ports",
"specified",
"in",
"bindings",
"from",
"the",
"portMapper"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/drivers/windows/port_mapping.go#L29-L43 | train |
docker/libnetwork | drivers/windows/port_mapping.go | ReleasePorts | func ReleasePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding) error {
var errorBuf bytes.Buffer
// Attempt to release all port bindings, do not stop on failure
for _, m := range bindings {
if err := releasePort(portMapper, m); err != nil {
errorBuf.WriteString(fmt.Sprintf("\ncould not release %v because of %v", m, err))
}
}
if errorBuf.Len() != 0 {
return errors.New(errorBuf.String())
}
return nil
} | go | func ReleasePorts(portMapper *portmapper.PortMapper, bindings []types.PortBinding) error {
var errorBuf bytes.Buffer
// Attempt to release all port bindings, do not stop on failure
for _, m := range bindings {
if err := releasePort(portMapper, m); err != nil {
errorBuf.WriteString(fmt.Sprintf("\ncould not release %v because of %v", m, err))
}
}
if errorBuf.Len() != 0 {
return errors.New(errorBuf.String())
}
return nil
} | [
"func",
"ReleasePorts",
"(",
"portMapper",
"*",
"portmapper",
".",
"PortMapper",
",",
"bindings",
"[",
"]",
"types",
".",
"PortBinding",
")",
"error",
"{",
"var",
"errorBuf",
"bytes",
".",
"Buffer",
"\n\n",
"// Attempt to release all port bindings, do not stop on failure",
"for",
"_",
",",
"m",
":=",
"range",
"bindings",
"{",
"if",
"err",
":=",
"releasePort",
"(",
"portMapper",
",",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"errorBuf",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"m",
",",
"err",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"errorBuf",
".",
"Len",
"(",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"errorBuf",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ReleasePorts releases ports specified in bindings from the portMapper | [
"ReleasePorts",
"releases",
"ports",
"specified",
"in",
"bindings",
"from",
"the",
"portMapper"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/drivers/windows/port_mapping.go#L102-L116 | train |
docker/libnetwork | api/api.go | NewHTTPHandler | func NewHTTPHandler(c libnetwork.NetworkController) func(w http.ResponseWriter, req *http.Request) {
h := &httpHandler{c: c}
h.initRouter()
return h.handleRequest
} | go | func NewHTTPHandler(c libnetwork.NetworkController) func(w http.ResponseWriter, req *http.Request) {
h := &httpHandler{c: c}
h.initRouter()
return h.handleRequest
} | [
"func",
"NewHTTPHandler",
"(",
"c",
"libnetwork",
".",
"NetworkController",
")",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"h",
":=",
"&",
"httpHandler",
"{",
"c",
":",
"c",
"}",
"\n",
"h",
".",
"initRouter",
"(",
")",
"\n",
"return",
"h",
".",
"handleRequest",
"\n",
"}"
] | // NewHTTPHandler creates and initialize the HTTP handler to serve the requests for libnetwork | [
"NewHTTPHandler",
"creates",
"and",
"initialize",
"the",
"HTTP",
"handler",
"to",
"serve",
"the",
"requests",
"for",
"libnetwork"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/api/api.go#L60-L64 | train |
docker/libnetwork | networkdb/nodemgmt.go | findNode | func (nDB *NetworkDB) findNode(nodeName string) (*node, nodeState, map[string]*node) {
for i, nodes := range []map[string]*node{
nDB.nodes,
nDB.leftNodes,
nDB.failedNodes,
} {
if n, ok := nodes[nodeName]; ok {
return n, nodeState(i), nodes
}
}
return nil, nodeNotFound, nil
} | go | func (nDB *NetworkDB) findNode(nodeName string) (*node, nodeState, map[string]*node) {
for i, nodes := range []map[string]*node{
nDB.nodes,
nDB.leftNodes,
nDB.failedNodes,
} {
if n, ok := nodes[nodeName]; ok {
return n, nodeState(i), nodes
}
}
return nil, nodeNotFound, nil
} | [
"func",
"(",
"nDB",
"*",
"NetworkDB",
")",
"findNode",
"(",
"nodeName",
"string",
")",
"(",
"*",
"node",
",",
"nodeState",
",",
"map",
"[",
"string",
"]",
"*",
"node",
")",
"{",
"for",
"i",
",",
"nodes",
":=",
"range",
"[",
"]",
"map",
"[",
"string",
"]",
"*",
"node",
"{",
"nDB",
".",
"nodes",
",",
"nDB",
".",
"leftNodes",
",",
"nDB",
".",
"failedNodes",
",",
"}",
"{",
"if",
"n",
",",
"ok",
":=",
"nodes",
"[",
"nodeName",
"]",
";",
"ok",
"{",
"return",
"n",
",",
"nodeState",
"(",
"i",
")",
",",
"nodes",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nodeNotFound",
",",
"nil",
"\n",
"}"
] | // findNode search the node into the 3 node lists and returns the node pointer and the list
// where it got found | [
"findNode",
"search",
"the",
"node",
"into",
"the",
"3",
"node",
"lists",
"and",
"returns",
"the",
"node",
"pointer",
"and",
"the",
"list",
"where",
"it",
"got",
"found"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/networkdb/nodemgmt.go#L28-L39 | train |
docker/libnetwork | networkdb/nodemgmt.go | changeNodeState | func (nDB *NetworkDB) changeNodeState(nodeName string, newState nodeState) (bool, error) {
n, currState, m := nDB.findNode(nodeName)
if n == nil {
return false, fmt.Errorf("node %s not found", nodeName)
}
switch newState {
case nodeActiveState:
if currState == nodeActiveState {
return false, nil
}
delete(m, nodeName)
// reset the node reap time
n.reapTime = 0
nDB.nodes[nodeName] = n
case nodeLeftState:
if currState == nodeLeftState {
return false, nil
}
delete(m, nodeName)
nDB.leftNodes[nodeName] = n
case nodeFailedState:
if currState == nodeFailedState {
return false, nil
}
delete(m, nodeName)
nDB.failedNodes[nodeName] = n
}
logrus.Infof("Node %s change state %s --> %s", nodeName, nodeStateName[currState], nodeStateName[newState])
if newState == nodeLeftState || newState == nodeFailedState {
// set the node reap time, if not already set
// It is possible that a node passes from failed to left and the reaptime was already set so keep that value
if n.reapTime == 0 {
n.reapTime = nodeReapInterval
}
// The node leave or fails, delete all the entries created by it.
// If the node was temporary down, deleting the entries will guarantee that the CREATE events will be accepted
// If the node instead left because was going down, then it makes sense to just delete all its state
nDB.deleteNodeFromNetworks(n.Name)
nDB.deleteNodeTableEntries(n.Name)
}
return true, nil
} | go | func (nDB *NetworkDB) changeNodeState(nodeName string, newState nodeState) (bool, error) {
n, currState, m := nDB.findNode(nodeName)
if n == nil {
return false, fmt.Errorf("node %s not found", nodeName)
}
switch newState {
case nodeActiveState:
if currState == nodeActiveState {
return false, nil
}
delete(m, nodeName)
// reset the node reap time
n.reapTime = 0
nDB.nodes[nodeName] = n
case nodeLeftState:
if currState == nodeLeftState {
return false, nil
}
delete(m, nodeName)
nDB.leftNodes[nodeName] = n
case nodeFailedState:
if currState == nodeFailedState {
return false, nil
}
delete(m, nodeName)
nDB.failedNodes[nodeName] = n
}
logrus.Infof("Node %s change state %s --> %s", nodeName, nodeStateName[currState], nodeStateName[newState])
if newState == nodeLeftState || newState == nodeFailedState {
// set the node reap time, if not already set
// It is possible that a node passes from failed to left and the reaptime was already set so keep that value
if n.reapTime == 0 {
n.reapTime = nodeReapInterval
}
// The node leave or fails, delete all the entries created by it.
// If the node was temporary down, deleting the entries will guarantee that the CREATE events will be accepted
// If the node instead left because was going down, then it makes sense to just delete all its state
nDB.deleteNodeFromNetworks(n.Name)
nDB.deleteNodeTableEntries(n.Name)
}
return true, nil
} | [
"func",
"(",
"nDB",
"*",
"NetworkDB",
")",
"changeNodeState",
"(",
"nodeName",
"string",
",",
"newState",
"nodeState",
")",
"(",
"bool",
",",
"error",
")",
"{",
"n",
",",
"currState",
",",
"m",
":=",
"nDB",
".",
"findNode",
"(",
"nodeName",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"nodeName",
")",
"\n",
"}",
"\n\n",
"switch",
"newState",
"{",
"case",
"nodeActiveState",
":",
"if",
"currState",
"==",
"nodeActiveState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"// reset the node reap time",
"n",
".",
"reapTime",
"=",
"0",
"\n",
"nDB",
".",
"nodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"case",
"nodeLeftState",
":",
"if",
"currState",
"==",
"nodeLeftState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"nDB",
".",
"leftNodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"case",
"nodeFailedState",
":",
"if",
"currState",
"==",
"nodeFailedState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"nDB",
".",
"failedNodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"nodeName",
",",
"nodeStateName",
"[",
"currState",
"]",
",",
"nodeStateName",
"[",
"newState",
"]",
")",
"\n\n",
"if",
"newState",
"==",
"nodeLeftState",
"||",
"newState",
"==",
"nodeFailedState",
"{",
"// set the node reap time, if not already set",
"// It is possible that a node passes from failed to left and the reaptime was already set so keep that value",
"if",
"n",
".",
"reapTime",
"==",
"0",
"{",
"n",
".",
"reapTime",
"=",
"nodeReapInterval",
"\n",
"}",
"\n",
"// The node leave or fails, delete all the entries created by it.",
"// If the node was temporary down, deleting the entries will guarantee that the CREATE events will be accepted",
"// If the node instead left because was going down, then it makes sense to just delete all its state",
"nDB",
".",
"deleteNodeFromNetworks",
"(",
"n",
".",
"Name",
")",
"\n",
"nDB",
".",
"deleteNodeTableEntries",
"(",
"n",
".",
"Name",
")",
"\n",
"}",
"\n\n",
"return",
"true",
",",
"nil",
"\n",
"}"
] | // changeNodeState changes the state of the node specified, returns true if the node was moved,
// false if there was no need to change the node state. Error will be returned if the node does not
// exists | [
"changeNodeState",
"changes",
"the",
"state",
"of",
"the",
"node",
"specified",
"returns",
"true",
"if",
"the",
"node",
"was",
"moved",
"false",
"if",
"there",
"was",
"no",
"need",
"to",
"change",
"the",
"node",
"state",
".",
"Error",
"will",
"be",
"returned",
"if",
"the",
"node",
"does",
"not",
"exists"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/networkdb/nodemgmt.go#L44-L92 | train |
docker/libnetwork | networkdb/message.go | decodeCompoundMessage | func decodeCompoundMessage(buf []byte) ([][]byte, error) {
var cMsg CompoundMessage
if err := proto.Unmarshal(buf, &cMsg); err != nil {
return nil, err
}
parts := make([][]byte, 0, len(cMsg.Messages))
for _, m := range cMsg.Messages {
parts = append(parts, m.Payload)
}
return parts, nil
} | go | func decodeCompoundMessage(buf []byte) ([][]byte, error) {
var cMsg CompoundMessage
if err := proto.Unmarshal(buf, &cMsg); err != nil {
return nil, err
}
parts := make([][]byte, 0, len(cMsg.Messages))
for _, m := range cMsg.Messages {
parts = append(parts, m.Payload)
}
return parts, nil
} | [
"func",
"decodeCompoundMessage",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"cMsg",
"CompoundMessage",
"\n",
"if",
"err",
":=",
"proto",
".",
"Unmarshal",
"(",
"buf",
",",
"&",
"cMsg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"parts",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"cMsg",
".",
"Messages",
")",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"cMsg",
".",
"Messages",
"{",
"parts",
"=",
"append",
"(",
"parts",
",",
"m",
".",
"Payload",
")",
"\n",
"}",
"\n\n",
"return",
"parts",
",",
"nil",
"\n",
"}"
] | // decodeCompoundMessage splits a compound message and returns
// the slices of individual messages. Returns any potential error. | [
"decodeCompoundMessage",
"splits",
"a",
"compound",
"message",
"and",
"returns",
"the",
"slices",
"of",
"individual",
"messages",
".",
"Returns",
"any",
"potential",
"error",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/networkdb/message.go#L86-L98 | train |
docker/libnetwork | bitseq/sequence.go | NewHandle | func NewHandle(app string, ds datastore.DataStore, id string, numElements uint64) (*Handle, error) {
h := &Handle{
app: app,
id: id,
store: ds,
bits: numElements,
unselected: numElements,
head: &sequence{
block: 0x0,
count: getNumBlocks(numElements),
},
}
if h.store == nil {
return h, nil
}
// Get the initial status from the ds if present.
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return nil, err
}
// If the handle is not in store, write it.
if !h.Exists() {
if err := h.writeToStore(); err != nil {
return nil, fmt.Errorf("failed to write bitsequence to store: %v", err)
}
}
return h, nil
} | go | func NewHandle(app string, ds datastore.DataStore, id string, numElements uint64) (*Handle, error) {
h := &Handle{
app: app,
id: id,
store: ds,
bits: numElements,
unselected: numElements,
head: &sequence{
block: 0x0,
count: getNumBlocks(numElements),
},
}
if h.store == nil {
return h, nil
}
// Get the initial status from the ds if present.
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return nil, err
}
// If the handle is not in store, write it.
if !h.Exists() {
if err := h.writeToStore(); err != nil {
return nil, fmt.Errorf("failed to write bitsequence to store: %v", err)
}
}
return h, nil
} | [
"func",
"NewHandle",
"(",
"app",
"string",
",",
"ds",
"datastore",
".",
"DataStore",
",",
"id",
"string",
",",
"numElements",
"uint64",
")",
"(",
"*",
"Handle",
",",
"error",
")",
"{",
"h",
":=",
"&",
"Handle",
"{",
"app",
":",
"app",
",",
"id",
":",
"id",
",",
"store",
":",
"ds",
",",
"bits",
":",
"numElements",
",",
"unselected",
":",
"numElements",
",",
"head",
":",
"&",
"sequence",
"{",
"block",
":",
"0x0",
",",
"count",
":",
"getNumBlocks",
"(",
"numElements",
")",
",",
"}",
",",
"}",
"\n\n",
"if",
"h",
".",
"store",
"==",
"nil",
"{",
"return",
"h",
",",
"nil",
"\n",
"}",
"\n\n",
"// Get the initial status from the ds if present.",
"if",
"err",
":=",
"h",
".",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// If the handle is not in store, write it.",
"if",
"!",
"h",
".",
"Exists",
"(",
")",
"{",
"if",
"err",
":=",
"h",
".",
"writeToStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"h",
",",
"nil",
"\n",
"}"
] | // NewHandle returns a thread-safe instance of the bitmask handler | [
"NewHandle",
"returns",
"a",
"thread",
"-",
"safe",
"instance",
"of",
"the",
"bitmask",
"handler"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L50-L80 | train |
docker/libnetwork | bitseq/sequence.go | toString | func (s *sequence) toString() string {
var nextBlock string
if s.next == nil {
nextBlock = "end"
} else {
nextBlock = s.next.toString()
}
return fmt.Sprintf("(0x%x, %d)->%s", s.block, s.count, nextBlock)
} | go | func (s *sequence) toString() string {
var nextBlock string
if s.next == nil {
nextBlock = "end"
} else {
nextBlock = s.next.toString()
}
return fmt.Sprintf("(0x%x, %d)->%s", s.block, s.count, nextBlock)
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"toString",
"(",
")",
"string",
"{",
"var",
"nextBlock",
"string",
"\n",
"if",
"s",
".",
"next",
"==",
"nil",
"{",
"nextBlock",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"nextBlock",
"=",
"s",
".",
"next",
".",
"toString",
"(",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"block",
",",
"s",
".",
"count",
",",
"nextBlock",
")",
"\n",
"}"
] | // String returns a string representation of the block sequence starting from this block | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"block",
"sequence",
"starting",
"from",
"this",
"block"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L90-L98 | train |
docker/libnetwork | bitseq/sequence.go | getAvailableBit | func (s *sequence) getAvailableBit(from uint64) (uint64, uint64, error) {
if s.block == blockMAX || s.count == 0 {
return invalidPos, invalidPos, ErrNoBitAvailable
}
bits := from
bitSel := blockFirstBit >> from
for bitSel > 0 && s.block&bitSel != 0 {
bitSel >>= 1
bits++
}
// Check if the loop exited because it could not
// find any available bit int block starting from
// "from". Return invalid pos in that case.
if bitSel == 0 {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bits / 8, bits % 8, nil
} | go | func (s *sequence) getAvailableBit(from uint64) (uint64, uint64, error) {
if s.block == blockMAX || s.count == 0 {
return invalidPos, invalidPos, ErrNoBitAvailable
}
bits := from
bitSel := blockFirstBit >> from
for bitSel > 0 && s.block&bitSel != 0 {
bitSel >>= 1
bits++
}
// Check if the loop exited because it could not
// find any available bit int block starting from
// "from". Return invalid pos in that case.
if bitSel == 0 {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bits / 8, bits % 8, nil
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"getAvailableBit",
"(",
"from",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"if",
"s",
".",
"block",
"==",
"blockMAX",
"||",
"s",
".",
"count",
"==",
"0",
"{",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"bits",
":=",
"from",
"\n",
"bitSel",
":=",
"blockFirstBit",
">>",
"from",
"\n",
"for",
"bitSel",
">",
"0",
"&&",
"s",
".",
"block",
"&",
"bitSel",
"!=",
"0",
"{",
"bitSel",
">>=",
"1",
"\n",
"bits",
"++",
"\n",
"}",
"\n",
"// Check if the loop exited because it could not",
"// find any available bit int block starting from",
"// \"from\". Return invalid pos in that case.",
"if",
"bitSel",
"==",
"0",
"{",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"return",
"bits",
"/",
"8",
",",
"bits",
"%",
"8",
",",
"nil",
"\n",
"}"
] | // GetAvailableBit returns the position of the first unset bit in the bitmask represented by this sequence | [
"GetAvailableBit",
"returns",
"the",
"position",
"of",
"the",
"first",
"unset",
"bit",
"in",
"the",
"bitmask",
"represented",
"by",
"this",
"sequence"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L101-L118 | train |
docker/libnetwork | bitseq/sequence.go | getCopy | func (s *sequence) getCopy() *sequence {
n := &sequence{block: s.block, count: s.count}
pn := n
ps := s.next
for ps != nil {
pn.next = &sequence{block: ps.block, count: ps.count}
pn = pn.next
ps = ps.next
}
return n
} | go | func (s *sequence) getCopy() *sequence {
n := &sequence{block: s.block, count: s.count}
pn := n
ps := s.next
for ps != nil {
pn.next = &sequence{block: ps.block, count: ps.count}
pn = pn.next
ps = ps.next
}
return n
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"getCopy",
"(",
")",
"*",
"sequence",
"{",
"n",
":=",
"&",
"sequence",
"{",
"block",
":",
"s",
".",
"block",
",",
"count",
":",
"s",
".",
"count",
"}",
"\n",
"pn",
":=",
"n",
"\n",
"ps",
":=",
"s",
".",
"next",
"\n",
"for",
"ps",
"!=",
"nil",
"{",
"pn",
".",
"next",
"=",
"&",
"sequence",
"{",
"block",
":",
"ps",
".",
"block",
",",
"count",
":",
"ps",
".",
"count",
"}",
"\n",
"pn",
"=",
"pn",
".",
"next",
"\n",
"ps",
"=",
"ps",
".",
"next",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] | // GetCopy returns a copy of the linked list rooted at this node | [
"GetCopy",
"returns",
"a",
"copy",
"of",
"the",
"linked",
"list",
"rooted",
"at",
"this",
"node"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L121-L131 | train |
docker/libnetwork | bitseq/sequence.go | equal | func (s *sequence) equal(o *sequence) bool {
this := s
other := o
for this != nil {
if other == nil {
return false
}
if this.block != other.block || this.count != other.count {
return false
}
this = this.next
other = other.next
}
// Check if other is longer than this
if other != nil {
return false
}
return true
} | go | func (s *sequence) equal(o *sequence) bool {
this := s
other := o
for this != nil {
if other == nil {
return false
}
if this.block != other.block || this.count != other.count {
return false
}
this = this.next
other = other.next
}
// Check if other is longer than this
if other != nil {
return false
}
return true
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"equal",
"(",
"o",
"*",
"sequence",
")",
"bool",
"{",
"this",
":=",
"s",
"\n",
"other",
":=",
"o",
"\n",
"for",
"this",
"!=",
"nil",
"{",
"if",
"other",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"this",
".",
"block",
"!=",
"other",
".",
"block",
"||",
"this",
".",
"count",
"!=",
"other",
".",
"count",
"{",
"return",
"false",
"\n",
"}",
"\n",
"this",
"=",
"this",
".",
"next",
"\n",
"other",
"=",
"other",
".",
"next",
"\n",
"}",
"\n",
"// Check if other is longer than this",
"if",
"other",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // Equal checks if this sequence is equal to the passed one | [
"Equal",
"checks",
"if",
"this",
"sequence",
"is",
"equal",
"to",
"the",
"passed",
"one"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L134-L152 | train |
docker/libnetwork | bitseq/sequence.go | toByteArray | func (s *sequence) toByteArray() ([]byte, error) {
var bb []byte
p := s
for p != nil {
b := make([]byte, 12)
binary.BigEndian.PutUint32(b[0:], p.block)
binary.BigEndian.PutUint64(b[4:], p.count)
bb = append(bb, b...)
p = p.next
}
return bb, nil
} | go | func (s *sequence) toByteArray() ([]byte, error) {
var bb []byte
p := s
for p != nil {
b := make([]byte, 12)
binary.BigEndian.PutUint32(b[0:], p.block)
binary.BigEndian.PutUint64(b[4:], p.count)
bb = append(bb, b...)
p = p.next
}
return bb, nil
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"toByteArray",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"bb",
"[",
"]",
"byte",
"\n\n",
"p",
":=",
"s",
"\n",
"for",
"p",
"!=",
"nil",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"12",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint32",
"(",
"b",
"[",
"0",
":",
"]",
",",
"p",
".",
"block",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"b",
"[",
"4",
":",
"]",
",",
"p",
".",
"count",
")",
"\n",
"bb",
"=",
"append",
"(",
"bb",
",",
"b",
"...",
")",
"\n",
"p",
"=",
"p",
".",
"next",
"\n",
"}",
"\n\n",
"return",
"bb",
",",
"nil",
"\n",
"}"
] | // ToByteArray converts the sequence into a byte array | [
"ToByteArray",
"converts",
"the",
"sequence",
"into",
"a",
"byte",
"array"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L155-L168 | train |
docker/libnetwork | bitseq/sequence.go | fromByteArray | func (s *sequence) fromByteArray(data []byte) error {
l := len(data)
if l%12 != 0 {
return fmt.Errorf("cannot deserialize byte sequence of length %d (%v)", l, data)
}
p := s
i := 0
for {
p.block = binary.BigEndian.Uint32(data[i : i+4])
p.count = binary.BigEndian.Uint64(data[i+4 : i+12])
i += 12
if i == l {
break
}
p.next = &sequence{}
p = p.next
}
return nil
} | go | func (s *sequence) fromByteArray(data []byte) error {
l := len(data)
if l%12 != 0 {
return fmt.Errorf("cannot deserialize byte sequence of length %d (%v)", l, data)
}
p := s
i := 0
for {
p.block = binary.BigEndian.Uint32(data[i : i+4])
p.count = binary.BigEndian.Uint64(data[i+4 : i+12])
i += 12
if i == l {
break
}
p.next = &sequence{}
p = p.next
}
return nil
} | [
"func",
"(",
"s",
"*",
"sequence",
")",
"fromByteArray",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"l",
":=",
"len",
"(",
"data",
")",
"\n",
"if",
"l",
"%",
"12",
"!=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
",",
"data",
")",
"\n",
"}",
"\n\n",
"p",
":=",
"s",
"\n",
"i",
":=",
"0",
"\n",
"for",
"{",
"p",
".",
"block",
"=",
"binary",
".",
"BigEndian",
".",
"Uint32",
"(",
"data",
"[",
"i",
":",
"i",
"+",
"4",
"]",
")",
"\n",
"p",
".",
"count",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"data",
"[",
"i",
"+",
"4",
":",
"i",
"+",
"12",
"]",
")",
"\n",
"i",
"+=",
"12",
"\n",
"if",
"i",
"==",
"l",
"{",
"break",
"\n",
"}",
"\n",
"p",
".",
"next",
"=",
"&",
"sequence",
"{",
"}",
"\n",
"p",
"=",
"p",
".",
"next",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // fromByteArray construct the sequence from the byte array | [
"fromByteArray",
"construct",
"the",
"sequence",
"from",
"the",
"byte",
"array"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L171-L191 | train |
docker/libnetwork | bitseq/sequence.go | SetAnyInRange | func (h *Handle) SetAnyInRange(start, end uint64, serial bool) (uint64, error) {
if end < start || end >= h.bits {
return invalidPos, fmt.Errorf("invalid bit range [%d, %d]", start, end)
}
if h.Unselected() == 0 {
return invalidPos, ErrNoBitAvailable
}
return h.set(0, start, end, true, false, serial)
} | go | func (h *Handle) SetAnyInRange(start, end uint64, serial bool) (uint64, error) {
if end < start || end >= h.bits {
return invalidPos, fmt.Errorf("invalid bit range [%d, %d]", start, end)
}
if h.Unselected() == 0 {
return invalidPos, ErrNoBitAvailable
}
return h.set(0, start, end, true, false, serial)
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"SetAnyInRange",
"(",
"start",
",",
"end",
"uint64",
",",
"serial",
"bool",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"end",
"<",
"start",
"||",
"end",
">=",
"h",
".",
"bits",
"{",
"return",
"invalidPos",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"start",
",",
"end",
")",
"\n",
"}",
"\n",
"if",
"h",
".",
"Unselected",
"(",
")",
"==",
"0",
"{",
"return",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"return",
"h",
".",
"set",
"(",
"0",
",",
"start",
",",
"end",
",",
"true",
",",
"false",
",",
"serial",
")",
"\n",
"}"
] | // SetAnyInRange atomically sets the first unset bit in the specified range in the sequence and returns the corresponding ordinal | [
"SetAnyInRange",
"atomically",
"sets",
"the",
"first",
"unset",
"bit",
"in",
"the",
"specified",
"range",
"in",
"the",
"sequence",
"and",
"returns",
"the",
"corresponding",
"ordinal"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L208-L216 | train |
docker/libnetwork | bitseq/sequence.go | SetAny | func (h *Handle) SetAny(serial bool) (uint64, error) {
if h.Unselected() == 0 {
return invalidPos, ErrNoBitAvailable
}
return h.set(0, 0, h.bits-1, true, false, serial)
} | go | func (h *Handle) SetAny(serial bool) (uint64, error) {
if h.Unselected() == 0 {
return invalidPos, ErrNoBitAvailable
}
return h.set(0, 0, h.bits-1, true, false, serial)
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"SetAny",
"(",
"serial",
"bool",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"h",
".",
"Unselected",
"(",
")",
"==",
"0",
"{",
"return",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"return",
"h",
".",
"set",
"(",
"0",
",",
"0",
",",
"h",
".",
"bits",
"-",
"1",
",",
"true",
",",
"false",
",",
"serial",
")",
"\n",
"}"
] | // SetAny atomically sets the first unset bit in the sequence and returns the corresponding ordinal | [
"SetAny",
"atomically",
"sets",
"the",
"first",
"unset",
"bit",
"in",
"the",
"sequence",
"and",
"returns",
"the",
"corresponding",
"ordinal"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L219-L224 | train |
docker/libnetwork | bitseq/sequence.go | Set | func (h *Handle) Set(ordinal uint64) error {
if err := h.validateOrdinal(ordinal); err != nil {
return err
}
_, err := h.set(ordinal, 0, 0, false, false, false)
return err
} | go | func (h *Handle) Set(ordinal uint64) error {
if err := h.validateOrdinal(ordinal); err != nil {
return err
}
_, err := h.set(ordinal, 0, 0, false, false, false)
return err
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"Set",
"(",
"ordinal",
"uint64",
")",
"error",
"{",
"if",
"err",
":=",
"h",
".",
"validateOrdinal",
"(",
"ordinal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"h",
".",
"set",
"(",
"ordinal",
",",
"0",
",",
"0",
",",
"false",
",",
"false",
",",
"false",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Set atomically sets the corresponding bit in the sequence | [
"Set",
"atomically",
"sets",
"the",
"corresponding",
"bit",
"in",
"the",
"sequence"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L227-L233 | train |
docker/libnetwork | bitseq/sequence.go | Unset | func (h *Handle) Unset(ordinal uint64) error {
if err := h.validateOrdinal(ordinal); err != nil {
return err
}
_, err := h.set(ordinal, 0, 0, false, true, false)
return err
} | go | func (h *Handle) Unset(ordinal uint64) error {
if err := h.validateOrdinal(ordinal); err != nil {
return err
}
_, err := h.set(ordinal, 0, 0, false, true, false)
return err
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"Unset",
"(",
"ordinal",
"uint64",
")",
"error",
"{",
"if",
"err",
":=",
"h",
".",
"validateOrdinal",
"(",
"ordinal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"h",
".",
"set",
"(",
"ordinal",
",",
"0",
",",
"0",
",",
"false",
",",
"true",
",",
"false",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Unset atomically unsets the corresponding bit in the sequence | [
"Unset",
"atomically",
"unsets",
"the",
"corresponding",
"bit",
"in",
"the",
"sequence"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L236-L242 | train |
docker/libnetwork | bitseq/sequence.go | IsSet | func (h *Handle) IsSet(ordinal uint64) bool {
if err := h.validateOrdinal(ordinal); err != nil {
return false
}
h.Lock()
_, _, err := checkIfAvailable(h.head, ordinal)
h.Unlock()
return err != nil
} | go | func (h *Handle) IsSet(ordinal uint64) bool {
if err := h.validateOrdinal(ordinal); err != nil {
return false
}
h.Lock()
_, _, err := checkIfAvailable(h.head, ordinal)
h.Unlock()
return err != nil
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"IsSet",
"(",
"ordinal",
"uint64",
")",
"bool",
"{",
"if",
"err",
":=",
"h",
".",
"validateOrdinal",
"(",
"ordinal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"_",
",",
"_",
",",
"err",
":=",
"checkIfAvailable",
"(",
"h",
".",
"head",
",",
"ordinal",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n",
"return",
"err",
"!=",
"nil",
"\n",
"}"
] | // IsSet atomically checks if the ordinal bit is set. In case ordinal
// is outside of the bit sequence limits, false is returned. | [
"IsSet",
"atomically",
"checks",
"if",
"the",
"ordinal",
"bit",
"is",
"set",
".",
"In",
"case",
"ordinal",
"is",
"outside",
"of",
"the",
"bit",
"sequence",
"limits",
"false",
"is",
"returned",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L246-L254 | train |
docker/libnetwork | bitseq/sequence.go | CheckConsistency | func (h *Handle) CheckConsistency() error {
for {
h.Lock()
store := h.store
h.Unlock()
if store != nil {
if err := store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return err
}
}
h.Lock()
nh := h.getCopy()
h.Unlock()
if !nh.runConsistencyCheck() {
return nil
}
if err := nh.writeToStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while fixing inconsistent bitsequence: %v", err)
}
continue
}
logrus.Infof("Fixed inconsistent bit sequence in datastore:\n%s\n%s", h, nh)
h.Lock()
h.head = nh.head
h.Unlock()
return nil
}
} | go | func (h *Handle) CheckConsistency() error {
for {
h.Lock()
store := h.store
h.Unlock()
if store != nil {
if err := store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return err
}
}
h.Lock()
nh := h.getCopy()
h.Unlock()
if !nh.runConsistencyCheck() {
return nil
}
if err := nh.writeToStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while fixing inconsistent bitsequence: %v", err)
}
continue
}
logrus.Infof("Fixed inconsistent bit sequence in datastore:\n%s\n%s", h, nh)
h.Lock()
h.head = nh.head
h.Unlock()
return nil
}
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"CheckConsistency",
"(",
")",
"error",
"{",
"for",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"store",
":=",
"h",
".",
"store",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"store",
"!=",
"nil",
"{",
"if",
"err",
":=",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"nh",
":=",
"h",
".",
"getCopy",
"(",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"!",
"nh",
".",
"runConsistencyCheck",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"nh",
".",
"writeToStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"types",
".",
"RetryError",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"h",
",",
"nh",
")",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"head",
"=",
"nh",
".",
"head",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // CheckConsistency checks if the bit sequence is in an inconsistent state and attempts to fix it.
// It looks for a corruption signature that may happen in docker 1.9.0 and 1.9.1. | [
"CheckConsistency",
"checks",
"if",
"the",
"bit",
"sequence",
"is",
"in",
"an",
"inconsistent",
"state",
"and",
"attempts",
"to",
"fix",
"it",
".",
"It",
"looks",
"for",
"a",
"corruption",
"signature",
"that",
"may",
"happen",
"in",
"docker",
"1",
".",
"9",
".",
"0",
"and",
"1",
".",
"9",
".",
"1",
"."
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L271-L306 | train |
docker/libnetwork | bitseq/sequence.go | validateOrdinal | func (h *Handle) validateOrdinal(ordinal uint64) error {
h.Lock()
defer h.Unlock()
if ordinal >= h.bits {
return errors.New("bit does not belong to the sequence")
}
return nil
} | go | func (h *Handle) validateOrdinal(ordinal uint64) error {
h.Lock()
defer h.Unlock()
if ordinal >= h.bits {
return errors.New("bit does not belong to the sequence")
}
return nil
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"validateOrdinal",
"(",
"ordinal",
"uint64",
")",
"error",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"defer",
"h",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ordinal",
">=",
"h",
".",
"bits",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // checks is needed because to cover the case where the number of bits is not a multiple of blockLen | [
"checks",
"is",
"needed",
"because",
"to",
"cover",
"the",
"case",
"where",
"the",
"number",
"of",
"bits",
"is",
"not",
"a",
"multiple",
"of",
"blockLen"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L386-L393 | train |
docker/libnetwork | bitseq/sequence.go | Destroy | func (h *Handle) Destroy() error {
for {
if err := h.deleteFromStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while destroying the sequence: %v", err)
}
// Fetch latest
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil {
if err == datastore.ErrKeyNotFound { // already removed
return nil
}
return fmt.Errorf("failed to fetch from store when destroying the sequence: %v", err)
}
continue
}
return nil
}
} | go | func (h *Handle) Destroy() error {
for {
if err := h.deleteFromStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while destroying the sequence: %v", err)
}
// Fetch latest
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil {
if err == datastore.ErrKeyNotFound { // already removed
return nil
}
return fmt.Errorf("failed to fetch from store when destroying the sequence: %v", err)
}
continue
}
return nil
}
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"Destroy",
"(",
")",
"error",
"{",
"for",
"{",
"if",
"err",
":=",
"h",
".",
"deleteFromStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"types",
".",
"RetryError",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// Fetch latest",
"if",
"err",
":=",
"h",
".",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"datastore",
".",
"ErrKeyNotFound",
"{",
"// already removed",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Destroy removes from the datastore the data belonging to this handle | [
"Destroy",
"removes",
"from",
"the",
"datastore",
"the",
"data",
"belonging",
"to",
"this",
"handle"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L396-L413 | train |
docker/libnetwork | bitseq/sequence.go | ToByteArray | func (h *Handle) ToByteArray() ([]byte, error) {
h.Lock()
defer h.Unlock()
ba := make([]byte, 16)
binary.BigEndian.PutUint64(ba[0:], h.bits)
binary.BigEndian.PutUint64(ba[8:], h.unselected)
bm, err := h.head.toByteArray()
if err != nil {
return nil, fmt.Errorf("failed to serialize head: %s", err.Error())
}
ba = append(ba, bm...)
return ba, nil
} | go | func (h *Handle) ToByteArray() ([]byte, error) {
h.Lock()
defer h.Unlock()
ba := make([]byte, 16)
binary.BigEndian.PutUint64(ba[0:], h.bits)
binary.BigEndian.PutUint64(ba[8:], h.unselected)
bm, err := h.head.toByteArray()
if err != nil {
return nil, fmt.Errorf("failed to serialize head: %s", err.Error())
}
ba = append(ba, bm...)
return ba, nil
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"ToByteArray",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"defer",
"h",
".",
"Unlock",
"(",
")",
"\n",
"ba",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"16",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"ba",
"[",
"0",
":",
"]",
",",
"h",
".",
"bits",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"ba",
"[",
"8",
":",
"]",
",",
"h",
".",
"unselected",
")",
"\n",
"bm",
",",
"err",
":=",
"h",
".",
"head",
".",
"toByteArray",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"ba",
"=",
"append",
"(",
"ba",
",",
"bm",
"...",
")",
"\n\n",
"return",
"ba",
",",
"nil",
"\n",
"}"
] | // ToByteArray converts this handle's data into a byte array | [
"ToByteArray",
"converts",
"this",
"handle",
"s",
"data",
"into",
"a",
"byte",
"array"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L416-L430 | train |
docker/libnetwork | bitseq/sequence.go | FromByteArray | func (h *Handle) FromByteArray(ba []byte) error {
if ba == nil {
return errors.New("nil byte array")
}
nh := &sequence{}
err := nh.fromByteArray(ba[16:])
if err != nil {
return fmt.Errorf("failed to deserialize head: %s", err.Error())
}
h.Lock()
h.head = nh
h.bits = binary.BigEndian.Uint64(ba[0:8])
h.unselected = binary.BigEndian.Uint64(ba[8:16])
h.Unlock()
return nil
} | go | func (h *Handle) FromByteArray(ba []byte) error {
if ba == nil {
return errors.New("nil byte array")
}
nh := &sequence{}
err := nh.fromByteArray(ba[16:])
if err != nil {
return fmt.Errorf("failed to deserialize head: %s", err.Error())
}
h.Lock()
h.head = nh
h.bits = binary.BigEndian.Uint64(ba[0:8])
h.unselected = binary.BigEndian.Uint64(ba[8:16])
h.Unlock()
return nil
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"FromByteArray",
"(",
"ba",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"ba",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"nh",
":=",
"&",
"sequence",
"{",
"}",
"\n",
"err",
":=",
"nh",
".",
"fromByteArray",
"(",
"ba",
"[",
"16",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"head",
"=",
"nh",
"\n",
"h",
".",
"bits",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"ba",
"[",
"0",
":",
"8",
"]",
")",
"\n",
"h",
".",
"unselected",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"ba",
"[",
"8",
":",
"16",
"]",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // FromByteArray reads his handle's data from a byte array | [
"FromByteArray",
"reads",
"his",
"handle",
"s",
"data",
"from",
"a",
"byte",
"array"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L433-L451 | train |
docker/libnetwork | bitseq/sequence.go | Unselected | func (h *Handle) Unselected() uint64 {
h.Lock()
defer h.Unlock()
return h.unselected
} | go | func (h *Handle) Unselected() uint64 {
h.Lock()
defer h.Unlock()
return h.unselected
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"Unselected",
"(",
")",
"uint64",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"defer",
"h",
".",
"Unlock",
"(",
")",
"\n",
"return",
"h",
".",
"unselected",
"\n",
"}"
] | // Unselected returns the number of bits which are not selected | [
"Unselected",
"returns",
"the",
"number",
"of",
"bits",
"which",
"are",
"not",
"selected"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L459-L463 | train |
docker/libnetwork | bitseq/sequence.go | MarshalJSON | func (h *Handle) MarshalJSON() ([]byte, error) {
m := map[string]interface{}{
"id": h.id,
}
b, err := h.ToByteArray()
if err != nil {
return nil, err
}
m["sequence"] = b
return json.Marshal(m)
} | go | func (h *Handle) MarshalJSON() ([]byte, error) {
m := map[string]interface{}{
"id": h.id,
}
b, err := h.ToByteArray()
if err != nil {
return nil, err
}
m["sequence"] = b
return json.Marshal(m)
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"h",
".",
"id",
",",
"}",
"\n\n",
"b",
",",
"err",
":=",
"h",
".",
"ToByteArray",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"b",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"m",
")",
"\n",
"}"
] | // MarshalJSON encodes Handle into json message | [
"MarshalJSON",
"encodes",
"Handle",
"into",
"json",
"message"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L473-L484 | train |
docker/libnetwork | bitseq/sequence.go | UnmarshalJSON | func (h *Handle) UnmarshalJSON(data []byte) error {
var (
m map[string]interface{}
b []byte
err error
)
if err = json.Unmarshal(data, &m); err != nil {
return err
}
h.id = m["id"].(string)
bi, _ := json.Marshal(m["sequence"])
if err := json.Unmarshal(bi, &b); err != nil {
return err
}
return h.FromByteArray(b)
} | go | func (h *Handle) UnmarshalJSON(data []byte) error {
var (
m map[string]interface{}
b []byte
err error
)
if err = json.Unmarshal(data, &m); err != nil {
return err
}
h.id = m["id"].(string)
bi, _ := json.Marshal(m["sequence"])
if err := json.Unmarshal(bi, &b); err != nil {
return err
}
return h.FromByteArray(b)
} | [
"func",
"(",
"h",
"*",
"Handle",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"b",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
")",
"\n",
"if",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"h",
".",
"id",
"=",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"bi",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"m",
"[",
"\"",
"\"",
"]",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bi",
",",
"&",
"b",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"h",
".",
"FromByteArray",
"(",
"b",
")",
"\n",
"}"
] | // UnmarshalJSON decodes json message into Handle | [
"UnmarshalJSON",
"decodes",
"json",
"message",
"into",
"Handle"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L487-L502 | train |
docker/libnetwork | bitseq/sequence.go | getFirstAvailable | func getFirstAvailable(head *sequence, start uint64) (uint64, uint64, error) {
// Find sequence which contains the start bit
byteStart, bitStart := ordinalToPos(start)
current, _, precBlocks, inBlockBytePos := findSequence(head, byteStart)
// Derive the this sequence offsets
byteOffset := byteStart - inBlockBytePos
bitOffset := inBlockBytePos*8 + bitStart
for current != nil {
if current.block != blockMAX {
// If the current block is not full, check if there is any bit
// from the current bit in the current block. If not, before proceeding to the
// next block node, make sure we check for available bit in the next
// instance of the same block. Due to RLE same block signature will be
// compressed.
retry:
bytePos, bitPos, err := current.getAvailableBit(bitOffset)
if err != nil && precBlocks == current.count-1 {
// This is the last instance in the same block node,
// so move to the next block.
goto next
}
if err != nil {
// There are some more instances of the same block, so add the offset
// and be optimistic that you will find the available bit in the next
// instance of the same block.
bitOffset = 0
byteOffset += blockBytes
precBlocks++
goto retry
}
return byteOffset + bytePos, bitPos, err
}
// Moving to next block: Reset bit offset.
next:
bitOffset = 0
byteOffset += (current.count * blockBytes) - (precBlocks * blockBytes)
precBlocks = 0
current = current.next
}
return invalidPos, invalidPos, ErrNoBitAvailable
} | go | func getFirstAvailable(head *sequence, start uint64) (uint64, uint64, error) {
// Find sequence which contains the start bit
byteStart, bitStart := ordinalToPos(start)
current, _, precBlocks, inBlockBytePos := findSequence(head, byteStart)
// Derive the this sequence offsets
byteOffset := byteStart - inBlockBytePos
bitOffset := inBlockBytePos*8 + bitStart
for current != nil {
if current.block != blockMAX {
// If the current block is not full, check if there is any bit
// from the current bit in the current block. If not, before proceeding to the
// next block node, make sure we check for available bit in the next
// instance of the same block. Due to RLE same block signature will be
// compressed.
retry:
bytePos, bitPos, err := current.getAvailableBit(bitOffset)
if err != nil && precBlocks == current.count-1 {
// This is the last instance in the same block node,
// so move to the next block.
goto next
}
if err != nil {
// There are some more instances of the same block, so add the offset
// and be optimistic that you will find the available bit in the next
// instance of the same block.
bitOffset = 0
byteOffset += blockBytes
precBlocks++
goto retry
}
return byteOffset + bytePos, bitPos, err
}
// Moving to next block: Reset bit offset.
next:
bitOffset = 0
byteOffset += (current.count * blockBytes) - (precBlocks * blockBytes)
precBlocks = 0
current = current.next
}
return invalidPos, invalidPos, ErrNoBitAvailable
} | [
"func",
"getFirstAvailable",
"(",
"head",
"*",
"sequence",
",",
"start",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"// Find sequence which contains the start bit",
"byteStart",
",",
"bitStart",
":=",
"ordinalToPos",
"(",
"start",
")",
"\n",
"current",
",",
"_",
",",
"precBlocks",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"byteStart",
")",
"\n",
"// Derive the this sequence offsets",
"byteOffset",
":=",
"byteStart",
"-",
"inBlockBytePos",
"\n",
"bitOffset",
":=",
"inBlockBytePos",
"*",
"8",
"+",
"bitStart",
"\n",
"for",
"current",
"!=",
"nil",
"{",
"if",
"current",
".",
"block",
"!=",
"blockMAX",
"{",
"// If the current block is not full, check if there is any bit",
"// from the current bit in the current block. If not, before proceeding to the",
"// next block node, make sure we check for available bit in the next",
"// instance of the same block. Due to RLE same block signature will be",
"// compressed.",
"retry",
":",
"bytePos",
",",
"bitPos",
",",
"err",
":=",
"current",
".",
"getAvailableBit",
"(",
"bitOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"precBlocks",
"==",
"current",
".",
"count",
"-",
"1",
"{",
"// This is the last instance in the same block node,",
"// so move to the next block.",
"goto",
"next",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// There are some more instances of the same block, so add the offset",
"// and be optimistic that you will find the available bit in the next",
"// instance of the same block.",
"bitOffset",
"=",
"0",
"\n",
"byteOffset",
"+=",
"blockBytes",
"\n",
"precBlocks",
"++",
"\n",
"goto",
"retry",
"\n",
"}",
"\n",
"return",
"byteOffset",
"+",
"bytePos",
",",
"bitPos",
",",
"err",
"\n",
"}",
"\n",
"// Moving to next block: Reset bit offset.",
"next",
":",
"bitOffset",
"=",
"0",
"\n",
"byteOffset",
"+=",
"(",
"current",
".",
"count",
"*",
"blockBytes",
")",
"-",
"(",
"precBlocks",
"*",
"blockBytes",
")",
"\n",
"precBlocks",
"=",
"0",
"\n",
"current",
"=",
"current",
".",
"next",
"\n",
"}",
"\n",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}"
] | // getFirstAvailable looks for the first unset bit in passed mask starting from start | [
"getFirstAvailable",
"looks",
"for",
"the",
"first",
"unset",
"bit",
"in",
"passed",
"mask",
"starting",
"from",
"start"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L505-L545 | train |
docker/libnetwork | bitseq/sequence.go | getAvailableFromCurrent | func getAvailableFromCurrent(head *sequence, start, curr, end uint64) (uint64, uint64, error) {
var bytePos, bitPos uint64
var err error
if curr != 0 && curr > start {
bytePos, bitPos, err = getFirstAvailable(head, curr)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
goto begin
}
return bytePos, bitPos, nil
}
begin:
bytePos, bitPos, err = getFirstAvailable(head, start)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bytePos, bitPos, nil
} | go | func getAvailableFromCurrent(head *sequence, start, curr, end uint64) (uint64, uint64, error) {
var bytePos, bitPos uint64
var err error
if curr != 0 && curr > start {
bytePos, bitPos, err = getFirstAvailable(head, curr)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
goto begin
}
return bytePos, bitPos, nil
}
begin:
bytePos, bitPos, err = getFirstAvailable(head, start)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bytePos, bitPos, nil
} | [
"func",
"getAvailableFromCurrent",
"(",
"head",
"*",
"sequence",
",",
"start",
",",
"curr",
",",
"end",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"var",
"bytePos",
",",
"bitPos",
"uint64",
"\n",
"var",
"err",
"error",
"\n",
"if",
"curr",
"!=",
"0",
"&&",
"curr",
">",
"start",
"{",
"bytePos",
",",
"bitPos",
",",
"err",
"=",
"getFirstAvailable",
"(",
"head",
",",
"curr",
")",
"\n",
"ret",
":=",
"posToOrdinal",
"(",
"bytePos",
",",
"bitPos",
")",
"\n",
"if",
"end",
"<",
"ret",
"||",
"err",
"!=",
"nil",
"{",
"goto",
"begin",
"\n",
"}",
"\n",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}",
"\n\n",
"begin",
":",
"bytePos",
",",
"bitPos",
",",
"err",
"=",
"getFirstAvailable",
"(",
"head",
",",
"start",
")",
"\n",
"ret",
":=",
"posToOrdinal",
"(",
"bytePos",
",",
"bitPos",
")",
"\n",
"if",
"end",
"<",
"ret",
"||",
"err",
"!=",
"nil",
"{",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}"
] | // getAvailableFromCurrent will look for available ordinal from the current ordinal.
// If none found then it will loop back to the start to check of the available bit.
// This can be further optimized to check from start till curr in case of a rollover | [
"getAvailableFromCurrent",
"will",
"look",
"for",
"available",
"ordinal",
"from",
"the",
"current",
"ordinal",
".",
"If",
"none",
"found",
"then",
"it",
"will",
"loop",
"back",
"to",
"the",
"start",
"to",
"check",
"of",
"the",
"available",
"bit",
".",
"This",
"can",
"be",
"further",
"optimized",
"to",
"check",
"from",
"start",
"till",
"curr",
"in",
"case",
"of",
"a",
"rollover"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L550-L569 | train |
docker/libnetwork | bitseq/sequence.go | checkIfAvailable | func checkIfAvailable(head *sequence, ordinal uint64) (uint64, uint64, error) {
bytePos, bitPos := ordinalToPos(ordinal)
// Find the sequence containing this byte
current, _, _, inBlockBytePos := findSequence(head, bytePos)
if current != nil {
// Check whether the bit corresponding to the ordinal address is unset
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
if current.block&bitSel == 0 {
return bytePos, bitPos, nil
}
}
return invalidPos, invalidPos, ErrBitAllocated
} | go | func checkIfAvailable(head *sequence, ordinal uint64) (uint64, uint64, error) {
bytePos, bitPos := ordinalToPos(ordinal)
// Find the sequence containing this byte
current, _, _, inBlockBytePos := findSequence(head, bytePos)
if current != nil {
// Check whether the bit corresponding to the ordinal address is unset
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
if current.block&bitSel == 0 {
return bytePos, bitPos, nil
}
}
return invalidPos, invalidPos, ErrBitAllocated
} | [
"func",
"checkIfAvailable",
"(",
"head",
"*",
"sequence",
",",
"ordinal",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"bytePos",
",",
"bitPos",
":=",
"ordinalToPos",
"(",
"ordinal",
")",
"\n\n",
"// Find the sequence containing this byte",
"current",
",",
"_",
",",
"_",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"bytePos",
")",
"\n",
"if",
"current",
"!=",
"nil",
"{",
"// Check whether the bit corresponding to the ordinal address is unset",
"bitSel",
":=",
"blockFirstBit",
">>",
"(",
"inBlockBytePos",
"*",
"8",
"+",
"bitPos",
")",
"\n",
"if",
"current",
".",
"block",
"&",
"bitSel",
"==",
"0",
"{",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrBitAllocated",
"\n",
"}"
] | // checkIfAvailable checks if the bit correspondent to the specified ordinal is unset
// If the ordinal is beyond the sequence limits, a negative response is returned | [
"checkIfAvailable",
"checks",
"if",
"the",
"bit",
"correspondent",
"to",
"the",
"specified",
"ordinal",
"is",
"unset",
"If",
"the",
"ordinal",
"is",
"beyond",
"the",
"sequence",
"limits",
"a",
"negative",
"response",
"is",
"returned"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L573-L587 | train |
docker/libnetwork | bitseq/sequence.go | removeCurrentIfEmpty | func removeCurrentIfEmpty(head **sequence, previous, current *sequence) {
if current.count == 0 {
if current == *head {
*head = current.next
} else {
previous.next = current.next
current = current.next
}
}
} | go | func removeCurrentIfEmpty(head **sequence, previous, current *sequence) {
if current.count == 0 {
if current == *head {
*head = current.next
} else {
previous.next = current.next
current = current.next
}
}
} | [
"func",
"removeCurrentIfEmpty",
"(",
"head",
"*",
"*",
"sequence",
",",
"previous",
",",
"current",
"*",
"sequence",
")",
"{",
"if",
"current",
".",
"count",
"==",
"0",
"{",
"if",
"current",
"==",
"*",
"head",
"{",
"*",
"head",
"=",
"current",
".",
"next",
"\n",
"}",
"else",
"{",
"previous",
".",
"next",
"=",
"current",
".",
"next",
"\n",
"current",
"=",
"current",
".",
"next",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Removes the current sequence from the list if empty, adjusting the head pointer if needed | [
"Removes",
"the",
"current",
"sequence",
"from",
"the",
"list",
"if",
"empty",
"adjusting",
"the",
"head",
"pointer",
"if",
"needed"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L696-L705 | train |
docker/libnetwork | osl/interface_linux.go | Statistics | func (i *nwIface) Statistics() (*types.InterfaceStatistics, error) {
i.Lock()
n := i.ns
i.Unlock()
l, err := n.nlHandle.LinkByName(i.DstName())
if err != nil {
return nil, fmt.Errorf("failed to retrieve the statistics for %s in netns %s: %v", i.DstName(), n.path, err)
}
stats := l.Attrs().Statistics
if stats == nil {
return nil, fmt.Errorf("no statistics were returned")
}
return &types.InterfaceStatistics{
RxBytes: uint64(stats.RxBytes),
TxBytes: uint64(stats.TxBytes),
RxPackets: uint64(stats.RxPackets),
TxPackets: uint64(stats.TxPackets),
RxDropped: uint64(stats.RxDropped),
TxDropped: uint64(stats.TxDropped),
}, nil
} | go | func (i *nwIface) Statistics() (*types.InterfaceStatistics, error) {
i.Lock()
n := i.ns
i.Unlock()
l, err := n.nlHandle.LinkByName(i.DstName())
if err != nil {
return nil, fmt.Errorf("failed to retrieve the statistics for %s in netns %s: %v", i.DstName(), n.path, err)
}
stats := l.Attrs().Statistics
if stats == nil {
return nil, fmt.Errorf("no statistics were returned")
}
return &types.InterfaceStatistics{
RxBytes: uint64(stats.RxBytes),
TxBytes: uint64(stats.TxBytes),
RxPackets: uint64(stats.RxPackets),
TxPackets: uint64(stats.TxPackets),
RxDropped: uint64(stats.RxDropped),
TxDropped: uint64(stats.TxDropped),
}, nil
} | [
"func",
"(",
"i",
"*",
"nwIface",
")",
"Statistics",
"(",
")",
"(",
"*",
"types",
".",
"InterfaceStatistics",
",",
"error",
")",
"{",
"i",
".",
"Lock",
"(",
")",
"\n",
"n",
":=",
"i",
".",
"ns",
"\n",
"i",
".",
"Unlock",
"(",
")",
"\n\n",
"l",
",",
"err",
":=",
"n",
".",
"nlHandle",
".",
"LinkByName",
"(",
"i",
".",
"DstName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
".",
"DstName",
"(",
")",
",",
"n",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"stats",
":=",
"l",
".",
"Attrs",
"(",
")",
".",
"Statistics",
"\n",
"if",
"stats",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"types",
".",
"InterfaceStatistics",
"{",
"RxBytes",
":",
"uint64",
"(",
"stats",
".",
"RxBytes",
")",
",",
"TxBytes",
":",
"uint64",
"(",
"stats",
".",
"TxBytes",
")",
",",
"RxPackets",
":",
"uint64",
"(",
"stats",
".",
"RxPackets",
")",
",",
"TxPackets",
":",
"uint64",
"(",
"stats",
".",
"TxPackets",
")",
",",
"RxDropped",
":",
"uint64",
"(",
"stats",
".",
"RxDropped",
")",
",",
"TxDropped",
":",
"uint64",
"(",
"stats",
".",
"TxDropped",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Returns the sandbox's side veth interface statistics | [
"Returns",
"the",
"sandbox",
"s",
"side",
"veth",
"interface",
"statistics"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/osl/interface_linux.go#L180-L203 | train |
docker/libnetwork | ipamutils/utils.go | configDefaultNetworks | func configDefaultNetworks(defaultAddressPool []*NetworkToSplit, result *[]*net.IPNet) error {
mutex.Lock()
defer mutex.Unlock()
defaultNetworks, err := splitNetworks(defaultAddressPool)
if err != nil {
return err
}
*result = defaultNetworks
return nil
} | go | func configDefaultNetworks(defaultAddressPool []*NetworkToSplit, result *[]*net.IPNet) error {
mutex.Lock()
defer mutex.Unlock()
defaultNetworks, err := splitNetworks(defaultAddressPool)
if err != nil {
return err
}
*result = defaultNetworks
return nil
} | [
"func",
"configDefaultNetworks",
"(",
"defaultAddressPool",
"[",
"]",
"*",
"NetworkToSplit",
",",
"result",
"*",
"[",
"]",
"*",
"net",
".",
"IPNet",
")",
"error",
"{",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"defaultNetworks",
",",
"err",
":=",
"splitNetworks",
"(",
"defaultAddressPool",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"result",
"=",
"defaultNetworks",
"\n",
"return",
"nil",
"\n",
"}"
] | // configDefaultNetworks configures local as well global default pool based on input | [
"configDefaultNetworks",
"configures",
"local",
"as",
"well",
"global",
"default",
"pool",
"based",
"on",
"input"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ipamutils/utils.go#L48-L57 | train |
docker/libnetwork | ipamutils/utils.go | ConfigGlobalScopeDefaultNetworks | func ConfigGlobalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
if defaultAddressPool == nil {
defaultAddressPool = globalScopeDefaultNetworks
}
return configDefaultNetworks(defaultAddressPool, &PredefinedGlobalScopeDefaultNetworks)
} | go | func ConfigGlobalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
if defaultAddressPool == nil {
defaultAddressPool = globalScopeDefaultNetworks
}
return configDefaultNetworks(defaultAddressPool, &PredefinedGlobalScopeDefaultNetworks)
} | [
"func",
"ConfigGlobalScopeDefaultNetworks",
"(",
"defaultAddressPool",
"[",
"]",
"*",
"NetworkToSplit",
")",
"error",
"{",
"if",
"defaultAddressPool",
"==",
"nil",
"{",
"defaultAddressPool",
"=",
"globalScopeDefaultNetworks",
"\n",
"}",
"\n",
"return",
"configDefaultNetworks",
"(",
"defaultAddressPool",
",",
"&",
"PredefinedGlobalScopeDefaultNetworks",
")",
"\n",
"}"
] | // ConfigGlobalScopeDefaultNetworks configures global default pool.
// Ideally this will be called from SwarmKit as part of swarm init | [
"ConfigGlobalScopeDefaultNetworks",
"configures",
"global",
"default",
"pool",
".",
"Ideally",
"this",
"will",
"be",
"called",
"from",
"SwarmKit",
"as",
"part",
"of",
"swarm",
"init"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ipamutils/utils.go#L75-L80 | train |
docker/libnetwork | ipamutils/utils.go | ConfigLocalScopeDefaultNetworks | func ConfigLocalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
if defaultAddressPool == nil {
return nil
}
return configDefaultNetworks(defaultAddressPool, &PredefinedLocalScopeDefaultNetworks)
} | go | func ConfigLocalScopeDefaultNetworks(defaultAddressPool []*NetworkToSplit) error {
if defaultAddressPool == nil {
return nil
}
return configDefaultNetworks(defaultAddressPool, &PredefinedLocalScopeDefaultNetworks)
} | [
"func",
"ConfigLocalScopeDefaultNetworks",
"(",
"defaultAddressPool",
"[",
"]",
"*",
"NetworkToSplit",
")",
"error",
"{",
"if",
"defaultAddressPool",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"configDefaultNetworks",
"(",
"defaultAddressPool",
",",
"&",
"PredefinedLocalScopeDefaultNetworks",
")",
"\n",
"}"
] | // ConfigLocalScopeDefaultNetworks configures local default pool.
// Ideally this will be called during libnetwork init | [
"ConfigLocalScopeDefaultNetworks",
"configures",
"local",
"default",
"pool",
".",
"Ideally",
"this",
"will",
"be",
"called",
"during",
"libnetwork",
"init"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ipamutils/utils.go#L84-L89 | train |
docker/libnetwork | ipamutils/utils.go | splitNetworks | func splitNetworks(list []*NetworkToSplit) ([]*net.IPNet, error) {
localPools := make([]*net.IPNet, 0, len(list))
for _, p := range list {
_, b, err := net.ParseCIDR(p.Base)
if err != nil {
return nil, fmt.Errorf("invalid base pool %q: %v", p.Base, err)
}
ones, _ := b.Mask.Size()
if p.Size <= 0 || p.Size < ones {
return nil, fmt.Errorf("invalid pools size: %d", p.Size)
}
localPools = append(localPools, splitNetwork(p.Size, b)...)
}
return localPools, nil
} | go | func splitNetworks(list []*NetworkToSplit) ([]*net.IPNet, error) {
localPools := make([]*net.IPNet, 0, len(list))
for _, p := range list {
_, b, err := net.ParseCIDR(p.Base)
if err != nil {
return nil, fmt.Errorf("invalid base pool %q: %v", p.Base, err)
}
ones, _ := b.Mask.Size()
if p.Size <= 0 || p.Size < ones {
return nil, fmt.Errorf("invalid pools size: %d", p.Size)
}
localPools = append(localPools, splitNetwork(p.Size, b)...)
}
return localPools, nil
} | [
"func",
"splitNetworks",
"(",
"list",
"[",
"]",
"*",
"NetworkToSplit",
")",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"error",
")",
"{",
"localPools",
":=",
"make",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"0",
",",
"len",
"(",
"list",
")",
")",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"list",
"{",
"_",
",",
"b",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"p",
".",
"Base",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"Base",
",",
"err",
")",
"\n",
"}",
"\n",
"ones",
",",
"_",
":=",
"b",
".",
"Mask",
".",
"Size",
"(",
")",
"\n",
"if",
"p",
".",
"Size",
"<=",
"0",
"||",
"p",
".",
"Size",
"<",
"ones",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"Size",
")",
"\n",
"}",
"\n",
"localPools",
"=",
"append",
"(",
"localPools",
",",
"splitNetwork",
"(",
"p",
".",
"Size",
",",
"b",
")",
"...",
")",
"\n",
"}",
"\n",
"return",
"localPools",
",",
"nil",
"\n",
"}"
] | // splitNetworks takes a slice of networks, split them accordingly and returns them | [
"splitNetworks",
"takes",
"a",
"slice",
"of",
"networks",
"split",
"them",
"accordingly",
"and",
"returns",
"them"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ipamutils/utils.go#L92-L107 | train |
docker/libnetwork | portmapper/mapper_linux.go | SetIptablesChain | func (pm *PortMapper) SetIptablesChain(c *iptables.ChainInfo, bridgeName string) {
pm.chain = c
pm.bridgeName = bridgeName
} | go | func (pm *PortMapper) SetIptablesChain(c *iptables.ChainInfo, bridgeName string) {
pm.chain = c
pm.bridgeName = bridgeName
} | [
"func",
"(",
"pm",
"*",
"PortMapper",
")",
"SetIptablesChain",
"(",
"c",
"*",
"iptables",
".",
"ChainInfo",
",",
"bridgeName",
"string",
")",
"{",
"pm",
".",
"chain",
"=",
"c",
"\n",
"pm",
".",
"bridgeName",
"=",
"bridgeName",
"\n",
"}"
] | // SetIptablesChain sets the specified chain into portmapper | [
"SetIptablesChain",
"sets",
"the",
"specified",
"chain",
"into",
"portmapper"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/portmapper/mapper_linux.go#L26-L29 | train |
docker/libnetwork | portmapper/mapper_linux.go | DeleteForwardingTableEntry | func (pm *PortMapper) DeleteForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
return pm.forward(iptables.Delete, proto, sourceIP, sourcePort, containerIP, containerPort)
} | go | func (pm *PortMapper) DeleteForwardingTableEntry(proto string, sourceIP net.IP, sourcePort int, containerIP string, containerPort int) error {
return pm.forward(iptables.Delete, proto, sourceIP, sourcePort, containerIP, containerPort)
} | [
"func",
"(",
"pm",
"*",
"PortMapper",
")",
"DeleteForwardingTableEntry",
"(",
"proto",
"string",
",",
"sourceIP",
"net",
".",
"IP",
",",
"sourcePort",
"int",
",",
"containerIP",
"string",
",",
"containerPort",
"int",
")",
"error",
"{",
"return",
"pm",
".",
"forward",
"(",
"iptables",
".",
"Delete",
",",
"proto",
",",
"sourceIP",
",",
"sourcePort",
",",
"containerIP",
",",
"containerPort",
")",
"\n",
"}"
] | // DeleteForwardingTableEntry removes a port mapping from the forwarding table | [
"DeleteForwardingTableEntry",
"removes",
"a",
"port",
"mapping",
"from",
"the",
"forwarding",
"table"
] | 9ff9b57c344df5cd47443ad9e65702ec85c5aeb0 | https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/portmapper/mapper_linux.go#L37-L39 | train |
satori/go.uuid | codec.go | FromBytes | func FromBytes(input []byte) (u UUID, err error) {
err = u.UnmarshalBinary(input)
return
} | go | func FromBytes(input []byte) (u UUID, err error) {
err = u.UnmarshalBinary(input)
return
} | [
"func",
"FromBytes",
"(",
"input",
"[",
"]",
"byte",
")",
"(",
"u",
"UUID",
",",
"err",
"error",
")",
"{",
"err",
"=",
"u",
".",
"UnmarshalBinary",
"(",
"input",
")",
"\n",
"return",
"\n",
"}"
] | // FromBytes returns UUID converted from raw byte slice input.
// It will return error if the slice isn't 16 bytes long. | [
"FromBytes",
"returns",
"UUID",
"converted",
"from",
"raw",
"byte",
"slice",
"input",
".",
"It",
"will",
"return",
"error",
"if",
"the",
"slice",
"isn",
"t",
"16",
"bytes",
"long",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L32-L35 | train |
satori/go.uuid | codec.go | FromBytesOrNil | func FromBytesOrNil(input []byte) UUID {
uuid, err := FromBytes(input)
if err != nil {
return Nil
}
return uuid
} | go | func FromBytesOrNil(input []byte) UUID {
uuid, err := FromBytes(input)
if err != nil {
return Nil
}
return uuid
} | [
"func",
"FromBytesOrNil",
"(",
"input",
"[",
"]",
"byte",
")",
"UUID",
"{",
"uuid",
",",
"err",
":=",
"FromBytes",
"(",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Nil",
"\n",
"}",
"\n",
"return",
"uuid",
"\n",
"}"
] | // FromBytesOrNil returns UUID converted from raw byte slice input.
// Same behavior as FromBytes, but returns a Nil UUID on error. | [
"FromBytesOrNil",
"returns",
"UUID",
"converted",
"from",
"raw",
"byte",
"slice",
"input",
".",
"Same",
"behavior",
"as",
"FromBytes",
"but",
"returns",
"a",
"Nil",
"UUID",
"on",
"error",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L39-L45 | train |
satori/go.uuid | codec.go | FromStringOrNil | func FromStringOrNil(input string) UUID {
uuid, err := FromString(input)
if err != nil {
return Nil
}
return uuid
} | go | func FromStringOrNil(input string) UUID {
uuid, err := FromString(input)
if err != nil {
return Nil
}
return uuid
} | [
"func",
"FromStringOrNil",
"(",
"input",
"string",
")",
"UUID",
"{",
"uuid",
",",
"err",
":=",
"FromString",
"(",
"input",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"Nil",
"\n",
"}",
"\n",
"return",
"uuid",
"\n",
"}"
] | // FromStringOrNil returns UUID parsed from string input.
// Same behavior as FromString, but returns a Nil UUID on error. | [
"FromStringOrNil",
"returns",
"UUID",
"parsed",
"from",
"string",
"input",
".",
"Same",
"behavior",
"as",
"FromString",
"but",
"returns",
"a",
"Nil",
"UUID",
"on",
"error",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L56-L62 | train |
satori/go.uuid | codec.go | MarshalText | func (u UUID) MarshalText() (text []byte, err error) {
text = []byte(u.String())
return
} | go | func (u UUID) MarshalText() (text []byte, err error) {
text = []byte(u.String())
return
} | [
"func",
"(",
"u",
"UUID",
")",
"MarshalText",
"(",
")",
"(",
"text",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"text",
"=",
"[",
"]",
"byte",
"(",
"u",
".",
"String",
"(",
")",
")",
"\n",
"return",
"\n",
"}"
] | // MarshalText implements the encoding.TextMarshaler interface.
// The encoding is the same as returned by String. | [
"MarshalText",
"implements",
"the",
"encoding",
".",
"TextMarshaler",
"interface",
".",
"The",
"encoding",
"is",
"the",
"same",
"as",
"returned",
"by",
"String",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L66-L69 | train |
satori/go.uuid | codec.go | decodeCanonical | func (u *UUID) decodeCanonical(t []byte) (err error) {
if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
return fmt.Errorf("uuid: incorrect UUID format %s", t)
}
src := t[:]
dst := u[:]
for i, byteGroup := range byteGroups {
if i > 0 {
src = src[1:] // skip dash
}
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
if err != nil {
return
}
src = src[byteGroup:]
dst = dst[byteGroup/2:]
}
return
} | go | func (u *UUID) decodeCanonical(t []byte) (err error) {
if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
return fmt.Errorf("uuid: incorrect UUID format %s", t)
}
src := t[:]
dst := u[:]
for i, byteGroup := range byteGroups {
if i > 0 {
src = src[1:] // skip dash
}
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
if err != nil {
return
}
src = src[byteGroup:]
dst = dst[byteGroup/2:]
}
return
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"decodeCanonical",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"t",
"[",
"8",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"13",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"18",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"23",
"]",
"!=",
"'-'",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n\n",
"src",
":=",
"t",
"[",
":",
"]",
"\n",
"dst",
":=",
"u",
"[",
":",
"]",
"\n\n",
"for",
"i",
",",
"byteGroup",
":=",
"range",
"byteGroups",
"{",
"if",
"i",
">",
"0",
"{",
"src",
"=",
"src",
"[",
"1",
":",
"]",
"// skip dash",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"hex",
".",
"Decode",
"(",
"dst",
"[",
":",
"byteGroup",
"/",
"2",
"]",
",",
"src",
"[",
":",
"byteGroup",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"src",
"=",
"src",
"[",
"byteGroup",
":",
"]",
"\n",
"dst",
"=",
"dst",
"[",
"byteGroup",
"/",
"2",
":",
"]",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // decodeCanonical decodes UUID string in format
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8". | [
"decodeCanonical",
"decodes",
"UUID",
"string",
"in",
"format",
"6ba7b810",
"-",
"9dad",
"-",
"11d1",
"-",
"80b4",
"-",
"00c04fd430c8",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L113-L134 | train |
satori/go.uuid | codec.go | decodeHashLike | func (u *UUID) decodeHashLike(t []byte) (err error) {
src := t[:]
dst := u[:]
if _, err = hex.Decode(dst, src); err != nil {
return err
}
return
} | go | func (u *UUID) decodeHashLike(t []byte) (err error) {
src := t[:]
dst := u[:]
if _, err = hex.Decode(dst, src); err != nil {
return err
}
return
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"decodeHashLike",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"src",
":=",
"t",
"[",
":",
"]",
"\n",
"dst",
":=",
"u",
"[",
":",
"]",
"\n\n",
"if",
"_",
",",
"err",
"=",
"hex",
".",
"Decode",
"(",
"dst",
",",
"src",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // decodeHashLike decodes UUID string in format
// "6ba7b8109dad11d180b400c04fd430c8". | [
"decodeHashLike",
"decodes",
"UUID",
"string",
"in",
"format",
"6ba7b8109dad11d180b400c04fd430c8",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L138-L146 | train |
satori/go.uuid | codec.go | decodePlain | func (u *UUID) decodePlain(t []byte) (err error) {
switch len(t) {
case 32:
return u.decodeHashLike(t)
case 36:
return u.decodeCanonical(t)
default:
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
}
} | go | func (u *UUID) decodePlain(t []byte) (err error) {
switch len(t) {
case 32:
return u.decodeHashLike(t)
case 36:
return u.decodeCanonical(t)
default:
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
}
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"decodePlain",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"switch",
"len",
"(",
"t",
")",
"{",
"case",
"32",
":",
"return",
"u",
".",
"decodeHashLike",
"(",
"t",
")",
"\n",
"case",
"36",
":",
"return",
"u",
".",
"decodeCanonical",
"(",
"t",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n",
"}"
] | // decodePlain decodes UUID string in canonical format
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
// "6ba7b8109dad11d180b400c04fd430c8". | [
"decodePlain",
"decodes",
"UUID",
"string",
"in",
"canonical",
"format",
"6ba7b810",
"-",
"9dad",
"-",
"11d1",
"-",
"80b4",
"-",
"00c04fd430c8",
"or",
"in",
"hash",
"-",
"like",
"format",
"6ba7b8109dad11d180b400c04fd430c8",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L179-L188 | train |
satori/go.uuid | codec.go | UnmarshalBinary | func (u *UUID) UnmarshalBinary(data []byte) (err error) {
if len(data) != Size {
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
return
}
copy(u[:], data)
return
} | go | func (u *UUID) UnmarshalBinary(data []byte) (err error) {
if len(data) != Size {
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
return
}
copy(u[:], data)
return
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"!=",
"Size",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"data",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"copy",
"(",
"u",
"[",
":",
"]",
",",
"data",
")",
"\n\n",
"return",
"\n",
"}"
] | // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
// It will return error if the slice isn't 16 bytes long. | [
"UnmarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryUnmarshaler",
"interface",
".",
"It",
"will",
"return",
"error",
"if",
"the",
"slice",
"isn",
"t",
"16",
"bytes",
"long",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L198-L206 | train |
satori/go.uuid | generator.go | getClockSequence | func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
var err error
g.clockSequenceOnce.Do(func() {
buf := make([]byte, 2)
if _, err = io.ReadFull(g.rand, buf); err != nil {
return
}
g.clockSequence = binary.BigEndian.Uint16(buf)
})
if err != nil {
return 0, 0, err
}
g.storageMutex.Lock()
defer g.storageMutex.Unlock()
timeNow := g.getEpoch()
// Clock didn't change since last UUID generation.
// Should increase clock sequence.
if timeNow <= g.lastTime {
g.clockSequence++
}
g.lastTime = timeNow
return timeNow, g.clockSequence, nil
} | go | func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
var err error
g.clockSequenceOnce.Do(func() {
buf := make([]byte, 2)
if _, err = io.ReadFull(g.rand, buf); err != nil {
return
}
g.clockSequence = binary.BigEndian.Uint16(buf)
})
if err != nil {
return 0, 0, err
}
g.storageMutex.Lock()
defer g.storageMutex.Unlock()
timeNow := g.getEpoch()
// Clock didn't change since last UUID generation.
// Should increase clock sequence.
if timeNow <= g.lastTime {
g.clockSequence++
}
g.lastTime = timeNow
return timeNow, g.clockSequence, nil
} | [
"func",
"(",
"g",
"*",
"rfc4122Generator",
")",
"getClockSequence",
"(",
")",
"(",
"uint64",
",",
"uint16",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"g",
".",
"clockSequenceOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"g",
".",
"rand",
",",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"g",
".",
"clockSequence",
"=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"buf",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"g",
".",
"storageMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"g",
".",
"storageMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"timeNow",
":=",
"g",
".",
"getEpoch",
"(",
")",
"\n",
"// Clock didn't change since last UUID generation.",
"// Should increase clock sequence.",
"if",
"timeNow",
"<=",
"g",
".",
"lastTime",
"{",
"g",
".",
"clockSequence",
"++",
"\n",
"}",
"\n",
"g",
".",
"lastTime",
"=",
"timeNow",
"\n\n",
"return",
"timeNow",
",",
"g",
".",
"clockSequence",
",",
"nil",
"\n",
"}"
] | // Returns epoch and clock sequence. | [
"Returns",
"epoch",
"and",
"clock",
"sequence",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/generator.go#L187-L212 | train |
satori/go.uuid | uuid.go | Equal | func Equal(u1 UUID, u2 UUID) bool {
return bytes.Equal(u1[:], u2[:])
} | go | func Equal(u1 UUID, u2 UUID) bool {
return bytes.Equal(u1[:], u2[:])
} | [
"func",
"Equal",
"(",
"u1",
"UUID",
",",
"u2",
"UUID",
")",
"bool",
"{",
"return",
"bytes",
".",
"Equal",
"(",
"u1",
"[",
":",
"]",
",",
"u2",
"[",
":",
"]",
")",
"\n",
"}"
] | // Equal returns true if u1 and u2 equals, otherwise returns false. | [
"Equal",
"returns",
"true",
"if",
"u1",
"and",
"u2",
"equals",
"otherwise",
"returns",
"false",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/uuid.go#L83-L85 | train |
satori/go.uuid | uuid.go | SetVariant | func (u *UUID) SetVariant(v byte) {
switch v {
case VariantNCS:
u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
case VariantRFC4122:
u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
case VariantMicrosoft:
u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
case VariantFuture:
fallthrough
default:
u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
}
} | go | func (u *UUID) SetVariant(v byte) {
switch v {
case VariantNCS:
u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
case VariantRFC4122:
u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
case VariantMicrosoft:
u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
case VariantFuture:
fallthrough
default:
u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
}
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"SetVariant",
"(",
"v",
"byte",
")",
"{",
"switch",
"v",
"{",
"case",
"VariantNCS",
":",
"u",
"[",
"8",
"]",
"=",
"(",
"u",
"[",
"8",
"]",
"&",
"(",
"0xff",
">>",
"1",
")",
"|",
"(",
"0x00",
"<<",
"7",
")",
")",
"\n",
"case",
"VariantRFC4122",
":",
"u",
"[",
"8",
"]",
"=",
"(",
"u",
"[",
"8",
"]",
"&",
"(",
"0xff",
">>",
"2",
")",
"|",
"(",
"0x02",
"<<",
"6",
")",
")",
"\n",
"case",
"VariantMicrosoft",
":",
"u",
"[",
"8",
"]",
"=",
"(",
"u",
"[",
"8",
"]",
"&",
"(",
"0xff",
">>",
"3",
")",
"|",
"(",
"0x06",
"<<",
"5",
")",
")",
"\n",
"case",
"VariantFuture",
":",
"fallthrough",
"\n",
"default",
":",
"u",
"[",
"8",
"]",
"=",
"(",
"u",
"[",
"8",
"]",
"&",
"(",
"0xff",
">>",
"3",
")",
"|",
"(",
"0x07",
"<<",
"5",
")",
")",
"\n",
"}",
"\n",
"}"
] | // SetVariant sets variant bits. | [
"SetVariant",
"sets",
"variant",
"bits",
"."
] | b2ce2384e17bbe0c6d34077efa39dbab3e09123b | https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/uuid.go#L137-L150 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAggregateByAggfnoid | func PgAggregateByAggfnoid(db XODB, aggfnoid pgtypes.Regproc) (*PgAggregate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval ` +
`FROM pg_catalog.pg_aggregate ` +
`WHERE aggfnoid = $1`
// run query
XOLog(sqlstr, aggfnoid)
pa := PgAggregate{}
err = db.QueryRow(sqlstr, aggfnoid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAggregateByAggfnoid(db XODB, aggfnoid pgtypes.Regproc) (*PgAggregate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval ` +
`FROM pg_catalog.pg_aggregate ` +
`WHERE aggfnoid = $1`
// run query
XOLog(sqlstr, aggfnoid)
pa := PgAggregate{}
err = db.QueryRow(sqlstr, aggfnoid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAggregateByAggfnoid",
"(",
"db",
"XODB",
",",
"aggfnoid",
"pgtypes",
".",
"Regproc",
")",
"(",
"*",
"PgAggregate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval `",
"+",
"`FROM pg_catalog.pg_aggregate `",
"+",
"`WHERE aggfnoid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"aggfnoid",
")",
"\n",
"pa",
":=",
"PgAggregate",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"aggfnoid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Aggfnoid",
",",
"&",
"pa",
".",
"Aggkind",
",",
"&",
"pa",
".",
"Aggnumdirectargs",
",",
"&",
"pa",
".",
"Aggtransfn",
",",
"&",
"pa",
".",
"Aggfinalfn",
",",
"&",
"pa",
".",
"Aggmtransfn",
",",
"&",
"pa",
".",
"Aggminvtransfn",
",",
"&",
"pa",
".",
"Aggmfinalfn",
",",
"&",
"pa",
".",
"Aggfinalextra",
",",
"&",
"pa",
".",
"Aggmfinalextra",
",",
"&",
"pa",
".",
"Aggsortop",
",",
"&",
"pa",
".",
"Aggtranstype",
",",
"&",
"pa",
".",
"Aggtransspace",
",",
"&",
"pa",
".",
"Aggmtranstype",
",",
"&",
"pa",
".",
"Aggmtransspace",
",",
"&",
"pa",
".",
"Agginitval",
",",
"&",
"pa",
".",
"Aggminitval",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAggregateByAggfnoid retrieves a row from 'pg_catalog.pg_aggregate' as a PgAggregate.
//
// Generated from index 'pg_aggregate_fnoid_index'. | [
"PgAggregateByAggfnoid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_aggregate",
"as",
"a",
"PgAggregate",
".",
"Generated",
"from",
"index",
"pg_aggregate_fnoid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41744-L41763 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmByAmname | func PgAmByAmname(db XODB, amname pgtypes.Name) (*PgAm, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions ` +
`FROM pg_catalog.pg_am ` +
`WHERE amname = $1`
// run query
XOLog(sqlstr, amname)
pa := PgAm{}
err = db.QueryRow(sqlstr, amname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amname, &pa.Amstrategies, &pa.Amsupport, &pa.Amcanorder, &pa.Amcanorderbyop, &pa.Amcanbackward, &pa.Amcanunique, &pa.Amcanmulticol, &pa.Amoptionalkey, &pa.Amsearcharray, &pa.Amsearchnulls, &pa.Amstorage, &pa.Amclusterable, &pa.Ampredlocks, &pa.Amkeytype, &pa.Aminsert, &pa.Ambeginscan, &pa.Amgettuple, &pa.Amgetbitmap, &pa.Amrescan, &pa.Amendscan, &pa.Ammarkpos, &pa.Amrestrpos, &pa.Ambuild, &pa.Ambuildempty, &pa.Ambulkdelete, &pa.Amvacuumcleanup, &pa.Amcanreturn, &pa.Amcostestimate, &pa.Amoptions)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmByAmname(db XODB, amname pgtypes.Name) (*PgAm, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions ` +
`FROM pg_catalog.pg_am ` +
`WHERE amname = $1`
// run query
XOLog(sqlstr, amname)
pa := PgAm{}
err = db.QueryRow(sqlstr, amname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amname, &pa.Amstrategies, &pa.Amsupport, &pa.Amcanorder, &pa.Amcanorderbyop, &pa.Amcanbackward, &pa.Amcanunique, &pa.Amcanmulticol, &pa.Amoptionalkey, &pa.Amsearcharray, &pa.Amsearchnulls, &pa.Amstorage, &pa.Amclusterable, &pa.Ampredlocks, &pa.Amkeytype, &pa.Aminsert, &pa.Ambeginscan, &pa.Amgettuple, &pa.Amgetbitmap, &pa.Amrescan, &pa.Amendscan, &pa.Ammarkpos, &pa.Amrestrpos, &pa.Ambuild, &pa.Ambuildempty, &pa.Ambulkdelete, &pa.Amvacuumcleanup, &pa.Amcanreturn, &pa.Amcostestimate, &pa.Amoptions)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmByAmname",
"(",
"db",
"XODB",
",",
"amname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgAm",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions `",
"+",
"`FROM pg_catalog.pg_am `",
"+",
"`WHERE amname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amname",
")",
"\n",
"pa",
":=",
"PgAm",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amname",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amname",
",",
"&",
"pa",
".",
"Amstrategies",
",",
"&",
"pa",
".",
"Amsupport",
",",
"&",
"pa",
".",
"Amcanorder",
",",
"&",
"pa",
".",
"Amcanorderbyop",
",",
"&",
"pa",
".",
"Amcanbackward",
",",
"&",
"pa",
".",
"Amcanunique",
",",
"&",
"pa",
".",
"Amcanmulticol",
",",
"&",
"pa",
".",
"Amoptionalkey",
",",
"&",
"pa",
".",
"Amsearcharray",
",",
"&",
"pa",
".",
"Amsearchnulls",
",",
"&",
"pa",
".",
"Amstorage",
",",
"&",
"pa",
".",
"Amclusterable",
",",
"&",
"pa",
".",
"Ampredlocks",
",",
"&",
"pa",
".",
"Amkeytype",
",",
"&",
"pa",
".",
"Aminsert",
",",
"&",
"pa",
".",
"Ambeginscan",
",",
"&",
"pa",
".",
"Amgettuple",
",",
"&",
"pa",
".",
"Amgetbitmap",
",",
"&",
"pa",
".",
"Amrescan",
",",
"&",
"pa",
".",
"Amendscan",
",",
"&",
"pa",
".",
"Ammarkpos",
",",
"&",
"pa",
".",
"Amrestrpos",
",",
"&",
"pa",
".",
"Ambuild",
",",
"&",
"pa",
".",
"Ambuildempty",
",",
"&",
"pa",
".",
"Ambulkdelete",
",",
"&",
"pa",
".",
"Amvacuumcleanup",
",",
"&",
"pa",
".",
"Amcanreturn",
",",
"&",
"pa",
".",
"Amcostestimate",
",",
"&",
"pa",
".",
"Amoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmByAmname retrieves a row from 'pg_catalog.pg_am' as a PgAm.
//
// Generated from index 'pg_am_name_index'. | [
"PgAmByAmname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_am",
"as",
"a",
"PgAm",
".",
"Generated",
"from",
"index",
"pg_am_name_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41768-L41787 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy | func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(db XODB, amopfamily pgtypes.Oid, amoplefttype pgtypes.Oid, amoprighttype pgtypes.Oid, amopstrategy int16) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`
// run query
XOLog(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(db XODB, amopfamily pgtypes.Oid, amoplefttype pgtypes.Oid, amoprighttype pgtypes.Oid, amopstrategy int16) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`
// run query
XOLog(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy",
"(",
"db",
"XODB",
",",
"amopfamily",
"pgtypes",
".",
"Oid",
",",
"amoplefttype",
"pgtypes",
".",
"Oid",
",",
"amoprighttype",
"pgtypes",
".",
"Oid",
",",
"amopstrategy",
"int16",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amopfamily",
",",
"amoplefttype",
",",
"amoprighttype",
",",
"amopstrategy",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amopfamily",
",",
"amoplefttype",
",",
"amoprighttype",
",",
"amopstrategy",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_fam_strat_index'. | [
"PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_fam_strat_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41816-L41835 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmopByOid | func PgAmopByOid(db XODB, oid pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmop{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmopByOid(db XODB, oid pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmop{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmopByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmopByOid retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_oid_index'. | [
"PgAmopByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41840-L41859 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmopByAmopoprAmoppurposeAmopfamily | func PgAmopByAmopoprAmoppurposeAmopfamily(db XODB, amopopr pgtypes.Oid, amoppurpose uint8, amopfamily pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`
// run query
XOLog(sqlstr, amopopr, amoppurpose, amopfamily)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmopByAmopoprAmoppurposeAmopfamily(db XODB, amopopr pgtypes.Oid, amoppurpose uint8, amopfamily pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`
// run query
XOLog(sqlstr, amopopr, amoppurpose, amopfamily)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmopByAmopoprAmoppurposeAmopfamily",
"(",
"db",
"XODB",
",",
"amopopr",
"pgtypes",
".",
"Oid",
",",
"amoppurpose",
"uint8",
",",
"amopfamily",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amopopr",
",",
"amoppurpose",
",",
"amopfamily",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amopopr",
",",
"amoppurpose",
",",
"amopfamily",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmopByAmopoprAmoppurposeAmopfamily retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_opr_fam_index'. | [
"PgAmopByAmopoprAmoppurposeAmopfamily",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_opr_fam_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41864-L41883 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum | func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(db XODB, amprocfamily pgtypes.Oid, amproclefttype pgtypes.Oid, amprocrighttype pgtypes.Oid, amprocnum int16) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`
// run query
XOLog(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(db XODB, amprocfamily pgtypes.Oid, amproclefttype pgtypes.Oid, amprocrighttype pgtypes.Oid, amprocnum int16) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`
// run query
XOLog(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum",
"(",
"db",
"XODB",
",",
"amprocfamily",
"pgtypes",
".",
"Oid",
",",
"amproclefttype",
"pgtypes",
".",
"Oid",
",",
"amprocrighttype",
"pgtypes",
".",
"Oid",
",",
"amprocnum",
"int16",
")",
"(",
"*",
"PgAmproc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc `",
"+",
"`FROM pg_catalog.pg_amproc `",
"+",
"`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amprocfamily",
",",
"amproclefttype",
",",
"amprocrighttype",
",",
"amprocnum",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amprocfamily",
",",
"amproclefttype",
",",
"amprocrighttype",
",",
"amprocnum",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amprocfamily",
",",
"&",
"pa",
".",
"Amproclefttype",
",",
"&",
"pa",
".",
"Amprocrighttype",
",",
"&",
"pa",
".",
"Amprocnum",
",",
"&",
"pa",
".",
"Amproc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_fam_proc_index'. | [
"PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amproc",
"as",
"a",
"PgAmproc",
".",
"Generated",
"from",
"index",
"pg_amproc_fam_proc_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41888-L41907 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAmprocByOid | func PgAmprocByOid(db XODB, oid pgtypes.Oid) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAmprocByOid(db XODB, oid pgtypes.Oid) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAmprocByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmproc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc `",
"+",
"`FROM pg_catalog.pg_amproc `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amprocfamily",
",",
"&",
"pa",
".",
"Amproclefttype",
",",
"&",
"pa",
".",
"Amprocrighttype",
",",
"&",
"pa",
".",
"Amprocnum",
",",
"&",
"pa",
".",
"Amproc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAmprocByOid retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_oid_index'. | [
"PgAmprocByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amproc",
"as",
"a",
"PgAmproc",
".",
"Generated",
"from",
"index",
"pg_amproc_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41912-L41931 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAttrdefByAdrelidAdnum | func PgAttrdefByAdrelidAdnum(db XODB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE adrelid = $1 AND adnum = $2`
// run query
XOLog(sqlstr, adrelid, adnum)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAttrdefByAdrelidAdnum(db XODB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE adrelid = $1 AND adnum = $2`
// run query
XOLog(sqlstr, adrelid, adnum)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAttrdefByAdrelidAdnum",
"(",
"db",
"XODB",
",",
"adrelid",
"pgtypes",
".",
"Oid",
",",
"adnum",
"int16",
")",
"(",
"*",
"PgAttrdef",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc `",
"+",
"`FROM pg_catalog.pg_attrdef `",
"+",
"`WHERE adrelid = $1 AND adnum = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"adrelid",
",",
"adnum",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"adrelid",
",",
"adnum",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Adrelid",
",",
"&",
"pa",
".",
"Adnum",
",",
"&",
"pa",
".",
"Adbin",
",",
"&",
"pa",
".",
"Adsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAttrdefByAdrelidAdnum retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_adrelid_adnum_index'. | [
"PgAttrdefByAdrelidAdnum",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attrdef",
"as",
"a",
"PgAttrdef",
".",
"Generated",
"from",
"index",
"pg_attrdef_adrelid_adnum_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41936-L41955 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAttrdefByOid | func PgAttrdefByOid(db XODB, oid pgtypes.Oid) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAttrdefByOid(db XODB, oid pgtypes.Oid) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAttrdefByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAttrdef",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc `",
"+",
"`FROM pg_catalog.pg_attrdef `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Adrelid",
",",
"&",
"pa",
".",
"Adnum",
",",
"&",
"pa",
".",
"Adbin",
",",
"&",
"pa",
".",
"Adsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAttrdefByOid retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_oid_index'. | [
"PgAttrdefByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attrdef",
"as",
"a",
"PgAttrdef",
".",
"Generated",
"from",
"index",
"pg_attrdef_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41960-L41979 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAttributeByAttrelidAttname | func PgAttributeByAttrelidAttname(db XODB, attrelid pgtypes.Oid, attname pgtypes.Name) (*PgAttribute, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions ` +
`FROM pg_catalog.pg_attribute ` +
`WHERE attrelid = $1 AND attname = $2`
// run query
XOLog(sqlstr, attrelid, attname)
pa := PgAttribute{}
err = db.QueryRow(sqlstr, attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAttributeByAttrelidAttname(db XODB, attrelid pgtypes.Oid, attname pgtypes.Name) (*PgAttribute, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions ` +
`FROM pg_catalog.pg_attribute ` +
`WHERE attrelid = $1 AND attname = $2`
// run query
XOLog(sqlstr, attrelid, attname)
pa := PgAttribute{}
err = db.QueryRow(sqlstr, attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAttributeByAttrelidAttname",
"(",
"db",
"XODB",
",",
"attrelid",
"pgtypes",
".",
"Oid",
",",
"attname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgAttribute",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions `",
"+",
"`FROM pg_catalog.pg_attribute `",
"+",
"`WHERE attrelid = $1 AND attname = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"attrelid",
",",
"attname",
")",
"\n",
"pa",
":=",
"PgAttribute",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"attrelid",
",",
"attname",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Attrelid",
",",
"&",
"pa",
".",
"Attname",
",",
"&",
"pa",
".",
"Atttypid",
",",
"&",
"pa",
".",
"Attstattarget",
",",
"&",
"pa",
".",
"Attlen",
",",
"&",
"pa",
".",
"Attnum",
",",
"&",
"pa",
".",
"Attndims",
",",
"&",
"pa",
".",
"Attcacheoff",
",",
"&",
"pa",
".",
"Atttypmod",
",",
"&",
"pa",
".",
"Attbyval",
",",
"&",
"pa",
".",
"Attstorage",
",",
"&",
"pa",
".",
"Attalign",
",",
"&",
"pa",
".",
"Attnotnull",
",",
"&",
"pa",
".",
"Atthasdef",
",",
"&",
"pa",
".",
"Attisdropped",
",",
"&",
"pa",
".",
"Attislocal",
",",
"&",
"pa",
".",
"Attinhcount",
",",
"&",
"pa",
".",
"Attcollation",
",",
"&",
"pa",
".",
"Attacl",
",",
"&",
"pa",
".",
"Attoptions",
",",
"&",
"pa",
".",
"Attfdwoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAttributeByAttrelidAttname retrieves a row from 'pg_catalog.pg_attribute' as a PgAttribute.
//
// Generated from index 'pg_attribute_relid_attnam_index'. | [
"PgAttributeByAttrelidAttname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attribute",
"as",
"a",
"PgAttribute",
".",
"Generated",
"from",
"index",
"pg_attribute_relid_attnam_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41984-L42003 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAuthMemberByMemberRoleid | func PgAuthMemberByMemberRoleid(db XODB, member pgtypes.Oid, roleid pgtypes.Oid) (*PgAuthMember, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
`FROM pg_catalog.pg_auth_members ` +
`WHERE member = $1 AND roleid = $2`
// run query
XOLog(sqlstr, member, roleid)
pam := PgAuthMember{}
err = db.QueryRow(sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption)
if err != nil {
return nil, err
}
return &pam, nil
} | go | func PgAuthMemberByMemberRoleid(db XODB, member pgtypes.Oid, roleid pgtypes.Oid) (*PgAuthMember, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
`FROM pg_catalog.pg_auth_members ` +
`WHERE member = $1 AND roleid = $2`
// run query
XOLog(sqlstr, member, roleid)
pam := PgAuthMember{}
err = db.QueryRow(sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption)
if err != nil {
return nil, err
}
return &pam, nil
} | [
"func",
"PgAuthMemberByMemberRoleid",
"(",
"db",
"XODB",
",",
"member",
"pgtypes",
".",
"Oid",
",",
"roleid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAuthMember",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option `",
"+",
"`FROM pg_catalog.pg_auth_members `",
"+",
"`WHERE member = $1 AND roleid = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"member",
",",
"roleid",
")",
"\n",
"pam",
":=",
"PgAuthMember",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"member",
",",
"roleid",
")",
".",
"Scan",
"(",
"&",
"pam",
".",
"Tableoid",
",",
"&",
"pam",
".",
"Cmax",
",",
"&",
"pam",
".",
"Xmax",
",",
"&",
"pam",
".",
"Cmin",
",",
"&",
"pam",
".",
"Xmin",
",",
"&",
"pam",
".",
"Ctid",
",",
"&",
"pam",
".",
"Roleid",
",",
"&",
"pam",
".",
"Member",
",",
"&",
"pam",
".",
"Grantor",
",",
"&",
"pam",
".",
"AdminOption",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pam",
",",
"nil",
"\n",
"}"
] | // PgAuthMemberByMemberRoleid retrieves a row from 'pg_catalog.pg_auth_members' as a PgAuthMember.
//
// Generated from index 'pg_auth_members_member_role_index'. | [
"PgAuthMemberByMemberRoleid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_auth_members",
"as",
"a",
"PgAuthMember",
".",
"Generated",
"from",
"index",
"pg_auth_members_member_role_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42032-L42051 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgAuthidByOid | func PgAuthidByOid(db XODB, oid pgtypes.Oid) (*PgAuthid, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
`FROM pg_catalog.pg_authid ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAuthid{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil)
if err != nil {
return nil, err
}
return &pa, nil
} | go | func PgAuthidByOid(db XODB, oid pgtypes.Oid) (*PgAuthid, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
`FROM pg_catalog.pg_authid ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAuthid{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil)
if err != nil {
return nil, err
}
return &pa, nil
} | [
"func",
"PgAuthidByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAuthid",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil `",
"+",
"`FROM pg_catalog.pg_authid `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAuthid",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Rolname",
",",
"&",
"pa",
".",
"Rolsuper",
",",
"&",
"pa",
".",
"Rolinherit",
",",
"&",
"pa",
".",
"Rolcreaterole",
",",
"&",
"pa",
".",
"Rolcreatedb",
",",
"&",
"pa",
".",
"Rolcanlogin",
",",
"&",
"pa",
".",
"Rolreplication",
",",
"&",
"pa",
".",
"Rolbypassrls",
",",
"&",
"pa",
".",
"Rolconnlimit",
",",
"&",
"pa",
".",
"Rolpassword",
",",
"&",
"pa",
".",
"Rolvaliduntil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] | // PgAuthidByOid retrieves a row from 'pg_catalog.pg_authid' as a PgAuthid.
//
// Generated from index 'pg_authid_oid_index'. | [
"PgAuthidByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_authid",
"as",
"a",
"PgAuthid",
".",
"Generated",
"from",
"index",
"pg_authid_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42080-L42099 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgCastByOid | func PgCastByOid(db XODB, oid pgtypes.Oid) (*PgCast, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod ` +
`FROM pg_catalog.pg_cast ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCast{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgCastByOid(db XODB, oid pgtypes.Oid) (*PgCast, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod ` +
`FROM pg_catalog.pg_cast ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCast{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgCastByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCast",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod `",
"+",
"`FROM pg_catalog.pg_cast `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCast",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Castsource",
",",
"&",
"pc",
".",
"Casttarget",
",",
"&",
"pc",
".",
"Castfunc",
",",
"&",
"pc",
".",
"Castcontext",
",",
"&",
"pc",
".",
"Castmethod",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgCastByOid retrieves a row from 'pg_catalog.pg_cast' as a PgCast.
//
// Generated from index 'pg_cast_oid_index'. | [
"PgCastByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_cast",
"as",
"a",
"PgCast",
".",
"Generated",
"from",
"index",
"pg_cast_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42128-L42147 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgClassByOid | func PgClassByOid(db XODB, oid pgtypes.Oid) (*PgClass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions ` +
`FROM pg_catalog.pg_class ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgClass{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasoids, &pc.Relhaspkey, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgClassByOid(db XODB, oid pgtypes.Oid) (*PgClass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions ` +
`FROM pg_catalog.pg_class ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgClass{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasoids, &pc.Relhaspkey, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgClassByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgClass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions `",
"+",
"`FROM pg_catalog.pg_class `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgClass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Relname",
",",
"&",
"pc",
".",
"Relnamespace",
",",
"&",
"pc",
".",
"Reltype",
",",
"&",
"pc",
".",
"Reloftype",
",",
"&",
"pc",
".",
"Relowner",
",",
"&",
"pc",
".",
"Relam",
",",
"&",
"pc",
".",
"Relfilenode",
",",
"&",
"pc",
".",
"Reltablespace",
",",
"&",
"pc",
".",
"Relpages",
",",
"&",
"pc",
".",
"Reltuples",
",",
"&",
"pc",
".",
"Relallvisible",
",",
"&",
"pc",
".",
"Reltoastrelid",
",",
"&",
"pc",
".",
"Relhasindex",
",",
"&",
"pc",
".",
"Relisshared",
",",
"&",
"pc",
".",
"Relpersistence",
",",
"&",
"pc",
".",
"Relkind",
",",
"&",
"pc",
".",
"Relnatts",
",",
"&",
"pc",
".",
"Relchecks",
",",
"&",
"pc",
".",
"Relhasoids",
",",
"&",
"pc",
".",
"Relhaspkey",
",",
"&",
"pc",
".",
"Relhasrules",
",",
"&",
"pc",
".",
"Relhastriggers",
",",
"&",
"pc",
".",
"Relhassubclass",
",",
"&",
"pc",
".",
"Relrowsecurity",
",",
"&",
"pc",
".",
"Relforcerowsecurity",
",",
"&",
"pc",
".",
"Relispopulated",
",",
"&",
"pc",
".",
"Relreplident",
",",
"&",
"pc",
".",
"Relfrozenxid",
",",
"&",
"pc",
".",
"Relminmxid",
",",
"&",
"pc",
".",
"Relacl",
",",
"&",
"pc",
".",
"Reloptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgClassByOid retrieves a row from 'pg_catalog.pg_class' as a PgClass.
//
// Generated from index 'pg_class_oid_index'. | [
"PgClassByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_class",
"as",
"a",
"PgClass",
".",
"Generated",
"from",
"index",
"pg_class_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42176-L42195 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgCollationByCollnameCollencodingCollnamespace | func PgCollationByCollnameCollencodingCollnamespace(db XODB, collname pgtypes.Name, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`
// run query
XOLog(sqlstr, collname, collencoding, collnamespace)
pc := PgCollation{}
err = db.QueryRow(sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgCollationByCollnameCollencodingCollnamespace(db XODB, collname pgtypes.Name, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`
// run query
XOLog(sqlstr, collname, collencoding, collnamespace)
pc := PgCollation{}
err = db.QueryRow(sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgCollationByCollnameCollencodingCollnamespace",
"(",
"db",
"XODB",
",",
"collname",
"pgtypes",
".",
"Name",
",",
"collencoding",
"int",
",",
"collnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCollation",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype `",
"+",
"`FROM pg_catalog.pg_collation `",
"+",
"`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"collname",
",",
"collencoding",
",",
"collnamespace",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"collname",
",",
"collencoding",
",",
"collnamespace",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Collname",
",",
"&",
"pc",
".",
"Collnamespace",
",",
"&",
"pc",
".",
"Collowner",
",",
"&",
"pc",
".",
"Collencoding",
",",
"&",
"pc",
".",
"Collcollate",
",",
"&",
"pc",
".",
"Collctype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgCollationByCollnameCollencodingCollnamespace retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_name_enc_nsp_index'. | [
"PgCollationByCollnameCollencodingCollnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_collation",
"as",
"a",
"PgCollation",
".",
"Generated",
"from",
"index",
"pg_collation_name_enc_nsp_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42261-L42280 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgCollationByOid | func PgCollationByOid(db XODB, oid pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCollation{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgCollationByOid(db XODB, oid pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCollation{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgCollationByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCollation",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype `",
"+",
"`FROM pg_catalog.pg_collation `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Collname",
",",
"&",
"pc",
".",
"Collnamespace",
",",
"&",
"pc",
".",
"Collowner",
",",
"&",
"pc",
".",
"Collencoding",
",",
"&",
"pc",
".",
"Collcollate",
",",
"&",
"pc",
".",
"Collctype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgCollationByOid retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_oid_index'. | [
"PgCollationByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_collation",
"as",
"a",
"PgCollation",
".",
"Generated",
"from",
"index",
"pg_collation_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42285-L42304 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgConstraintsByConnameConnamespace | func PgConstraintsByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) ([]*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE conname = $1 AND connamespace = $2`
// run query
XOLog(sqlstr, conname, connamespace)
q, err := db.Query(sqlstr, conname, connamespace)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgConstraint{}
for q.Next() {
pc := PgConstraint{}
// scan
err = q.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
res = append(res, &pc)
}
return res, nil
} | go | func PgConstraintsByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) ([]*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE conname = $1 AND connamespace = $2`
// run query
XOLog(sqlstr, conname, connamespace)
q, err := db.Query(sqlstr, conname, connamespace)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgConstraint{}
for q.Next() {
pc := PgConstraint{}
// scan
err = q.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
res = append(res, &pc)
}
return res, nil
} | [
"func",
"PgConstraintsByConnameConnamespace",
"(",
"db",
"XODB",
",",
"conname",
"pgtypes",
".",
"Name",
",",
"connamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgConstraint",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc `",
"+",
"`FROM pg_catalog.pg_constraint `",
"+",
"`WHERE conname = $1 AND connamespace = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"conname",
",",
"connamespace",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"conname",
",",
"connamespace",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgConstraint",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Contype",
",",
"&",
"pc",
".",
"Condeferrable",
",",
"&",
"pc",
".",
"Condeferred",
",",
"&",
"pc",
".",
"Convalidated",
",",
"&",
"pc",
".",
"Conrelid",
",",
"&",
"pc",
".",
"Contypid",
",",
"&",
"pc",
".",
"Conindid",
",",
"&",
"pc",
".",
"Confrelid",
",",
"&",
"pc",
".",
"Confupdtype",
",",
"&",
"pc",
".",
"Confdeltype",
",",
"&",
"pc",
".",
"Confmatchtype",
",",
"&",
"pc",
".",
"Conislocal",
",",
"&",
"pc",
".",
"Coninhcount",
",",
"&",
"pc",
".",
"Connoinherit",
",",
"&",
"pc",
".",
"Conkey",
",",
"&",
"pc",
".",
"Confkey",
",",
"&",
"pc",
".",
"Conpfeqop",
",",
"&",
"pc",
".",
"Conppeqop",
",",
"&",
"pc",
".",
"Conffeqop",
",",
"&",
"pc",
".",
"Conexclop",
",",
"&",
"pc",
".",
"Conbin",
",",
"&",
"pc",
".",
"Consrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pc",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgConstraintsByConnameConnamespace retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_conname_nsp_index'. | [
"PgConstraintsByConnameConnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_constraint",
"as",
"a",
"PgConstraint",
".",
"Generated",
"from",
"index",
"pg_constraint_conname_nsp_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42309-L42341 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgConstraintByOid | func PgConstraintByOid(db XODB, oid pgtypes.Oid) (*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgConstraint{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgConstraintByOid(db XODB, oid pgtypes.Oid) (*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgConstraint{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgConstraintByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgConstraint",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc `",
"+",
"`FROM pg_catalog.pg_constraint `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Contype",
",",
"&",
"pc",
".",
"Condeferrable",
",",
"&",
"pc",
".",
"Condeferred",
",",
"&",
"pc",
".",
"Convalidated",
",",
"&",
"pc",
".",
"Conrelid",
",",
"&",
"pc",
".",
"Contypid",
",",
"&",
"pc",
".",
"Conindid",
",",
"&",
"pc",
".",
"Confrelid",
",",
"&",
"pc",
".",
"Confupdtype",
",",
"&",
"pc",
".",
"Confdeltype",
",",
"&",
"pc",
".",
"Confmatchtype",
",",
"&",
"pc",
".",
"Conislocal",
",",
"&",
"pc",
".",
"Coninhcount",
",",
"&",
"pc",
".",
"Connoinherit",
",",
"&",
"pc",
".",
"Conkey",
",",
"&",
"pc",
".",
"Confkey",
",",
"&",
"pc",
".",
"Conpfeqop",
",",
"&",
"pc",
".",
"Conppeqop",
",",
"&",
"pc",
".",
"Conffeqop",
",",
"&",
"pc",
".",
"Conexclop",
",",
"&",
"pc",
".",
"Conbin",
",",
"&",
"pc",
".",
"Consrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgConstraintByOid retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_oid_index'. | [
"PgConstraintByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_constraint",
"as",
"a",
"PgConstraint",
".",
"Generated",
"from",
"index",
"pg_constraint_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42420-L42439 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgConversionByConnamespaceConforencodingContoencodingOid | func PgConversionByConnamespaceConforencodingContoencodingOid(db XODB, connamespace pgtypes.Oid, conforencoding int, contoencoding int, oid pgtypes.Oid) (*PgConversion, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
`FROM pg_catalog.pg_conversion ` +
`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`
// run query
XOLog(sqlstr, connamespace, conforencoding, contoencoding, oid)
pc := PgConversion{}
err = db.QueryRow(sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault)
if err != nil {
return nil, err
}
return &pc, nil
} | go | func PgConversionByConnamespaceConforencodingContoencodingOid(db XODB, connamespace pgtypes.Oid, conforencoding int, contoencoding int, oid pgtypes.Oid) (*PgConversion, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
`FROM pg_catalog.pg_conversion ` +
`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`
// run query
XOLog(sqlstr, connamespace, conforencoding, contoencoding, oid)
pc := PgConversion{}
err = db.QueryRow(sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault)
if err != nil {
return nil, err
}
return &pc, nil
} | [
"func",
"PgConversionByConnamespaceConforencodingContoencodingOid",
"(",
"db",
"XODB",
",",
"connamespace",
"pgtypes",
".",
"Oid",
",",
"conforencoding",
"int",
",",
"contoencoding",
"int",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgConversion",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault `",
"+",
"`FROM pg_catalog.pg_conversion `",
"+",
"`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"connamespace",
",",
"conforencoding",
",",
"contoencoding",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConversion",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"connamespace",
",",
"conforencoding",
",",
"contoencoding",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Conowner",
",",
"&",
"pc",
".",
"Conforencoding",
",",
"&",
"pc",
".",
"Contoencoding",
",",
"&",
"pc",
".",
"Conproc",
",",
"&",
"pc",
".",
"Condefault",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] | // PgConversionByConnamespaceConforencodingContoencodingOid retrieves a row from 'pg_catalog.pg_conversion' as a PgConversion.
//
// Generated from index 'pg_conversion_default_index'. | [
"PgConversionByConnamespaceConforencodingContoencodingOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_conversion",
"as",
"a",
"PgConversion",
".",
"Generated",
"from",
"index",
"pg_conversion_default_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42444-L42463 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDatabaseByDatname | func PgDatabaseByDatname(db XODB, datname pgtypes.Name) (*PgDatabase, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
`FROM pg_catalog.pg_database ` +
`WHERE datname = $1`
// run query
XOLog(sqlstr, datname)
pd := PgDatabase{}
err = db.QueryRow(sqlstr, datname).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Oid, &pd.Ctid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl)
if err != nil {
return nil, err
}
return &pd, nil
} | go | func PgDatabaseByDatname(db XODB, datname pgtypes.Name) (*PgDatabase, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
`FROM pg_catalog.pg_database ` +
`WHERE datname = $1`
// run query
XOLog(sqlstr, datname)
pd := PgDatabase{}
err = db.QueryRow(sqlstr, datname).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Oid, &pd.Ctid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl)
if err != nil {
return nil, err
}
return &pd, nil
} | [
"func",
"PgDatabaseByDatname",
"(",
"db",
"XODB",
",",
"datname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgDatabase",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl `",
"+",
"`FROM pg_catalog.pg_database `",
"+",
"`WHERE datname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"datname",
")",
"\n",
"pd",
":=",
"PgDatabase",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"datname",
")",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Oid",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Datname",
",",
"&",
"pd",
".",
"Datdba",
",",
"&",
"pd",
".",
"Encoding",
",",
"&",
"pd",
".",
"Datcollate",
",",
"&",
"pd",
".",
"Datctype",
",",
"&",
"pd",
".",
"Datistemplate",
",",
"&",
"pd",
".",
"Datallowconn",
",",
"&",
"pd",
".",
"Datconnlimit",
",",
"&",
"pd",
".",
"Datlastsysoid",
",",
"&",
"pd",
".",
"Datfrozenxid",
",",
"&",
"pd",
".",
"Datminmxid",
",",
"&",
"pd",
".",
"Dattablespace",
",",
"&",
"pd",
".",
"Datacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pd",
",",
"nil",
"\n",
"}"
] | // PgDatabaseByDatname retrieves a row from 'pg_catalog.pg_database' as a PgDatabase.
//
// Generated from index 'pg_database_datname_index'. | [
"PgDatabaseByDatname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_database",
"as",
"a",
"PgDatabase",
".",
"Generated",
"from",
"index",
"pg_database_datname_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42516-L42535 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDbRoleSettingBySetdatabaseSetrole | func PgDbRoleSettingBySetdatabaseSetrole(db XODB, setdatabase pgtypes.Oid, setrole pgtypes.Oid) (*PgDbRoleSetting, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig ` +
`FROM pg_catalog.pg_db_role_setting ` +
`WHERE setdatabase = $1 AND setrole = $2`
// run query
XOLog(sqlstr, setdatabase, setrole)
pdrs := PgDbRoleSetting{}
err = db.QueryRow(sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig)
if err != nil {
return nil, err
}
return &pdrs, nil
} | go | func PgDbRoleSettingBySetdatabaseSetrole(db XODB, setdatabase pgtypes.Oid, setrole pgtypes.Oid) (*PgDbRoleSetting, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig ` +
`FROM pg_catalog.pg_db_role_setting ` +
`WHERE setdatabase = $1 AND setrole = $2`
// run query
XOLog(sqlstr, setdatabase, setrole)
pdrs := PgDbRoleSetting{}
err = db.QueryRow(sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig)
if err != nil {
return nil, err
}
return &pdrs, nil
} | [
"func",
"PgDbRoleSettingBySetdatabaseSetrole",
"(",
"db",
"XODB",
",",
"setdatabase",
"pgtypes",
".",
"Oid",
",",
"setrole",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgDbRoleSetting",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig `",
"+",
"`FROM pg_catalog.pg_db_role_setting `",
"+",
"`WHERE setdatabase = $1 AND setrole = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"setdatabase",
",",
"setrole",
")",
"\n",
"pdrs",
":=",
"PgDbRoleSetting",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"setdatabase",
",",
"setrole",
")",
".",
"Scan",
"(",
"&",
"pdrs",
".",
"Tableoid",
",",
"&",
"pdrs",
".",
"Cmax",
",",
"&",
"pdrs",
".",
"Xmax",
",",
"&",
"pdrs",
".",
"Cmin",
",",
"&",
"pdrs",
".",
"Xmin",
",",
"&",
"pdrs",
".",
"Ctid",
",",
"&",
"pdrs",
".",
"Setdatabase",
",",
"&",
"pdrs",
".",
"Setrole",
",",
"&",
"pdrs",
".",
"Setconfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pdrs",
",",
"nil",
"\n",
"}"
] | // PgDbRoleSettingBySetdatabaseSetrole retrieves a row from 'pg_catalog.pg_db_role_setting' as a PgDbRoleSetting.
//
// Generated from index 'pg_db_role_setting_databaseid_rol_index'. | [
"PgDbRoleSettingBySetdatabaseSetrole",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_db_role_setting",
"as",
"a",
"PgDbRoleSetting",
".",
"Generated",
"from",
"index",
"pg_db_role_setting_databaseid_rol_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42564-L42583 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDefaultACLByOid | func PgDefaultACLByOid(db XODB, oid pgtypes.Oid) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | go | func PgDefaultACLByOid(db XODB, oid pgtypes.Oid) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | [
"func",
"PgDefaultACLByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgDefaultACL",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl `",
"+",
"`FROM pg_catalog.pg_default_acl `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pda",
".",
"Tableoid",
",",
"&",
"pda",
".",
"Cmax",
",",
"&",
"pda",
".",
"Xmax",
",",
"&",
"pda",
".",
"Cmin",
",",
"&",
"pda",
".",
"Xmin",
",",
"&",
"pda",
".",
"Oid",
",",
"&",
"pda",
".",
"Ctid",
",",
"&",
"pda",
".",
"Defaclrole",
",",
"&",
"pda",
".",
"Defaclnamespace",
",",
"&",
"pda",
".",
"Defaclobjtype",
",",
"&",
"pda",
".",
"Defaclacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pda",
",",
"nil",
"\n",
"}"
] | // PgDefaultACLByOid retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_oid_index'. | [
"PgDefaultACLByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_default_acl",
"as",
"a",
"PgDefaultACL",
".",
"Generated",
"from",
"index",
"pg_default_acl_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42588-L42607 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype | func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(db XODB, defaclrole pgtypes.Oid, defaclnamespace pgtypes.Oid, defaclobjtype uint8) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`
// run query
XOLog(sqlstr, defaclrole, defaclnamespace, defaclobjtype)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | go | func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(db XODB, defaclrole pgtypes.Oid, defaclnamespace pgtypes.Oid, defaclobjtype uint8) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`
// run query
XOLog(sqlstr, defaclrole, defaclnamespace, defaclobjtype)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
} | [
"func",
"PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype",
"(",
"db",
"XODB",
",",
"defaclrole",
"pgtypes",
".",
"Oid",
",",
"defaclnamespace",
"pgtypes",
".",
"Oid",
",",
"defaclobjtype",
"uint8",
")",
"(",
"*",
"PgDefaultACL",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl `",
"+",
"`FROM pg_catalog.pg_default_acl `",
"+",
"`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"defaclrole",
",",
"defaclnamespace",
",",
"defaclobjtype",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"defaclrole",
",",
"defaclnamespace",
",",
"defaclobjtype",
")",
".",
"Scan",
"(",
"&",
"pda",
".",
"Tableoid",
",",
"&",
"pda",
".",
"Cmax",
",",
"&",
"pda",
".",
"Xmax",
",",
"&",
"pda",
".",
"Cmin",
",",
"&",
"pda",
".",
"Xmin",
",",
"&",
"pda",
".",
"Oid",
",",
"&",
"pda",
".",
"Ctid",
",",
"&",
"pda",
".",
"Defaclrole",
",",
"&",
"pda",
".",
"Defaclnamespace",
",",
"&",
"pda",
".",
"Defaclobjtype",
",",
"&",
"pda",
".",
"Defaclacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pda",
",",
"nil",
"\n",
"}"
] | // PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_role_nsp_obj_index'. | [
"PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_default_acl",
"as",
"a",
"PgDefaultACL",
".",
"Generated",
"from",
"index",
"pg_default_acl_role_nsp_obj_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42612-L42631 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDependsByClassidObjidObjsubid | func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
} | go | func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
} | [
"func",
"PgDependsByClassidObjidObjsubid",
"(",
"db",
"XODB",
",",
"classid",
"pgtypes",
".",
"Oid",
",",
"objid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"[",
"]",
"*",
"PgDepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype `",
"+",
"`FROM pg_catalog.pg_depend `",
"+",
"`WHERE classid = $1 AND objid = $2 AND objsubid = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgDepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pd",
":=",
"PgDepend",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Classid",
",",
"&",
"pd",
".",
"Objid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Refclassid",
",",
"&",
"pd",
".",
"Refobjid",
",",
"&",
"pd",
".",
"Refobjsubid",
",",
"&",
"pd",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pd",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgDependsByClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_depend' as a PgDepend.
//
// Generated from index 'pg_depend_depender_index'. | [
"PgDependsByClassidObjidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_depend",
"as",
"a",
"PgDepend",
".",
"Generated",
"from",
"index",
"pg_depend_depender_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42636-L42668 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgDescriptionByObjoidClassoidObjsubid | func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
} | go | func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
} | [
"func",
"PgDescriptionByObjoidClassoidObjsubid",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"*",
"PgDescription",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description `",
"+",
"`FROM pg_catalog.pg_description `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
"\n",
"pd",
":=",
"PgDescription",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Objoid",
",",
"&",
"pd",
".",
"Classoid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Description",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pd",
",",
"nil",
"\n",
"}"
] | // PgDescriptionByObjoidClassoidObjsubid retrieves a row from 'pg_catalog.pg_description' as a PgDescription.
//
// Generated from index 'pg_description_o_c_o_index'. | [
"PgDescriptionByObjoidClassoidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_description",
"as",
"a",
"PgDescription",
".",
"Generated",
"from",
"index",
"pg_description_o_c_o_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42710-L42729 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgEnumByOid | func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | go | func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | [
"func",
"PgEnumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] | // PgEnumByOid retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_oid_index'. | [
"PgEnumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42734-L42753 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgEnumByEnumtypidEnumlabel | func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | go | func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | [
"func",
"PgEnumByEnumtypidEnumlabel",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumlabel",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumlabel = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] | // PgEnumByEnumtypidEnumlabel retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_label_index'. | [
"PgEnumByEnumtypidEnumlabel",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_label_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42758-L42777 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgEnumByEnumtypidEnumsortorder | func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | go | func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
} | [
"func",
"PgEnumByEnumtypidEnumsortorder",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumsortorder",
"float32",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumsortorder = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] | // PgEnumByEnumtypidEnumsortorder retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_sortorder_index'. | [
"PgEnumByEnumtypidEnumsortorder",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_sortorder_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42782-L42801 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgEventTriggerByEvtname | func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
} | go | func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
} | [
"func",
"PgEventTriggerByEvtname",
"(",
"db",
"XODB",
",",
"evtname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEventTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags `",
"+",
"`FROM pg_catalog.pg_event_trigger `",
"+",
"`WHERE evtname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"evtname",
")",
"\n",
"pet",
":=",
"PgEventTrigger",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"evtname",
")",
".",
"Scan",
"(",
"&",
"pet",
".",
"Tableoid",
",",
"&",
"pet",
".",
"Cmax",
",",
"&",
"pet",
".",
"Xmax",
",",
"&",
"pet",
".",
"Cmin",
",",
"&",
"pet",
".",
"Xmin",
",",
"&",
"pet",
".",
"Oid",
",",
"&",
"pet",
".",
"Ctid",
",",
"&",
"pet",
".",
"Evtname",
",",
"&",
"pet",
".",
"Evtevent",
",",
"&",
"pet",
".",
"Evtowner",
",",
"&",
"pet",
".",
"Evtfoid",
",",
"&",
"pet",
".",
"Evtenabled",
",",
"&",
"pet",
".",
"Evttags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pet",
",",
"nil",
"\n",
"}"
] | // PgEventTriggerByEvtname retrieves a row from 'pg_catalog.pg_event_trigger' as a PgEventTrigger.
//
// Generated from index 'pg_event_trigger_evtname_index'. | [
"PgEventTriggerByEvtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_event_trigger",
"as",
"a",
"PgEventTrigger",
".",
"Generated",
"from",
"index",
"pg_event_trigger_evtname_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42806-L42825 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgExtensionByExtname | func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
} | go | func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
} | [
"func",
"PgExtensionByExtname",
"(",
"db",
"XODB",
",",
"extname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgExtension",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition `",
"+",
"`FROM pg_catalog.pg_extension `",
"+",
"`WHERE extname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"extname",
")",
"\n",
"pe",
":=",
"PgExtension",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"extname",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Extname",
",",
"&",
"pe",
".",
"Extowner",
",",
"&",
"pe",
".",
"Extnamespace",
",",
"&",
"pe",
".",
"Extrelocatable",
",",
"&",
"pe",
".",
"Extversion",
",",
"&",
"pe",
".",
"Extconfig",
",",
"&",
"pe",
".",
"Extcondition",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] | // PgExtensionByExtname retrieves a row from 'pg_catalog.pg_extension' as a PgExtension.
//
// Generated from index 'pg_extension_name_index'. | [
"PgExtensionByExtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_extension",
"as",
"a",
"PgExtension",
".",
"Generated",
"from",
"index",
"pg_extension_name_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42854-L42873 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgForeignDataWrapperByOid | func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
} | go | func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
} | [
"func",
"PgForeignDataWrapperByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignDataWrapper",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions `",
"+",
"`FROM pg_catalog.pg_foreign_data_wrapper `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pfdw",
":=",
"PgForeignDataWrapper",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pfdw",
".",
"Tableoid",
",",
"&",
"pfdw",
".",
"Cmax",
",",
"&",
"pfdw",
".",
"Xmax",
",",
"&",
"pfdw",
".",
"Cmin",
",",
"&",
"pfdw",
".",
"Xmin",
",",
"&",
"pfdw",
".",
"Oid",
",",
"&",
"pfdw",
".",
"Ctid",
",",
"&",
"pfdw",
".",
"Fdwname",
",",
"&",
"pfdw",
".",
"Fdwowner",
",",
"&",
"pfdw",
".",
"Fdwhandler",
",",
"&",
"pfdw",
".",
"Fdwvalidator",
",",
"&",
"pfdw",
".",
"Fdwacl",
",",
"&",
"pfdw",
".",
"Fdwoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pfdw",
",",
"nil",
"\n",
"}"
] | // PgForeignDataWrapperByOid retrieves a row from 'pg_catalog.pg_foreign_data_wrapper' as a PgForeignDataWrapper.
//
// Generated from index 'pg_foreign_data_wrapper_oid_index'. | [
"PgForeignDataWrapperByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_data_wrapper",
"as",
"a",
"PgForeignDataWrapper",
".",
"Generated",
"from",
"index",
"pg_foreign_data_wrapper_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42926-L42945 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgForeignServerBySrvname | func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
} | go | func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
} | [
"func",
"PgForeignServerBySrvname",
"(",
"db",
"XODB",
",",
"srvname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgForeignServer",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions `",
"+",
"`FROM pg_catalog.pg_foreign_server `",
"+",
"`WHERE srvname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"srvname",
")",
"\n",
"pfs",
":=",
"PgForeignServer",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"srvname",
")",
".",
"Scan",
"(",
"&",
"pfs",
".",
"Tableoid",
",",
"&",
"pfs",
".",
"Cmax",
",",
"&",
"pfs",
".",
"Xmax",
",",
"&",
"pfs",
".",
"Cmin",
",",
"&",
"pfs",
".",
"Xmin",
",",
"&",
"pfs",
".",
"Oid",
",",
"&",
"pfs",
".",
"Ctid",
",",
"&",
"pfs",
".",
"Srvname",
",",
"&",
"pfs",
".",
"Srvowner",
",",
"&",
"pfs",
".",
"Srvfdw",
",",
"&",
"pfs",
".",
"Srvtype",
",",
"&",
"pfs",
".",
"Srvversion",
",",
"&",
"pfs",
".",
"Srvacl",
",",
"&",
"pfs",
".",
"Srvoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pfs",
",",
"nil",
"\n",
"}"
] | // PgForeignServerBySrvname retrieves a row from 'pg_catalog.pg_foreign_server' as a PgForeignServer.
//
// Generated from index 'pg_foreign_server_name_index'. | [
"PgForeignServerBySrvname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_server",
"as",
"a",
"PgForeignServer",
".",
"Generated",
"from",
"index",
"pg_foreign_server_name_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42950-L42969 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgForeignTableByFtrelid | func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
} | go | func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
} | [
"func",
"PgForeignTableByFtrelid",
"(",
"db",
"XODB",
",",
"ftrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignTable",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions `",
"+",
"`FROM pg_catalog.pg_foreign_table `",
"+",
"`WHERE ftrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"ftrelid",
")",
"\n",
"pft",
":=",
"PgForeignTable",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"ftrelid",
")",
".",
"Scan",
"(",
"&",
"pft",
".",
"Tableoid",
",",
"&",
"pft",
".",
"Cmax",
",",
"&",
"pft",
".",
"Xmax",
",",
"&",
"pft",
".",
"Cmin",
",",
"&",
"pft",
".",
"Xmin",
",",
"&",
"pft",
".",
"Ctid",
",",
"&",
"pft",
".",
"Ftrelid",
",",
"&",
"pft",
".",
"Ftserver",
",",
"&",
"pft",
".",
"Ftoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pft",
",",
"nil",
"\n",
"}"
] | // PgForeignTableByFtrelid retrieves a row from 'pg_catalog.pg_foreign_table' as a PgForeignTable.
//
// Generated from index 'pg_foreign_table_relid_index'. | [
"PgForeignTableByFtrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_table",
"as",
"a",
"PgForeignTable",
".",
"Generated",
"from",
"index",
"pg_foreign_table_relid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42998-L43017 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgIndexByIndexrelid | func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
} | go | func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
} | [
"func",
"PgIndexByIndexrelid",
"(",
"db",
"XODB",
",",
"indexrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indexrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"indexrelid",
")",
"\n",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"indexrelid",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] | // PgIndexByIndexrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indexrelid_index'. | [
"PgIndexByIndexrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indexrelid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43022-L43041 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgIndicesByIndrelid | func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
} | go | func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
} | [
"func",
"PgIndicesByIndrelid",
"(",
"db",
"XODB",
",",
"indrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgIndex",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgIndicesByIndrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indrelid_index'. | [
"PgIndicesByIndrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indrelid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43046-L43078 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgInheritsByInhparent | func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
} | go | func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
} | [
"func",
"PgInheritsByInhparent",
"(",
"db",
"XODB",
",",
"inhparent",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhparent = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgInherit",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgInheritsByInhparent retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_parent_index'. | [
"PgInheritsByInhparent",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_parent_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43083-L43115 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgInheritByInhrelidInhseqno | func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
} | go | func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
} | [
"func",
"PgInheritByInhrelidInhseqno",
"(",
"db",
"XODB",
",",
"inhrelid",
"pgtypes",
".",
"Oid",
",",
"inhseqno",
"int",
")",
"(",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhrelid = $1 AND inhseqno = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
"\n",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] | // PgInheritByInhrelidInhseqno retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_relid_seqno_index'. | [
"PgInheritByInhrelidInhseqno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_relid_seqno_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43120-L43139 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgLanguageByLanname | func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
} | go | func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
} | [
"func",
"PgLanguageByLanname",
"(",
"db",
"XODB",
",",
"lanname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgLanguage",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl `",
"+",
"`FROM pg_catalog.pg_language `",
"+",
"`WHERE lanname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"lanname",
")",
"\n",
"pl",
":=",
"PgLanguage",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"lanname",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Oid",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Lanname",
",",
"&",
"pl",
".",
"Lanowner",
",",
"&",
"pl",
".",
"Lanispl",
",",
"&",
"pl",
".",
"Lanpltrusted",
",",
"&",
"pl",
".",
"Lanplcallfoid",
",",
"&",
"pl",
".",
"Laninline",
",",
"&",
"pl",
".",
"Lanvalidator",
",",
"&",
"pl",
".",
"Lanacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] | // PgLanguageByLanname retrieves a row from 'pg_catalog.pg_language' as a PgLanguage.
//
// Generated from index 'pg_language_name_index'. | [
"PgLanguageByLanname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_language",
"as",
"a",
"PgLanguage",
".",
"Generated",
"from",
"index",
"pg_language_name_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43144-L43163 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgLargeobjectByLoidPageno | func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
} | go | func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
} | [
"func",
"PgLargeobjectByLoidPageno",
"(",
"db",
"XODB",
",",
"loid",
"pgtypes",
".",
"Oid",
",",
"pageno",
"int",
")",
"(",
"*",
"PgLargeobject",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data `",
"+",
"`FROM pg_catalog.pg_largeobject `",
"+",
"`WHERE loid = $1 AND pageno = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
"\n",
"pl",
":=",
"PgLargeobject",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Loid",
",",
"&",
"pl",
".",
"Pageno",
",",
"&",
"pl",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] | // PgLargeobjectByLoidPageno retrieves a row from 'pg_catalog.pg_largeobject' as a PgLargeobject.
//
// Generated from index 'pg_largeobject_loid_pn_index'. | [
"PgLargeobjectByLoidPageno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject",
"as",
"a",
"PgLargeobject",
".",
"Generated",
"from",
"index",
"pg_largeobject_loid_pn_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43192-L43211 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgLargeobjectMetadatumByOid | func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
} | go | func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
} | [
"func",
"PgLargeobjectMetadatumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgLargeobjectMetadatum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl `",
"+",
"`FROM pg_catalog.pg_largeobject_metadata `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"plm",
":=",
"PgLargeobjectMetadatum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"plm",
".",
"Tableoid",
",",
"&",
"plm",
".",
"Cmax",
",",
"&",
"plm",
".",
"Xmax",
",",
"&",
"plm",
".",
"Cmin",
",",
"&",
"plm",
".",
"Xmin",
",",
"&",
"plm",
".",
"Oid",
",",
"&",
"plm",
".",
"Ctid",
",",
"&",
"plm",
".",
"Lomowner",
",",
"&",
"plm",
".",
"Lomacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"plm",
",",
"nil",
"\n",
"}"
] | // PgLargeobjectMetadatumByOid retrieves a row from 'pg_catalog.pg_largeobject_metadata' as a PgLargeobjectMetadatum.
//
// Generated from index 'pg_largeobject_metadata_oid_index'. | [
"PgLargeobjectMetadatumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject_metadata",
"as",
"a",
"PgLargeobjectMetadatum",
".",
"Generated",
"from",
"index",
"pg_largeobject_metadata_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43216-L43235 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgNamespaceByNspname | func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
} | go | func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
} | [
"func",
"PgNamespaceByNspname",
"(",
"db",
"XODB",
",",
"nspname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgNamespace",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl `",
"+",
"`FROM pg_catalog.pg_namespace `",
"+",
"`WHERE nspname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"nspname",
")",
"\n",
"pn",
":=",
"PgNamespace",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"nspname",
")",
".",
"Scan",
"(",
"&",
"pn",
".",
"Tableoid",
",",
"&",
"pn",
".",
"Cmax",
",",
"&",
"pn",
".",
"Xmax",
",",
"&",
"pn",
".",
"Cmin",
",",
"&",
"pn",
".",
"Xmin",
",",
"&",
"pn",
".",
"Oid",
",",
"&",
"pn",
".",
"Ctid",
",",
"&",
"pn",
".",
"Nspname",
",",
"&",
"pn",
".",
"Nspowner",
",",
"&",
"pn",
".",
"Nspacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pn",
",",
"nil",
"\n",
"}"
] | // PgNamespaceByNspname retrieves a row from 'pg_catalog.pg_namespace' as a PgNamespace.
//
// Generated from index 'pg_namespace_nspname_index'. | [
"PgNamespaceByNspname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_namespace",
"as",
"a",
"PgNamespace",
".",
"Generated",
"from",
"index",
"pg_namespace_nspname_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43240-L43259 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgOpclassByOpcmethodOpcnameOpcnamespace | func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
} | go | func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
} | [
"func",
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"(",
"db",
"XODB",
",",
"opcmethod",
"pgtypes",
".",
"Oid",
",",
"opcname",
"pgtypes",
".",
"Name",
",",
"opcnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] | // PgOpclassByOpcmethodOpcnameOpcnamespace retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_am_name_nsp_index'. | [
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_am_name_nsp_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43288-L43307 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgOpclassByOid | func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
} | go | func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
} | [
"func",
"PgOpclassByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] | // PgOpclassByOid retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_oid_index'. | [
"PgOpclassByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43312-L43331 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgOperatorByOid | func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
} | go | func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
} | [
"func",
"PgOperatorByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOperator",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin `",
"+",
"`FROM pg_catalog.pg_operator `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOperator",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Oprname",
",",
"&",
"po",
".",
"Oprnamespace",
",",
"&",
"po",
".",
"Oprowner",
",",
"&",
"po",
".",
"Oprkind",
",",
"&",
"po",
".",
"Oprcanmerge",
",",
"&",
"po",
".",
"Oprcanhash",
",",
"&",
"po",
".",
"Oprleft",
",",
"&",
"po",
".",
"Oprright",
",",
"&",
"po",
".",
"Oprresult",
",",
"&",
"po",
".",
"Oprcom",
",",
"&",
"po",
".",
"Oprnegate",
",",
"&",
"po",
".",
"Oprcode",
",",
"&",
"po",
".",
"Oprrest",
",",
"&",
"po",
".",
"Oprjoin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] | // PgOperatorByOid retrieves a row from 'pg_catalog.pg_operator' as a PgOperator.
//
// Generated from index 'pg_operator_oid_index'. | [
"PgOperatorByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_operator",
"as",
"a",
"PgOperator",
".",
"Generated",
"from",
"index",
"pg_operator_oid_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43336-L43355 | train |
xo/xo | examples/pgcatalog/pgcatalog/pgcatalog.xo.go | PgOpfamilyByOpfmethodOpfnameOpfnamespace | func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
} | go | func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
} | [
"func",
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"(",
"db",
"XODB",
",",
"opfmethod",
"pgtypes",
".",
"Oid",
",",
"opfname",
"pgtypes",
".",
"Name",
",",
"opfnamespace",
"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 opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
".",
"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",
"}"
] | // PgOpfamilyByOpfmethodOpfnameOpfnamespace retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_am_name_nsp_index'. | [
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opfamily",
"as",
"a",
"PgOpfamily",
".",
"Generated",
"from",
"index",
"pg_opfamily_am_name_nsp_index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43384-L43403 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.