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
list | docstring
stringlengths 6
2.61k
| docstring_tokens
list | 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",
"(",
"\"could not get initial namespace: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"initNl",
",",
"err",
"=",
"netlink",
".",
"NewHandle",
"(",
"getSupportedNlFamilies",
"(",
")",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Errorf",
"(",
"\"could not create netlink handle on initial namespace: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"initNl",
".",
"SetSocketTimeout",
"(",
"NetlinkSocketsTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"Failed to set the timeout on the default netlink handle sockets: %v\"",
",",
"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",
"(",
"\"failed to set to initial namespace, %v, initns fd %d: %v\"",
",",
"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",
"(",
"\"route for the next hop %s could not be found: %v\"",
",",
"nh",
",",
"err",
")",
"\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",
"(",
"\"sctp\"",
",",
"frontendAddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"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",
"(",
"\"Stopping proxy on sctp/%v for sctp/%v (%s)\"",
",",
"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",
"{",
"if",
"cuErr",
":=",
"ReleasePorts",
"(",
"portMapper",
",",
"bs",
")",
";",
"cuErr",
"!=",
"nil",
"{",
"logrus",
".",
"Warnf",
"(",
"\"Upon allocation failure for %v, failed to clear previously allocated port bindings: %v\"",
",",
"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",
"for",
"_",
",",
"m",
":=",
"range",
"bindings",
"{",
"if",
"err",
":=",
"releasePort",
"(",
"portMapper",
",",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"errorBuf",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"\\ncould not release %v because of %v\"",
",",
"\\n",
",",
"m",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"\n",
"if",
"errorBuf",
".",
"Len",
"(",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"errorBuf",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\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",
"(",
"\"node %s not found\"",
",",
"nodeName",
")",
"\n",
"}",
"\n",
"switch",
"newState",
"{",
"case",
"nodeActiveState",
":",
"if",
"currState",
"==",
"nodeActiveState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"n",
".",
"reapTime",
"=",
"0",
"\n",
"nDB",
".",
"nodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"case",
"nodeLeftState",
":",
"if",
"currState",
"==",
"nodeLeftState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"nDB",
".",
"leftNodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"case",
"nodeFailedState",
":",
"if",
"currState",
"==",
"nodeFailedState",
"{",
"return",
"false",
",",
"nil",
"\n",
"}",
"\n",
"delete",
"(",
"m",
",",
"nodeName",
")",
"\n",
"nDB",
".",
"failedNodes",
"[",
"nodeName",
"]",
"=",
"n",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"Node %s change state %s ",
",",
"nodeName",
",",
"nodeStateName",
"[",
"currState",
"]",
",",
"nodeStateName",
"[",
"newState",
"]",
")",
"\n",
"if",
"newState",
"==",
"nodeLeftState",
"||",
"newState",
"==",
"nodeFailedState",
"{",
"if",
"n",
".",
"reapTime",
"==",
"0",
"{",
"n",
".",
"reapTime",
"=",
"nodeReapInterval",
"\n",
"}",
"\n",
"nDB",
".",
"deleteNodeFromNetworks",
"(",
"n",
".",
"Name",
")",
"\n",
"nDB",
".",
"deleteNodeTableEntries",
"(",
"n",
".",
"Name",
")",
"\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",
"parts",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"len",
"(",
"cMsg",
".",
"Messages",
")",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"cMsg",
".",
"Messages",
"{",
"parts",
"=",
"append",
"(",
"parts",
",",
"m",
".",
"Payload",
")",
"\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",
"if",
"h",
".",
"store",
"==",
"nil",
"{",
"return",
"h",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"h",
".",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"h",
".",
"Exists",
"(",
")",
"{",
"if",
"err",
":=",
"h",
".",
"writeToStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to write bitsequence to store: %v\"",
",",
"err",
")",
"\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",
"=",
"\"end\"",
"\n",
"}",
"else",
"{",
"nextBlock",
"=",
"s",
".",
"next",
".",
"toString",
"(",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"(0x%x, %d)->%s\"",
",",
"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",
"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",
"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",
"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",
"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",
"(",
"\"cannot deserialize byte sequence of length %d (%v)\"",
",",
"l",
",",
"data",
")",
"\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",
"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",
"(",
"\"invalid bit range [%d, %d]\"",
",",
"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",
"if",
"store",
"!=",
"nil",
"{",
"if",
"err",
":=",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"nh",
":=",
"h",
".",
"getCopy",
"(",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"nh",
".",
"runConsistencyCheck",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"nh",
".",
"writeToStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"types",
".",
"RetryError",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"internal failure while fixing inconsistent bitsequence: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"Fixed inconsistent bit sequence in datastore:\\n%s\\n%s\"",
",",
"\\n",
",",
"\\n",
")",
"\n",
"h",
"\n",
"nh",
"\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"head",
"=",
"nh",
".",
"head",
"\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",
"(",
"\"bit does not belong to the sequence\"",
")",
"\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",
"(",
"\"internal failure while destroying the sequence: %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"h",
".",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"failed to fetch from store when destroying the sequence: %v\"",
",",
"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",
"(",
"\"failed to serialize head: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"ba",
"=",
"append",
"(",
"ba",
",",
"bm",
"...",
")",
"\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",
"(",
"\"nil byte array\"",
")",
"\n",
"}",
"\n",
"nh",
":=",
"&",
"sequence",
"{",
"}",
"\n",
"err",
":=",
"nh",
".",
"fromByteArray",
"(",
"ba",
"[",
"16",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"failed to deserialize head: %s\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\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",
"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",
"{",
"}",
"{",
"\"id\"",
":",
"h",
".",
"id",
",",
"}",
"\n",
"b",
",",
"err",
":=",
"h",
".",
"ToByteArray",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
"[",
"\"sequence\"",
"]",
"=",
"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",
"[",
"\"id\"",
"]",
".",
"(",
"string",
")",
"\n",
"bi",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"m",
"[",
"\"sequence\"",
"]",
")",
"\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",
")",
"{",
"byteStart",
",",
"bitStart",
":=",
"ordinalToPos",
"(",
"start",
")",
"\n",
"current",
",",
"_",
",",
"precBlocks",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"byteStart",
")",
"\n",
"byteOffset",
":=",
"byteStart",
"-",
"inBlockBytePos",
"\n",
"bitOffset",
":=",
"inBlockBytePos",
"*",
"8",
"+",
"bitStart",
"\n",
"for",
"current",
"!=",
"nil",
"{",
"if",
"current",
".",
"block",
"!=",
"blockMAX",
"{",
"retry",
":",
"bytePos",
",",
"bitPos",
",",
"err",
":=",
"current",
".",
"getAvailableBit",
"(",
"bitOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"precBlocks",
"==",
"current",
".",
"count",
"-",
"1",
"{",
"goto",
"next",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"bitOffset",
"=",
"0",
"\n",
"byteOffset",
"+=",
"blockBytes",
"\n",
"precBlocks",
"++",
"\n",
"goto",
"retry",
"\n",
"}",
"\n",
"return",
"byteOffset",
"+",
"bytePos",
",",
"bitPos",
",",
"err",
"\n",
"}",
"\n",
"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",
"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",
"current",
",",
"_",
",",
"_",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"bytePos",
")",
"\n",
"if",
"current",
"!=",
"nil",
"{",
"bitSel",
":=",
"blockFirstBit",
">>",
"(",
"inBlockBytePos",
"*",
"8",
"+",
"bitPos",
")",
"\n",
"if",
"current",
".",
"block",
"&",
"bitSel",
"==",
"0",
"{",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\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",
"l",
",",
"err",
":=",
"n",
".",
"nlHandle",
".",
"LinkByName",
"(",
"i",
".",
"DstName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"failed to retrieve the statistics for %s in netns %s: %v\"",
",",
"i",
".",
"DstName",
"(",
")",
",",
"n",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"stats",
":=",
"l",
".",
"Attrs",
"(",
")",
".",
"Statistics",
"\n",
"if",
"stats",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"no statistics were returned\"",
")",
"\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",
"for",
"_",
",",
"p",
":=",
"range",
"list",
"{",
"_",
",",
"b",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"p",
".",
"Base",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"invalid base pool %q: %v\"",
",",
"p",
".",
"Base",
",",
"err",
")",
"\n",
"}",
"\n",
"ones",
",",
"_",
":=",
"b",
".",
"Mask",
".",
"Size",
"(",
")",
"\n",
"if",
"p",
".",
"Size",
"<=",
"0",
"||",
"p",
".",
"Size",
"<",
"ones",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"invalid pools size: %d\"",
",",
"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",
"(",
"\"uuid: incorrect UUID format %s\"",
",",
"t",
")",
"\n",
"}",
"\n",
"src",
":=",
"t",
"[",
":",
"]",
"\n",
"dst",
":=",
"u",
"[",
":",
"]",
"\n",
"for",
"i",
",",
"byteGroup",
":=",
"range",
"byteGroups",
"{",
"if",
"i",
">",
"0",
"{",
"src",
"=",
"src",
"[",
"1",
":",
"]",
"\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",
"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",
"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",
"(",
"\"uuid: incorrrect UUID length: %s\"",
",",
"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",
"(",
"\"uuid: UUID must be exactly 16 bytes long, got %d bytes\"",
",",
"len",
"(",
"data",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"copy",
"(",
"u",
"[",
":",
"]",
",",
"data",
")",
"\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",
"g",
".",
"storageMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"g",
".",
"storageMutex",
".",
"Unlock",
"(",
")",
"\n",
"timeNow",
":=",
"g",
".",
"getEpoch",
"(",
")",
"\n",
"if",
"timeNow",
"<=",
"g",
".",
"lastTime",
"{",
"g",
".",
"clockSequence",
"++",
"\n",
"}",
"\n",
"g",
".",
"lastTime",
"=",
"timeNow",
"\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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"aggfnoid",
")",
"\n",
"pa",
":=",
"PgAggregate",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"amname",
")",
"\n",
"pa",
":=",
"PgAm",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"amopfamily",
",",
"amoplefttype",
",",
"amoprighttype",
",",
"amopstrategy",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"amopopr",
",",
"amoppurpose",
",",
"amopfamily",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"amprocfamily",
",",
"amproclefttype",
",",
"amprocrighttype",
",",
"amprocnum",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc `",
"+",
"`FROM pg_catalog.pg_amproc `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"adrelid",
",",
"adnum",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc `",
"+",
"`FROM pg_catalog.pg_attrdef `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"attrelid",
",",
"attname",
")",
"\n",
"pa",
":=",
"PgAttribute",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"member",
",",
"roleid",
")",
"\n",
"pam",
":=",
"PgAuthMember",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAuthid",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod `",
"+",
"`FROM pg_catalog.pg_cast `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCast",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgClass",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"collname",
",",
"collencoding",
",",
"collnamespace",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\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",
"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",
"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",
"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",
"res",
":=",
"[",
"]",
"*",
"PgConstraint",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\n",
"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",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pc",
")",
"\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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"connamespace",
",",
"conforencoding",
",",
"contoencoding",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConversion",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"datname",
")",
"\n",
"pd",
":=",
"PgDatabase",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"setdatabase",
",",
"setrole",
")",
"\n",
"pdrs",
":=",
"PgDbRoleSetting",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl `",
"+",
"`FROM pg_catalog.pg_default_acl `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"defaclrole",
",",
"defaclnamespace",
",",
"defaclobjtype",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\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",
"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",
"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",
"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",
"res",
":=",
"[",
"]",
"*",
"PgDepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pd",
":=",
"PgDepend",
"{",
"}",
"\n",
"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",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pd",
")",
"\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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
"\n",
"pd",
":=",
"PgDescription",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"evtname",
")",
"\n",
"pet",
":=",
"PgEventTrigger",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"extname",
")",
"\n",
"pe",
":=",
"PgExtension",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pfdw",
":=",
"PgForeignDataWrapper",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"srvname",
")",
"\n",
"pfs",
":=",
"PgForeignServer",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions `",
"+",
"`FROM pg_catalog.pg_foreign_table `",
"+",
"`WHERE ftrelid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"ftrelid",
")",
"\n",
"pft",
":=",
"PgForeignTable",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"indexrelid",
")",
"\n",
"pi",
":=",
"PgIndex",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgIndex",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n",
"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",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhparent = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n",
"res",
":=",
"[",
"]",
"*",
"PgInherit",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n",
"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",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhrelid = $1 AND inhseqno = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
"\n",
"pi",
":=",
"PgInherit",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"lanname",
")",
"\n",
"pl",
":=",
"PgLanguage",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data `",
"+",
"`FROM pg_catalog.pg_largeobject `",
"+",
"`WHERE loid = $1 AND pageno = $2`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
"\n",
"pl",
":=",
"PgLargeobject",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl `",
"+",
"`FROM pg_catalog.pg_largeobject_metadata `",
"+",
"`WHERE oid = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"plm",
":=",
"PgLargeobjectMetadatum",
"{",
"}",
"\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",
"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",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl `",
"+",
"`FROM pg_catalog.pg_namespace `",
"+",
"`WHERE nspname = $1`",
"\n",
"XOLog",
"(",
"sqlstr",
",",
"nspname",
")",
"\n",
"pn",
":=",
"PgNamespace",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOperator",
"{",
"}",
"\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",
"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",
"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",
"XOLog",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\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",
"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 community queries yet
The top public SQL queries from the community will appear here once available.