id
int32 0
167k
| 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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
22,700
|
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
|
22,701
|
docker/libnetwork
|
bitseq/sequence.go
|
CheckConsistency
|
func (h *Handle) CheckConsistency() error {
for {
h.Lock()
store := h.store
h.Unlock()
if store != nil {
if err := store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return err
}
}
h.Lock()
nh := h.getCopy()
h.Unlock()
if !nh.runConsistencyCheck() {
return nil
}
if err := nh.writeToStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while fixing inconsistent bitsequence: %v", err)
}
continue
}
logrus.Infof("Fixed inconsistent bit sequence in datastore:\n%s\n%s", h, nh)
h.Lock()
h.head = nh.head
h.Unlock()
return nil
}
}
|
go
|
func (h *Handle) CheckConsistency() error {
for {
h.Lock()
store := h.store
h.Unlock()
if store != nil {
if err := store.GetObject(datastore.Key(h.Key()...), h); err != nil && err != datastore.ErrKeyNotFound {
return err
}
}
h.Lock()
nh := h.getCopy()
h.Unlock()
if !nh.runConsistencyCheck() {
return nil
}
if err := nh.writeToStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while fixing inconsistent bitsequence: %v", err)
}
continue
}
logrus.Infof("Fixed inconsistent bit sequence in datastore:\n%s\n%s", h, nh)
h.Lock()
h.head = nh.head
h.Unlock()
return nil
}
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"CheckConsistency",
"(",
")",
"error",
"{",
"for",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"store",
":=",
"h",
".",
"store",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"store",
"!=",
"nil",
"{",
"if",
"err",
":=",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"datastore",
".",
"ErrKeyNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"nh",
":=",
"h",
".",
"getCopy",
"(",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"!",
"nh",
".",
"runConsistencyCheck",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"nh",
".",
"writeToStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"types",
".",
"RetryError",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"h",
",",
"nh",
")",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"head",
"=",
"nh",
".",
"head",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// CheckConsistency checks if the bit sequence is in an inconsistent state and attempts to fix it.
// It looks for a corruption signature that may happen in docker 1.9.0 and 1.9.1.
|
[
"CheckConsistency",
"checks",
"if",
"the",
"bit",
"sequence",
"is",
"in",
"an",
"inconsistent",
"state",
"and",
"attempts",
"to",
"fix",
"it",
".",
"It",
"looks",
"for",
"a",
"corruption",
"signature",
"that",
"may",
"happen",
"in",
"docker",
"1",
".",
"9",
".",
"0",
"and",
"1",
".",
"9",
".",
"1",
"."
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L271-L306
|
22,702
|
docker/libnetwork
|
bitseq/sequence.go
|
validateOrdinal
|
func (h *Handle) validateOrdinal(ordinal uint64) error {
h.Lock()
defer h.Unlock()
if ordinal >= h.bits {
return errors.New("bit does not belong to the sequence")
}
return nil
}
|
go
|
func (h *Handle) validateOrdinal(ordinal uint64) error {
h.Lock()
defer h.Unlock()
if ordinal >= h.bits {
return errors.New("bit does not belong to the sequence")
}
return nil
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"validateOrdinal",
"(",
"ordinal",
"uint64",
")",
"error",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"defer",
"h",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ordinal",
">=",
"h",
".",
"bits",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// checks is needed because to cover the case where the number of bits is not a multiple of blockLen
|
[
"checks",
"is",
"needed",
"because",
"to",
"cover",
"the",
"case",
"where",
"the",
"number",
"of",
"bits",
"is",
"not",
"a",
"multiple",
"of",
"blockLen"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L386-L393
|
22,703
|
docker/libnetwork
|
bitseq/sequence.go
|
Destroy
|
func (h *Handle) Destroy() error {
for {
if err := h.deleteFromStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while destroying the sequence: %v", err)
}
// Fetch latest
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil {
if err == datastore.ErrKeyNotFound { // already removed
return nil
}
return fmt.Errorf("failed to fetch from store when destroying the sequence: %v", err)
}
continue
}
return nil
}
}
|
go
|
func (h *Handle) Destroy() error {
for {
if err := h.deleteFromStore(); err != nil {
if _, ok := err.(types.RetryError); !ok {
return fmt.Errorf("internal failure while destroying the sequence: %v", err)
}
// Fetch latest
if err := h.store.GetObject(datastore.Key(h.Key()...), h); err != nil {
if err == datastore.ErrKeyNotFound { // already removed
return nil
}
return fmt.Errorf("failed to fetch from store when destroying the sequence: %v", err)
}
continue
}
return nil
}
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"Destroy",
"(",
")",
"error",
"{",
"for",
"{",
"if",
"err",
":=",
"h",
".",
"deleteFromStore",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"types",
".",
"RetryError",
")",
";",
"!",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"// Fetch latest",
"if",
"err",
":=",
"h",
".",
"store",
".",
"GetObject",
"(",
"datastore",
".",
"Key",
"(",
"h",
".",
"Key",
"(",
")",
"...",
")",
",",
"h",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"datastore",
".",
"ErrKeyNotFound",
"{",
"// already removed",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] |
// Destroy removes from the datastore the data belonging to this handle
|
[
"Destroy",
"removes",
"from",
"the",
"datastore",
"the",
"data",
"belonging",
"to",
"this",
"handle"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L396-L413
|
22,704
|
docker/libnetwork
|
bitseq/sequence.go
|
ToByteArray
|
func (h *Handle) ToByteArray() ([]byte, error) {
h.Lock()
defer h.Unlock()
ba := make([]byte, 16)
binary.BigEndian.PutUint64(ba[0:], h.bits)
binary.BigEndian.PutUint64(ba[8:], h.unselected)
bm, err := h.head.toByteArray()
if err != nil {
return nil, fmt.Errorf("failed to serialize head: %s", err.Error())
}
ba = append(ba, bm...)
return ba, nil
}
|
go
|
func (h *Handle) ToByteArray() ([]byte, error) {
h.Lock()
defer h.Unlock()
ba := make([]byte, 16)
binary.BigEndian.PutUint64(ba[0:], h.bits)
binary.BigEndian.PutUint64(ba[8:], h.unselected)
bm, err := h.head.toByteArray()
if err != nil {
return nil, fmt.Errorf("failed to serialize head: %s", err.Error())
}
ba = append(ba, bm...)
return ba, nil
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"ToByteArray",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"h",
".",
"Lock",
"(",
")",
"\n",
"defer",
"h",
".",
"Unlock",
"(",
")",
"\n",
"ba",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"16",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"ba",
"[",
"0",
":",
"]",
",",
"h",
".",
"bits",
")",
"\n",
"binary",
".",
"BigEndian",
".",
"PutUint64",
"(",
"ba",
"[",
"8",
":",
"]",
",",
"h",
".",
"unselected",
")",
"\n",
"bm",
",",
"err",
":=",
"h",
".",
"head",
".",
"toByteArray",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"ba",
"=",
"append",
"(",
"ba",
",",
"bm",
"...",
")",
"\n\n",
"return",
"ba",
",",
"nil",
"\n",
"}"
] |
// ToByteArray converts this handle's data into a byte array
|
[
"ToByteArray",
"converts",
"this",
"handle",
"s",
"data",
"into",
"a",
"byte",
"array"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L416-L430
|
22,705
|
docker/libnetwork
|
bitseq/sequence.go
|
FromByteArray
|
func (h *Handle) FromByteArray(ba []byte) error {
if ba == nil {
return errors.New("nil byte array")
}
nh := &sequence{}
err := nh.fromByteArray(ba[16:])
if err != nil {
return fmt.Errorf("failed to deserialize head: %s", err.Error())
}
h.Lock()
h.head = nh
h.bits = binary.BigEndian.Uint64(ba[0:8])
h.unselected = binary.BigEndian.Uint64(ba[8:16])
h.Unlock()
return nil
}
|
go
|
func (h *Handle) FromByteArray(ba []byte) error {
if ba == nil {
return errors.New("nil byte array")
}
nh := &sequence{}
err := nh.fromByteArray(ba[16:])
if err != nil {
return fmt.Errorf("failed to deserialize head: %s", err.Error())
}
h.Lock()
h.head = nh
h.bits = binary.BigEndian.Uint64(ba[0:8])
h.unselected = binary.BigEndian.Uint64(ba[8:16])
h.Unlock()
return nil
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"FromByteArray",
"(",
"ba",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"ba",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"nh",
":=",
"&",
"sequence",
"{",
"}",
"\n",
"err",
":=",
"nh",
".",
"fromByteArray",
"(",
"ba",
"[",
"16",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n\n",
"h",
".",
"Lock",
"(",
")",
"\n",
"h",
".",
"head",
"=",
"nh",
"\n",
"h",
".",
"bits",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"ba",
"[",
"0",
":",
"8",
"]",
")",
"\n",
"h",
".",
"unselected",
"=",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"ba",
"[",
"8",
":",
"16",
"]",
")",
"\n",
"h",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// FromByteArray reads his handle's data from a byte array
|
[
"FromByteArray",
"reads",
"his",
"handle",
"s",
"data",
"from",
"a",
"byte",
"array"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L433-L451
|
22,706
|
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
|
22,707
|
docker/libnetwork
|
bitseq/sequence.go
|
MarshalJSON
|
func (h *Handle) MarshalJSON() ([]byte, error) {
m := map[string]interface{}{
"id": h.id,
}
b, err := h.ToByteArray()
if err != nil {
return nil, err
}
m["sequence"] = b
return json.Marshal(m)
}
|
go
|
func (h *Handle) MarshalJSON() ([]byte, error) {
m := map[string]interface{}{
"id": h.id,
}
b, err := h.ToByteArray()
if err != nil {
return nil, err
}
m["sequence"] = b
return json.Marshal(m)
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"h",
".",
"id",
",",
"}",
"\n\n",
"b",
",",
"err",
":=",
"h",
".",
"ToByteArray",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
"[",
"\"",
"\"",
"]",
"=",
"b",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"m",
")",
"\n",
"}"
] |
// MarshalJSON encodes Handle into json message
|
[
"MarshalJSON",
"encodes",
"Handle",
"into",
"json",
"message"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L473-L484
|
22,708
|
docker/libnetwork
|
bitseq/sequence.go
|
UnmarshalJSON
|
func (h *Handle) UnmarshalJSON(data []byte) error {
var (
m map[string]interface{}
b []byte
err error
)
if err = json.Unmarshal(data, &m); err != nil {
return err
}
h.id = m["id"].(string)
bi, _ := json.Marshal(m["sequence"])
if err := json.Unmarshal(bi, &b); err != nil {
return err
}
return h.FromByteArray(b)
}
|
go
|
func (h *Handle) UnmarshalJSON(data []byte) error {
var (
m map[string]interface{}
b []byte
err error
)
if err = json.Unmarshal(data, &m); err != nil {
return err
}
h.id = m["id"].(string)
bi, _ := json.Marshal(m["sequence"])
if err := json.Unmarshal(bi, &b); err != nil {
return err
}
return h.FromByteArray(b)
}
|
[
"func",
"(",
"h",
"*",
"Handle",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"\n",
"b",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
")",
"\n",
"if",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"h",
".",
"id",
"=",
"m",
"[",
"\"",
"\"",
"]",
".",
"(",
"string",
")",
"\n",
"bi",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"m",
"[",
"\"",
"\"",
"]",
")",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"bi",
",",
"&",
"b",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"h",
".",
"FromByteArray",
"(",
"b",
")",
"\n",
"}"
] |
// UnmarshalJSON decodes json message into Handle
|
[
"UnmarshalJSON",
"decodes",
"json",
"message",
"into",
"Handle"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L487-L502
|
22,709
|
docker/libnetwork
|
bitseq/sequence.go
|
getFirstAvailable
|
func getFirstAvailable(head *sequence, start uint64) (uint64, uint64, error) {
// Find sequence which contains the start bit
byteStart, bitStart := ordinalToPos(start)
current, _, precBlocks, inBlockBytePos := findSequence(head, byteStart)
// Derive the this sequence offsets
byteOffset := byteStart - inBlockBytePos
bitOffset := inBlockBytePos*8 + bitStart
for current != nil {
if current.block != blockMAX {
// If the current block is not full, check if there is any bit
// from the current bit in the current block. If not, before proceeding to the
// next block node, make sure we check for available bit in the next
// instance of the same block. Due to RLE same block signature will be
// compressed.
retry:
bytePos, bitPos, err := current.getAvailableBit(bitOffset)
if err != nil && precBlocks == current.count-1 {
// This is the last instance in the same block node,
// so move to the next block.
goto next
}
if err != nil {
// There are some more instances of the same block, so add the offset
// and be optimistic that you will find the available bit in the next
// instance of the same block.
bitOffset = 0
byteOffset += blockBytes
precBlocks++
goto retry
}
return byteOffset + bytePos, bitPos, err
}
// Moving to next block: Reset bit offset.
next:
bitOffset = 0
byteOffset += (current.count * blockBytes) - (precBlocks * blockBytes)
precBlocks = 0
current = current.next
}
return invalidPos, invalidPos, ErrNoBitAvailable
}
|
go
|
func getFirstAvailable(head *sequence, start uint64) (uint64, uint64, error) {
// Find sequence which contains the start bit
byteStart, bitStart := ordinalToPos(start)
current, _, precBlocks, inBlockBytePos := findSequence(head, byteStart)
// Derive the this sequence offsets
byteOffset := byteStart - inBlockBytePos
bitOffset := inBlockBytePos*8 + bitStart
for current != nil {
if current.block != blockMAX {
// If the current block is not full, check if there is any bit
// from the current bit in the current block. If not, before proceeding to the
// next block node, make sure we check for available bit in the next
// instance of the same block. Due to RLE same block signature will be
// compressed.
retry:
bytePos, bitPos, err := current.getAvailableBit(bitOffset)
if err != nil && precBlocks == current.count-1 {
// This is the last instance in the same block node,
// so move to the next block.
goto next
}
if err != nil {
// There are some more instances of the same block, so add the offset
// and be optimistic that you will find the available bit in the next
// instance of the same block.
bitOffset = 0
byteOffset += blockBytes
precBlocks++
goto retry
}
return byteOffset + bytePos, bitPos, err
}
// Moving to next block: Reset bit offset.
next:
bitOffset = 0
byteOffset += (current.count * blockBytes) - (precBlocks * blockBytes)
precBlocks = 0
current = current.next
}
return invalidPos, invalidPos, ErrNoBitAvailable
}
|
[
"func",
"getFirstAvailable",
"(",
"head",
"*",
"sequence",
",",
"start",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"// Find sequence which contains the start bit",
"byteStart",
",",
"bitStart",
":=",
"ordinalToPos",
"(",
"start",
")",
"\n",
"current",
",",
"_",
",",
"precBlocks",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"byteStart",
")",
"\n",
"// Derive the this sequence offsets",
"byteOffset",
":=",
"byteStart",
"-",
"inBlockBytePos",
"\n",
"bitOffset",
":=",
"inBlockBytePos",
"*",
"8",
"+",
"bitStart",
"\n",
"for",
"current",
"!=",
"nil",
"{",
"if",
"current",
".",
"block",
"!=",
"blockMAX",
"{",
"// If the current block is not full, check if there is any bit",
"// from the current bit in the current block. If not, before proceeding to the",
"// next block node, make sure we check for available bit in the next",
"// instance of the same block. Due to RLE same block signature will be",
"// compressed.",
"retry",
":",
"bytePos",
",",
"bitPos",
",",
"err",
":=",
"current",
".",
"getAvailableBit",
"(",
"bitOffset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"precBlocks",
"==",
"current",
".",
"count",
"-",
"1",
"{",
"// This is the last instance in the same block node,",
"// so move to the next block.",
"goto",
"next",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// There are some more instances of the same block, so add the offset",
"// and be optimistic that you will find the available bit in the next",
"// instance of the same block.",
"bitOffset",
"=",
"0",
"\n",
"byteOffset",
"+=",
"blockBytes",
"\n",
"precBlocks",
"++",
"\n",
"goto",
"retry",
"\n",
"}",
"\n",
"return",
"byteOffset",
"+",
"bytePos",
",",
"bitPos",
",",
"err",
"\n",
"}",
"\n",
"// Moving to next block: Reset bit offset.",
"next",
":",
"bitOffset",
"=",
"0",
"\n",
"byteOffset",
"+=",
"(",
"current",
".",
"count",
"*",
"blockBytes",
")",
"-",
"(",
"precBlocks",
"*",
"blockBytes",
")",
"\n",
"precBlocks",
"=",
"0",
"\n",
"current",
"=",
"current",
".",
"next",
"\n",
"}",
"\n",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}"
] |
// getFirstAvailable looks for the first unset bit in passed mask starting from start
|
[
"getFirstAvailable",
"looks",
"for",
"the",
"first",
"unset",
"bit",
"in",
"passed",
"mask",
"starting",
"from",
"start"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L505-L545
|
22,710
|
docker/libnetwork
|
bitseq/sequence.go
|
getAvailableFromCurrent
|
func getAvailableFromCurrent(head *sequence, start, curr, end uint64) (uint64, uint64, error) {
var bytePos, bitPos uint64
var err error
if curr != 0 && curr > start {
bytePos, bitPos, err = getFirstAvailable(head, curr)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
goto begin
}
return bytePos, bitPos, nil
}
begin:
bytePos, bitPos, err = getFirstAvailable(head, start)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bytePos, bitPos, nil
}
|
go
|
func getAvailableFromCurrent(head *sequence, start, curr, end uint64) (uint64, uint64, error) {
var bytePos, bitPos uint64
var err error
if curr != 0 && curr > start {
bytePos, bitPos, err = getFirstAvailable(head, curr)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
goto begin
}
return bytePos, bitPos, nil
}
begin:
bytePos, bitPos, err = getFirstAvailable(head, start)
ret := posToOrdinal(bytePos, bitPos)
if end < ret || err != nil {
return invalidPos, invalidPos, ErrNoBitAvailable
}
return bytePos, bitPos, nil
}
|
[
"func",
"getAvailableFromCurrent",
"(",
"head",
"*",
"sequence",
",",
"start",
",",
"curr",
",",
"end",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"var",
"bytePos",
",",
"bitPos",
"uint64",
"\n",
"var",
"err",
"error",
"\n",
"if",
"curr",
"!=",
"0",
"&&",
"curr",
">",
"start",
"{",
"bytePos",
",",
"bitPos",
",",
"err",
"=",
"getFirstAvailable",
"(",
"head",
",",
"curr",
")",
"\n",
"ret",
":=",
"posToOrdinal",
"(",
"bytePos",
",",
"bitPos",
")",
"\n",
"if",
"end",
"<",
"ret",
"||",
"err",
"!=",
"nil",
"{",
"goto",
"begin",
"\n",
"}",
"\n",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}",
"\n\n",
"begin",
":",
"bytePos",
",",
"bitPos",
",",
"err",
"=",
"getFirstAvailable",
"(",
"head",
",",
"start",
")",
"\n",
"ret",
":=",
"posToOrdinal",
"(",
"bytePos",
",",
"bitPos",
")",
"\n",
"if",
"end",
"<",
"ret",
"||",
"err",
"!=",
"nil",
"{",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrNoBitAvailable",
"\n",
"}",
"\n",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}"
] |
// getAvailableFromCurrent will look for available ordinal from the current ordinal.
// If none found then it will loop back to the start to check of the available bit.
// This can be further optimized to check from start till curr in case of a rollover
|
[
"getAvailableFromCurrent",
"will",
"look",
"for",
"available",
"ordinal",
"from",
"the",
"current",
"ordinal",
".",
"If",
"none",
"found",
"then",
"it",
"will",
"loop",
"back",
"to",
"the",
"start",
"to",
"check",
"of",
"the",
"available",
"bit",
".",
"This",
"can",
"be",
"further",
"optimized",
"to",
"check",
"from",
"start",
"till",
"curr",
"in",
"case",
"of",
"a",
"rollover"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L550-L569
|
22,711
|
docker/libnetwork
|
bitseq/sequence.go
|
checkIfAvailable
|
func checkIfAvailable(head *sequence, ordinal uint64) (uint64, uint64, error) {
bytePos, bitPos := ordinalToPos(ordinal)
// Find the sequence containing this byte
current, _, _, inBlockBytePos := findSequence(head, bytePos)
if current != nil {
// Check whether the bit corresponding to the ordinal address is unset
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
if current.block&bitSel == 0 {
return bytePos, bitPos, nil
}
}
return invalidPos, invalidPos, ErrBitAllocated
}
|
go
|
func checkIfAvailable(head *sequence, ordinal uint64) (uint64, uint64, error) {
bytePos, bitPos := ordinalToPos(ordinal)
// Find the sequence containing this byte
current, _, _, inBlockBytePos := findSequence(head, bytePos)
if current != nil {
// Check whether the bit corresponding to the ordinal address is unset
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
if current.block&bitSel == 0 {
return bytePos, bitPos, nil
}
}
return invalidPos, invalidPos, ErrBitAllocated
}
|
[
"func",
"checkIfAvailable",
"(",
"head",
"*",
"sequence",
",",
"ordinal",
"uint64",
")",
"(",
"uint64",
",",
"uint64",
",",
"error",
")",
"{",
"bytePos",
",",
"bitPos",
":=",
"ordinalToPos",
"(",
"ordinal",
")",
"\n\n",
"// Find the sequence containing this byte",
"current",
",",
"_",
",",
"_",
",",
"inBlockBytePos",
":=",
"findSequence",
"(",
"head",
",",
"bytePos",
")",
"\n",
"if",
"current",
"!=",
"nil",
"{",
"// Check whether the bit corresponding to the ordinal address is unset",
"bitSel",
":=",
"blockFirstBit",
">>",
"(",
"inBlockBytePos",
"*",
"8",
"+",
"bitPos",
")",
"\n",
"if",
"current",
".",
"block",
"&",
"bitSel",
"==",
"0",
"{",
"return",
"bytePos",
",",
"bitPos",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"invalidPos",
",",
"invalidPos",
",",
"ErrBitAllocated",
"\n",
"}"
] |
// checkIfAvailable checks if the bit correspondent to the specified ordinal is unset
// If the ordinal is beyond the sequence limits, a negative response is returned
|
[
"checkIfAvailable",
"checks",
"if",
"the",
"bit",
"correspondent",
"to",
"the",
"specified",
"ordinal",
"is",
"unset",
"If",
"the",
"ordinal",
"is",
"beyond",
"the",
"sequence",
"limits",
"a",
"negative",
"response",
"is",
"returned"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/bitseq/sequence.go#L573-L587
|
22,712
|
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
|
22,713
|
docker/libnetwork
|
osl/interface_linux.go
|
Statistics
|
func (i *nwIface) Statistics() (*types.InterfaceStatistics, error) {
i.Lock()
n := i.ns
i.Unlock()
l, err := n.nlHandle.LinkByName(i.DstName())
if err != nil {
return nil, fmt.Errorf("failed to retrieve the statistics for %s in netns %s: %v", i.DstName(), n.path, err)
}
stats := l.Attrs().Statistics
if stats == nil {
return nil, fmt.Errorf("no statistics were returned")
}
return &types.InterfaceStatistics{
RxBytes: uint64(stats.RxBytes),
TxBytes: uint64(stats.TxBytes),
RxPackets: uint64(stats.RxPackets),
TxPackets: uint64(stats.TxPackets),
RxDropped: uint64(stats.RxDropped),
TxDropped: uint64(stats.TxDropped),
}, nil
}
|
go
|
func (i *nwIface) Statistics() (*types.InterfaceStatistics, error) {
i.Lock()
n := i.ns
i.Unlock()
l, err := n.nlHandle.LinkByName(i.DstName())
if err != nil {
return nil, fmt.Errorf("failed to retrieve the statistics for %s in netns %s: %v", i.DstName(), n.path, err)
}
stats := l.Attrs().Statistics
if stats == nil {
return nil, fmt.Errorf("no statistics were returned")
}
return &types.InterfaceStatistics{
RxBytes: uint64(stats.RxBytes),
TxBytes: uint64(stats.TxBytes),
RxPackets: uint64(stats.RxPackets),
TxPackets: uint64(stats.TxPackets),
RxDropped: uint64(stats.RxDropped),
TxDropped: uint64(stats.TxDropped),
}, nil
}
|
[
"func",
"(",
"i",
"*",
"nwIface",
")",
"Statistics",
"(",
")",
"(",
"*",
"types",
".",
"InterfaceStatistics",
",",
"error",
")",
"{",
"i",
".",
"Lock",
"(",
")",
"\n",
"n",
":=",
"i",
".",
"ns",
"\n",
"i",
".",
"Unlock",
"(",
")",
"\n\n",
"l",
",",
"err",
":=",
"n",
".",
"nlHandle",
".",
"LinkByName",
"(",
"i",
".",
"DstName",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"i",
".",
"DstName",
"(",
")",
",",
"n",
".",
"path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"stats",
":=",
"l",
".",
"Attrs",
"(",
")",
".",
"Statistics",
"\n",
"if",
"stats",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"types",
".",
"InterfaceStatistics",
"{",
"RxBytes",
":",
"uint64",
"(",
"stats",
".",
"RxBytes",
")",
",",
"TxBytes",
":",
"uint64",
"(",
"stats",
".",
"TxBytes",
")",
",",
"RxPackets",
":",
"uint64",
"(",
"stats",
".",
"RxPackets",
")",
",",
"TxPackets",
":",
"uint64",
"(",
"stats",
".",
"TxPackets",
")",
",",
"RxDropped",
":",
"uint64",
"(",
"stats",
".",
"RxDropped",
")",
",",
"TxDropped",
":",
"uint64",
"(",
"stats",
".",
"TxDropped",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Returns the sandbox's side veth interface statistics
|
[
"Returns",
"the",
"sandbox",
"s",
"side",
"veth",
"interface",
"statistics"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/osl/interface_linux.go#L180-L203
|
22,714
|
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
|
22,715
|
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
|
22,716
|
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
|
22,717
|
docker/libnetwork
|
ipamutils/utils.go
|
splitNetworks
|
func splitNetworks(list []*NetworkToSplit) ([]*net.IPNet, error) {
localPools := make([]*net.IPNet, 0, len(list))
for _, p := range list {
_, b, err := net.ParseCIDR(p.Base)
if err != nil {
return nil, fmt.Errorf("invalid base pool %q: %v", p.Base, err)
}
ones, _ := b.Mask.Size()
if p.Size <= 0 || p.Size < ones {
return nil, fmt.Errorf("invalid pools size: %d", p.Size)
}
localPools = append(localPools, splitNetwork(p.Size, b)...)
}
return localPools, nil
}
|
go
|
func splitNetworks(list []*NetworkToSplit) ([]*net.IPNet, error) {
localPools := make([]*net.IPNet, 0, len(list))
for _, p := range list {
_, b, err := net.ParseCIDR(p.Base)
if err != nil {
return nil, fmt.Errorf("invalid base pool %q: %v", p.Base, err)
}
ones, _ := b.Mask.Size()
if p.Size <= 0 || p.Size < ones {
return nil, fmt.Errorf("invalid pools size: %d", p.Size)
}
localPools = append(localPools, splitNetwork(p.Size, b)...)
}
return localPools, nil
}
|
[
"func",
"splitNetworks",
"(",
"list",
"[",
"]",
"*",
"NetworkToSplit",
")",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"error",
")",
"{",
"localPools",
":=",
"make",
"(",
"[",
"]",
"*",
"net",
".",
"IPNet",
",",
"0",
",",
"len",
"(",
"list",
")",
")",
"\n\n",
"for",
"_",
",",
"p",
":=",
"range",
"list",
"{",
"_",
",",
"b",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"p",
".",
"Base",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"Base",
",",
"err",
")",
"\n",
"}",
"\n",
"ones",
",",
"_",
":=",
"b",
".",
"Mask",
".",
"Size",
"(",
")",
"\n",
"if",
"p",
".",
"Size",
"<=",
"0",
"||",
"p",
".",
"Size",
"<",
"ones",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"p",
".",
"Size",
")",
"\n",
"}",
"\n",
"localPools",
"=",
"append",
"(",
"localPools",
",",
"splitNetwork",
"(",
"p",
".",
"Size",
",",
"b",
")",
"...",
")",
"\n",
"}",
"\n",
"return",
"localPools",
",",
"nil",
"\n",
"}"
] |
// splitNetworks takes a slice of networks, split them accordingly and returns them
|
[
"splitNetworks",
"takes",
"a",
"slice",
"of",
"networks",
"split",
"them",
"accordingly",
"and",
"returns",
"them"
] |
9ff9b57c344df5cd47443ad9e65702ec85c5aeb0
|
https://github.com/docker/libnetwork/blob/9ff9b57c344df5cd47443ad9e65702ec85c5aeb0/ipamutils/utils.go#L92-L107
|
22,718
|
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
|
22,719
|
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
|
22,720
|
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
|
22,721
|
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
|
22,722
|
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
|
22,723
|
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
|
22,724
|
satori/go.uuid
|
codec.go
|
decodeCanonical
|
func (u *UUID) decodeCanonical(t []byte) (err error) {
if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
return fmt.Errorf("uuid: incorrect UUID format %s", t)
}
src := t[:]
dst := u[:]
for i, byteGroup := range byteGroups {
if i > 0 {
src = src[1:] // skip dash
}
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
if err != nil {
return
}
src = src[byteGroup:]
dst = dst[byteGroup/2:]
}
return
}
|
go
|
func (u *UUID) decodeCanonical(t []byte) (err error) {
if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
return fmt.Errorf("uuid: incorrect UUID format %s", t)
}
src := t[:]
dst := u[:]
for i, byteGroup := range byteGroups {
if i > 0 {
src = src[1:] // skip dash
}
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
if err != nil {
return
}
src = src[byteGroup:]
dst = dst[byteGroup/2:]
}
return
}
|
[
"func",
"(",
"u",
"*",
"UUID",
")",
"decodeCanonical",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"t",
"[",
"8",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"13",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"18",
"]",
"!=",
"'-'",
"||",
"t",
"[",
"23",
"]",
"!=",
"'-'",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n\n",
"src",
":=",
"t",
"[",
":",
"]",
"\n",
"dst",
":=",
"u",
"[",
":",
"]",
"\n\n",
"for",
"i",
",",
"byteGroup",
":=",
"range",
"byteGroups",
"{",
"if",
"i",
">",
"0",
"{",
"src",
"=",
"src",
"[",
"1",
":",
"]",
"// skip dash",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"hex",
".",
"Decode",
"(",
"dst",
"[",
":",
"byteGroup",
"/",
"2",
"]",
",",
"src",
"[",
":",
"byteGroup",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"src",
"=",
"src",
"[",
"byteGroup",
":",
"]",
"\n",
"dst",
"=",
"dst",
"[",
"byteGroup",
"/",
"2",
":",
"]",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// decodeCanonical decodes UUID string in format
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
|
[
"decodeCanonical",
"decodes",
"UUID",
"string",
"in",
"format",
"6ba7b810",
"-",
"9dad",
"-",
"11d1",
"-",
"80b4",
"-",
"00c04fd430c8",
"."
] |
b2ce2384e17bbe0c6d34077efa39dbab3e09123b
|
https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L113-L134
|
22,725
|
satori/go.uuid
|
codec.go
|
decodeHashLike
|
func (u *UUID) decodeHashLike(t []byte) (err error) {
src := t[:]
dst := u[:]
if _, err = hex.Decode(dst, src); err != nil {
return err
}
return
}
|
go
|
func (u *UUID) decodeHashLike(t []byte) (err error) {
src := t[:]
dst := u[:]
if _, err = hex.Decode(dst, src); err != nil {
return err
}
return
}
|
[
"func",
"(",
"u",
"*",
"UUID",
")",
"decodeHashLike",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"src",
":=",
"t",
"[",
":",
"]",
"\n",
"dst",
":=",
"u",
"[",
":",
"]",
"\n\n",
"if",
"_",
",",
"err",
"=",
"hex",
".",
"Decode",
"(",
"dst",
",",
"src",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// decodeHashLike decodes UUID string in format
// "6ba7b8109dad11d180b400c04fd430c8".
|
[
"decodeHashLike",
"decodes",
"UUID",
"string",
"in",
"format",
"6ba7b8109dad11d180b400c04fd430c8",
"."
] |
b2ce2384e17bbe0c6d34077efa39dbab3e09123b
|
https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L138-L146
|
22,726
|
satori/go.uuid
|
codec.go
|
decodePlain
|
func (u *UUID) decodePlain(t []byte) (err error) {
switch len(t) {
case 32:
return u.decodeHashLike(t)
case 36:
return u.decodeCanonical(t)
default:
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
}
}
|
go
|
func (u *UUID) decodePlain(t []byte) (err error) {
switch len(t) {
case 32:
return u.decodeHashLike(t)
case 36:
return u.decodeCanonical(t)
default:
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
}
}
|
[
"func",
"(",
"u",
"*",
"UUID",
")",
"decodePlain",
"(",
"t",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"switch",
"len",
"(",
"t",
")",
"{",
"case",
"32",
":",
"return",
"u",
".",
"decodeHashLike",
"(",
"t",
")",
"\n",
"case",
"36",
":",
"return",
"u",
".",
"decodeCanonical",
"(",
"t",
")",
"\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n",
"}"
] |
// decodePlain decodes UUID string in canonical format
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
// "6ba7b8109dad11d180b400c04fd430c8".
|
[
"decodePlain",
"decodes",
"UUID",
"string",
"in",
"canonical",
"format",
"6ba7b810",
"-",
"9dad",
"-",
"11d1",
"-",
"80b4",
"-",
"00c04fd430c8",
"or",
"in",
"hash",
"-",
"like",
"format",
"6ba7b8109dad11d180b400c04fd430c8",
"."
] |
b2ce2384e17bbe0c6d34077efa39dbab3e09123b
|
https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L179-L188
|
22,727
|
satori/go.uuid
|
codec.go
|
UnmarshalBinary
|
func (u *UUID) UnmarshalBinary(data []byte) (err error) {
if len(data) != Size {
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
return
}
copy(u[:], data)
return
}
|
go
|
func (u *UUID) UnmarshalBinary(data []byte) (err error) {
if len(data) != Size {
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
return
}
copy(u[:], data)
return
}
|
[
"func",
"(",
"u",
"*",
"UUID",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"!=",
"Size",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"len",
"(",
"data",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"copy",
"(",
"u",
"[",
":",
"]",
",",
"data",
")",
"\n\n",
"return",
"\n",
"}"
] |
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
// It will return error if the slice isn't 16 bytes long.
|
[
"UnmarshalBinary",
"implements",
"the",
"encoding",
".",
"BinaryUnmarshaler",
"interface",
".",
"It",
"will",
"return",
"error",
"if",
"the",
"slice",
"isn",
"t",
"16",
"bytes",
"long",
"."
] |
b2ce2384e17bbe0c6d34077efa39dbab3e09123b
|
https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/codec.go#L198-L206
|
22,728
|
satori/go.uuid
|
generator.go
|
getClockSequence
|
func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
var err error
g.clockSequenceOnce.Do(func() {
buf := make([]byte, 2)
if _, err = io.ReadFull(g.rand, buf); err != nil {
return
}
g.clockSequence = binary.BigEndian.Uint16(buf)
})
if err != nil {
return 0, 0, err
}
g.storageMutex.Lock()
defer g.storageMutex.Unlock()
timeNow := g.getEpoch()
// Clock didn't change since last UUID generation.
// Should increase clock sequence.
if timeNow <= g.lastTime {
g.clockSequence++
}
g.lastTime = timeNow
return timeNow, g.clockSequence, nil
}
|
go
|
func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
var err error
g.clockSequenceOnce.Do(func() {
buf := make([]byte, 2)
if _, err = io.ReadFull(g.rand, buf); err != nil {
return
}
g.clockSequence = binary.BigEndian.Uint16(buf)
})
if err != nil {
return 0, 0, err
}
g.storageMutex.Lock()
defer g.storageMutex.Unlock()
timeNow := g.getEpoch()
// Clock didn't change since last UUID generation.
// Should increase clock sequence.
if timeNow <= g.lastTime {
g.clockSequence++
}
g.lastTime = timeNow
return timeNow, g.clockSequence, nil
}
|
[
"func",
"(",
"g",
"*",
"rfc4122Generator",
")",
"getClockSequence",
"(",
")",
"(",
"uint64",
",",
"uint16",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"g",
".",
"clockSequenceOnce",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"2",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"g",
".",
"rand",
",",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"g",
".",
"clockSequence",
"=",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"buf",
")",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"g",
".",
"storageMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"g",
".",
"storageMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"timeNow",
":=",
"g",
".",
"getEpoch",
"(",
")",
"\n",
"// Clock didn't change since last UUID generation.",
"// Should increase clock sequence.",
"if",
"timeNow",
"<=",
"g",
".",
"lastTime",
"{",
"g",
".",
"clockSequence",
"++",
"\n",
"}",
"\n",
"g",
".",
"lastTime",
"=",
"timeNow",
"\n\n",
"return",
"timeNow",
",",
"g",
".",
"clockSequence",
",",
"nil",
"\n",
"}"
] |
// Returns epoch and clock sequence.
|
[
"Returns",
"epoch",
"and",
"clock",
"sequence",
"."
] |
b2ce2384e17bbe0c6d34077efa39dbab3e09123b
|
https://github.com/satori/go.uuid/blob/b2ce2384e17bbe0c6d34077efa39dbab3e09123b/generator.go#L187-L212
|
22,729
|
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
|
22,730
|
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
|
22,731
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAggregateByAggfnoid
|
func PgAggregateByAggfnoid(db XODB, aggfnoid pgtypes.Regproc) (*PgAggregate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval ` +
`FROM pg_catalog.pg_aggregate ` +
`WHERE aggfnoid = $1`
// run query
XOLog(sqlstr, aggfnoid)
pa := PgAggregate{}
err = db.QueryRow(sqlstr, aggfnoid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAggregateByAggfnoid(db XODB, aggfnoid pgtypes.Regproc) (*PgAggregate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval ` +
`FROM pg_catalog.pg_aggregate ` +
`WHERE aggfnoid = $1`
// run query
XOLog(sqlstr, aggfnoid)
pa := PgAggregate{}
err = db.QueryRow(sqlstr, aggfnoid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Aggfnoid, &pa.Aggkind, &pa.Aggnumdirectargs, &pa.Aggtransfn, &pa.Aggfinalfn, &pa.Aggmtransfn, &pa.Aggminvtransfn, &pa.Aggmfinalfn, &pa.Aggfinalextra, &pa.Aggmfinalextra, &pa.Aggsortop, &pa.Aggtranstype, &pa.Aggtransspace, &pa.Aggmtranstype, &pa.Aggmtransspace, &pa.Agginitval, &pa.Aggminitval)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAggregateByAggfnoid",
"(",
"db",
"XODB",
",",
"aggfnoid",
"pgtypes",
".",
"Regproc",
")",
"(",
"*",
"PgAggregate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, aggfnoid, aggkind, aggnumdirectargs, aggtransfn, aggfinalfn, aggmtransfn, aggminvtransfn, aggmfinalfn, aggfinalextra, aggmfinalextra, aggsortop, aggtranstype, aggtransspace, aggmtranstype, aggmtransspace, agginitval, aggminitval `",
"+",
"`FROM pg_catalog.pg_aggregate `",
"+",
"`WHERE aggfnoid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"aggfnoid",
")",
"\n",
"pa",
":=",
"PgAggregate",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"aggfnoid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Aggfnoid",
",",
"&",
"pa",
".",
"Aggkind",
",",
"&",
"pa",
".",
"Aggnumdirectargs",
",",
"&",
"pa",
".",
"Aggtransfn",
",",
"&",
"pa",
".",
"Aggfinalfn",
",",
"&",
"pa",
".",
"Aggmtransfn",
",",
"&",
"pa",
".",
"Aggminvtransfn",
",",
"&",
"pa",
".",
"Aggmfinalfn",
",",
"&",
"pa",
".",
"Aggfinalextra",
",",
"&",
"pa",
".",
"Aggmfinalextra",
",",
"&",
"pa",
".",
"Aggsortop",
",",
"&",
"pa",
".",
"Aggtranstype",
",",
"&",
"pa",
".",
"Aggtransspace",
",",
"&",
"pa",
".",
"Aggmtranstype",
",",
"&",
"pa",
".",
"Aggmtransspace",
",",
"&",
"pa",
".",
"Agginitval",
",",
"&",
"pa",
".",
"Aggminitval",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAggregateByAggfnoid retrieves a row from 'pg_catalog.pg_aggregate' as a PgAggregate.
//
// Generated from index 'pg_aggregate_fnoid_index'.
|
[
"PgAggregateByAggfnoid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_aggregate",
"as",
"a",
"PgAggregate",
".",
"Generated",
"from",
"index",
"pg_aggregate_fnoid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41744-L41763
|
22,732
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmByAmname
|
func PgAmByAmname(db XODB, amname pgtypes.Name) (*PgAm, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions ` +
`FROM pg_catalog.pg_am ` +
`WHERE amname = $1`
// run query
XOLog(sqlstr, amname)
pa := PgAm{}
err = db.QueryRow(sqlstr, amname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amname, &pa.Amstrategies, &pa.Amsupport, &pa.Amcanorder, &pa.Amcanorderbyop, &pa.Amcanbackward, &pa.Amcanunique, &pa.Amcanmulticol, &pa.Amoptionalkey, &pa.Amsearcharray, &pa.Amsearchnulls, &pa.Amstorage, &pa.Amclusterable, &pa.Ampredlocks, &pa.Amkeytype, &pa.Aminsert, &pa.Ambeginscan, &pa.Amgettuple, &pa.Amgetbitmap, &pa.Amrescan, &pa.Amendscan, &pa.Ammarkpos, &pa.Amrestrpos, &pa.Ambuild, &pa.Ambuildempty, &pa.Ambulkdelete, &pa.Amvacuumcleanup, &pa.Amcanreturn, &pa.Amcostestimate, &pa.Amoptions)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmByAmname(db XODB, amname pgtypes.Name) (*PgAm, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions ` +
`FROM pg_catalog.pg_am ` +
`WHERE amname = $1`
// run query
XOLog(sqlstr, amname)
pa := PgAm{}
err = db.QueryRow(sqlstr, amname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amname, &pa.Amstrategies, &pa.Amsupport, &pa.Amcanorder, &pa.Amcanorderbyop, &pa.Amcanbackward, &pa.Amcanunique, &pa.Amcanmulticol, &pa.Amoptionalkey, &pa.Amsearcharray, &pa.Amsearchnulls, &pa.Amstorage, &pa.Amclusterable, &pa.Ampredlocks, &pa.Amkeytype, &pa.Aminsert, &pa.Ambeginscan, &pa.Amgettuple, &pa.Amgetbitmap, &pa.Amrescan, &pa.Amendscan, &pa.Ammarkpos, &pa.Amrestrpos, &pa.Ambuild, &pa.Ambuildempty, &pa.Ambulkdelete, &pa.Amvacuumcleanup, &pa.Amcanreturn, &pa.Amcostestimate, &pa.Amoptions)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmByAmname",
"(",
"db",
"XODB",
",",
"amname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgAm",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amname, amstrategies, amsupport, amcanorder, amcanorderbyop, amcanbackward, amcanunique, amcanmulticol, amoptionalkey, amsearcharray, amsearchnulls, amstorage, amclusterable, ampredlocks, amkeytype, aminsert, ambeginscan, amgettuple, amgetbitmap, amrescan, amendscan, ammarkpos, amrestrpos, ambuild, ambuildempty, ambulkdelete, amvacuumcleanup, amcanreturn, amcostestimate, amoptions `",
"+",
"`FROM pg_catalog.pg_am `",
"+",
"`WHERE amname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amname",
")",
"\n",
"pa",
":=",
"PgAm",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amname",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amname",
",",
"&",
"pa",
".",
"Amstrategies",
",",
"&",
"pa",
".",
"Amsupport",
",",
"&",
"pa",
".",
"Amcanorder",
",",
"&",
"pa",
".",
"Amcanorderbyop",
",",
"&",
"pa",
".",
"Amcanbackward",
",",
"&",
"pa",
".",
"Amcanunique",
",",
"&",
"pa",
".",
"Amcanmulticol",
",",
"&",
"pa",
".",
"Amoptionalkey",
",",
"&",
"pa",
".",
"Amsearcharray",
",",
"&",
"pa",
".",
"Amsearchnulls",
",",
"&",
"pa",
".",
"Amstorage",
",",
"&",
"pa",
".",
"Amclusterable",
",",
"&",
"pa",
".",
"Ampredlocks",
",",
"&",
"pa",
".",
"Amkeytype",
",",
"&",
"pa",
".",
"Aminsert",
",",
"&",
"pa",
".",
"Ambeginscan",
",",
"&",
"pa",
".",
"Amgettuple",
",",
"&",
"pa",
".",
"Amgetbitmap",
",",
"&",
"pa",
".",
"Amrescan",
",",
"&",
"pa",
".",
"Amendscan",
",",
"&",
"pa",
".",
"Ammarkpos",
",",
"&",
"pa",
".",
"Amrestrpos",
",",
"&",
"pa",
".",
"Ambuild",
",",
"&",
"pa",
".",
"Ambuildempty",
",",
"&",
"pa",
".",
"Ambulkdelete",
",",
"&",
"pa",
".",
"Amvacuumcleanup",
",",
"&",
"pa",
".",
"Amcanreturn",
",",
"&",
"pa",
".",
"Amcostestimate",
",",
"&",
"pa",
".",
"Amoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmByAmname retrieves a row from 'pg_catalog.pg_am' as a PgAm.
//
// Generated from index 'pg_am_name_index'.
|
[
"PgAmByAmname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_am",
"as",
"a",
"PgAm",
".",
"Generated",
"from",
"index",
"pg_am_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41768-L41787
|
22,733
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy
|
func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(db XODB, amopfamily pgtypes.Oid, amoplefttype pgtypes.Oid, amoprighttype pgtypes.Oid, amopstrategy int16) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`
// run query
XOLog(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy(db XODB, amopfamily pgtypes.Oid, amoplefttype pgtypes.Oid, amoprighttype pgtypes.Oid, amopstrategy int16) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`
// run query
XOLog(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopfamily, amoplefttype, amoprighttype, amopstrategy).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy",
"(",
"db",
"XODB",
",",
"amopfamily",
"pgtypes",
".",
"Oid",
",",
"amoplefttype",
"pgtypes",
".",
"Oid",
",",
"amoprighttype",
"pgtypes",
".",
"Oid",
",",
"amopstrategy",
"int16",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE amopfamily = $1 AND amoplefttype = $2 AND amoprighttype = $3 AND amopstrategy = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amopfamily",
",",
"amoplefttype",
",",
"amoprighttype",
",",
"amopstrategy",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amopfamily",
",",
"amoplefttype",
",",
"amoprighttype",
",",
"amopstrategy",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_fam_strat_index'.
|
[
"PgAmopByAmopfamilyAmoplefttypeAmoprighttypeAmopstrategy",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_fam_strat_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41816-L41835
|
22,734
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmopByOid
|
func PgAmopByOid(db XODB, oid pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmop{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmopByOid(db XODB, oid pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmop{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmopByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmopByOid retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_oid_index'.
|
[
"PgAmopByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41840-L41859
|
22,735
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmopByAmopoprAmoppurposeAmopfamily
|
func PgAmopByAmopoprAmoppurposeAmopfamily(db XODB, amopopr pgtypes.Oid, amoppurpose uint8, amopfamily pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`
// run query
XOLog(sqlstr, amopopr, amoppurpose, amopfamily)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmopByAmopoprAmoppurposeAmopfamily(db XODB, amopopr pgtypes.Oid, amoppurpose uint8, amopfamily pgtypes.Oid) (*PgAmop, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily ` +
`FROM pg_catalog.pg_amop ` +
`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`
// run query
XOLog(sqlstr, amopopr, amoppurpose, amopfamily)
pa := PgAmop{}
err = db.QueryRow(sqlstr, amopopr, amoppurpose, amopfamily).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amopfamily, &pa.Amoplefttype, &pa.Amoprighttype, &pa.Amopstrategy, &pa.Amoppurpose, &pa.Amopopr, &pa.Amopmethod, &pa.Amopsortfamily)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmopByAmopoprAmoppurposeAmopfamily",
"(",
"db",
"XODB",
",",
"amopopr",
"pgtypes",
".",
"Oid",
",",
"amoppurpose",
"uint8",
",",
"amopfamily",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmop",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amopfamily, amoplefttype, amoprighttype, amopstrategy, amoppurpose, amopopr, amopmethod, amopsortfamily `",
"+",
"`FROM pg_catalog.pg_amop `",
"+",
"`WHERE amopopr = $1 AND amoppurpose = $2 AND amopfamily = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amopopr",
",",
"amoppurpose",
",",
"amopfamily",
")",
"\n",
"pa",
":=",
"PgAmop",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amopopr",
",",
"amoppurpose",
",",
"amopfamily",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amopfamily",
",",
"&",
"pa",
".",
"Amoplefttype",
",",
"&",
"pa",
".",
"Amoprighttype",
",",
"&",
"pa",
".",
"Amopstrategy",
",",
"&",
"pa",
".",
"Amoppurpose",
",",
"&",
"pa",
".",
"Amopopr",
",",
"&",
"pa",
".",
"Amopmethod",
",",
"&",
"pa",
".",
"Amopsortfamily",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmopByAmopoprAmoppurposeAmopfamily retrieves a row from 'pg_catalog.pg_amop' as a PgAmop.
//
// Generated from index 'pg_amop_opr_fam_index'.
|
[
"PgAmopByAmopoprAmoppurposeAmopfamily",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amop",
"as",
"a",
"PgAmop",
".",
"Generated",
"from",
"index",
"pg_amop_opr_fam_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41864-L41883
|
22,736
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum
|
func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(db XODB, amprocfamily pgtypes.Oid, amproclefttype pgtypes.Oid, amprocrighttype pgtypes.Oid, amprocnum int16) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`
// run query
XOLog(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum(db XODB, amprocfamily pgtypes.Oid, amproclefttype pgtypes.Oid, amprocrighttype pgtypes.Oid, amprocnum int16) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`
// run query
XOLog(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, amprocfamily, amproclefttype, amprocrighttype, amprocnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum",
"(",
"db",
"XODB",
",",
"amprocfamily",
"pgtypes",
".",
"Oid",
",",
"amproclefttype",
"pgtypes",
".",
"Oid",
",",
"amprocrighttype",
"pgtypes",
".",
"Oid",
",",
"amprocnum",
"int16",
")",
"(",
"*",
"PgAmproc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc `",
"+",
"`FROM pg_catalog.pg_amproc `",
"+",
"`WHERE amprocfamily = $1 AND amproclefttype = $2 AND amprocrighttype = $3 AND amprocnum = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"amprocfamily",
",",
"amproclefttype",
",",
"amprocrighttype",
",",
"amprocnum",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"amprocfamily",
",",
"amproclefttype",
",",
"amprocrighttype",
",",
"amprocnum",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amprocfamily",
",",
"&",
"pa",
".",
"Amproclefttype",
",",
"&",
"pa",
".",
"Amprocrighttype",
",",
"&",
"pa",
".",
"Amprocnum",
",",
"&",
"pa",
".",
"Amproc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_fam_proc_index'.
|
[
"PgAmprocByAmprocfamilyAmproclefttypeAmprocrighttypeAmprocnum",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amproc",
"as",
"a",
"PgAmproc",
".",
"Generated",
"from",
"index",
"pg_amproc_fam_proc_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41888-L41907
|
22,737
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAmprocByOid
|
func PgAmprocByOid(db XODB, oid pgtypes.Oid) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAmprocByOid(db XODB, oid pgtypes.Oid) (*PgAmproc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc ` +
`FROM pg_catalog.pg_amproc ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAmproc{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Amprocfamily, &pa.Amproclefttype, &pa.Amprocrighttype, &pa.Amprocnum, &pa.Amproc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAmprocByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAmproc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, amprocfamily, amproclefttype, amprocrighttype, amprocnum, amproc `",
"+",
"`FROM pg_catalog.pg_amproc `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAmproc",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Amprocfamily",
",",
"&",
"pa",
".",
"Amproclefttype",
",",
"&",
"pa",
".",
"Amprocrighttype",
",",
"&",
"pa",
".",
"Amprocnum",
",",
"&",
"pa",
".",
"Amproc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAmprocByOid retrieves a row from 'pg_catalog.pg_amproc' as a PgAmproc.
//
// Generated from index 'pg_amproc_oid_index'.
|
[
"PgAmprocByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_amproc",
"as",
"a",
"PgAmproc",
".",
"Generated",
"from",
"index",
"pg_amproc_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41912-L41931
|
22,738
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAttrdefByAdrelidAdnum
|
func PgAttrdefByAdrelidAdnum(db XODB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE adrelid = $1 AND adnum = $2`
// run query
XOLog(sqlstr, adrelid, adnum)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAttrdefByAdrelidAdnum(db XODB, adrelid pgtypes.Oid, adnum int16) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE adrelid = $1 AND adnum = $2`
// run query
XOLog(sqlstr, adrelid, adnum)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, adrelid, adnum).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAttrdefByAdrelidAdnum",
"(",
"db",
"XODB",
",",
"adrelid",
"pgtypes",
".",
"Oid",
",",
"adnum",
"int16",
")",
"(",
"*",
"PgAttrdef",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc `",
"+",
"`FROM pg_catalog.pg_attrdef `",
"+",
"`WHERE adrelid = $1 AND adnum = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"adrelid",
",",
"adnum",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"adrelid",
",",
"adnum",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Adrelid",
",",
"&",
"pa",
".",
"Adnum",
",",
"&",
"pa",
".",
"Adbin",
",",
"&",
"pa",
".",
"Adsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAttrdefByAdrelidAdnum retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_adrelid_adnum_index'.
|
[
"PgAttrdefByAdrelidAdnum",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attrdef",
"as",
"a",
"PgAttrdef",
".",
"Generated",
"from",
"index",
"pg_attrdef_adrelid_adnum_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41936-L41955
|
22,739
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAttrdefByOid
|
func PgAttrdefByOid(db XODB, oid pgtypes.Oid) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAttrdefByOid(db XODB, oid pgtypes.Oid) (*PgAttrdef, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc ` +
`FROM pg_catalog.pg_attrdef ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAttrdef{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Adrelid, &pa.Adnum, &pa.Adbin, &pa.Adsrc)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAttrdefByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAttrdef",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, adrelid, adnum, adbin, adsrc `",
"+",
"`FROM pg_catalog.pg_attrdef `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAttrdef",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Adrelid",
",",
"&",
"pa",
".",
"Adnum",
",",
"&",
"pa",
".",
"Adbin",
",",
"&",
"pa",
".",
"Adsrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAttrdefByOid retrieves a row from 'pg_catalog.pg_attrdef' as a PgAttrdef.
//
// Generated from index 'pg_attrdef_oid_index'.
|
[
"PgAttrdefByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attrdef",
"as",
"a",
"PgAttrdef",
".",
"Generated",
"from",
"index",
"pg_attrdef_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41960-L41979
|
22,740
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAttributeByAttrelidAttname
|
func PgAttributeByAttrelidAttname(db XODB, attrelid pgtypes.Oid, attname pgtypes.Name) (*PgAttribute, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions ` +
`FROM pg_catalog.pg_attribute ` +
`WHERE attrelid = $1 AND attname = $2`
// run query
XOLog(sqlstr, attrelid, attname)
pa := PgAttribute{}
err = db.QueryRow(sqlstr, attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAttributeByAttrelidAttname(db XODB, attrelid pgtypes.Oid, attname pgtypes.Name) (*PgAttribute, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions ` +
`FROM pg_catalog.pg_attribute ` +
`WHERE attrelid = $1 AND attname = $2`
// run query
XOLog(sqlstr, attrelid, attname)
pa := PgAttribute{}
err = db.QueryRow(sqlstr, attrelid, attname).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Ctid, &pa.Attrelid, &pa.Attname, &pa.Atttypid, &pa.Attstattarget, &pa.Attlen, &pa.Attnum, &pa.Attndims, &pa.Attcacheoff, &pa.Atttypmod, &pa.Attbyval, &pa.Attstorage, &pa.Attalign, &pa.Attnotnull, &pa.Atthasdef, &pa.Attisdropped, &pa.Attislocal, &pa.Attinhcount, &pa.Attcollation, &pa.Attacl, &pa.Attoptions, &pa.Attfdwoptions)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAttributeByAttrelidAttname",
"(",
"db",
"XODB",
",",
"attrelid",
"pgtypes",
".",
"Oid",
",",
"attname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgAttribute",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, attrelid, attname, atttypid, attstattarget, attlen, attnum, attndims, attcacheoff, atttypmod, attbyval, attstorage, attalign, attnotnull, atthasdef, attisdropped, attislocal, attinhcount, attcollation, attacl, attoptions, attfdwoptions `",
"+",
"`FROM pg_catalog.pg_attribute `",
"+",
"`WHERE attrelid = $1 AND attname = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"attrelid",
",",
"attname",
")",
"\n",
"pa",
":=",
"PgAttribute",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"attrelid",
",",
"attname",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Attrelid",
",",
"&",
"pa",
".",
"Attname",
",",
"&",
"pa",
".",
"Atttypid",
",",
"&",
"pa",
".",
"Attstattarget",
",",
"&",
"pa",
".",
"Attlen",
",",
"&",
"pa",
".",
"Attnum",
",",
"&",
"pa",
".",
"Attndims",
",",
"&",
"pa",
".",
"Attcacheoff",
",",
"&",
"pa",
".",
"Atttypmod",
",",
"&",
"pa",
".",
"Attbyval",
",",
"&",
"pa",
".",
"Attstorage",
",",
"&",
"pa",
".",
"Attalign",
",",
"&",
"pa",
".",
"Attnotnull",
",",
"&",
"pa",
".",
"Atthasdef",
",",
"&",
"pa",
".",
"Attisdropped",
",",
"&",
"pa",
".",
"Attislocal",
",",
"&",
"pa",
".",
"Attinhcount",
",",
"&",
"pa",
".",
"Attcollation",
",",
"&",
"pa",
".",
"Attacl",
",",
"&",
"pa",
".",
"Attoptions",
",",
"&",
"pa",
".",
"Attfdwoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAttributeByAttrelidAttname retrieves a row from 'pg_catalog.pg_attribute' as a PgAttribute.
//
// Generated from index 'pg_attribute_relid_attnam_index'.
|
[
"PgAttributeByAttrelidAttname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_attribute",
"as",
"a",
"PgAttribute",
".",
"Generated",
"from",
"index",
"pg_attribute_relid_attnam_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L41984-L42003
|
22,741
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAuthMemberByMemberRoleid
|
func PgAuthMemberByMemberRoleid(db XODB, member pgtypes.Oid, roleid pgtypes.Oid) (*PgAuthMember, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
`FROM pg_catalog.pg_auth_members ` +
`WHERE member = $1 AND roleid = $2`
// run query
XOLog(sqlstr, member, roleid)
pam := PgAuthMember{}
err = db.QueryRow(sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption)
if err != nil {
return nil, err
}
return &pam, nil
}
|
go
|
func PgAuthMemberByMemberRoleid(db XODB, member pgtypes.Oid, roleid pgtypes.Oid) (*PgAuthMember, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option ` +
`FROM pg_catalog.pg_auth_members ` +
`WHERE member = $1 AND roleid = $2`
// run query
XOLog(sqlstr, member, roleid)
pam := PgAuthMember{}
err = db.QueryRow(sqlstr, member, roleid).Scan(&pam.Tableoid, &pam.Cmax, &pam.Xmax, &pam.Cmin, &pam.Xmin, &pam.Ctid, &pam.Roleid, &pam.Member, &pam.Grantor, &pam.AdminOption)
if err != nil {
return nil, err
}
return &pam, nil
}
|
[
"func",
"PgAuthMemberByMemberRoleid",
"(",
"db",
"XODB",
",",
"member",
"pgtypes",
".",
"Oid",
",",
"roleid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAuthMember",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roleid, member, grantor, admin_option `",
"+",
"`FROM pg_catalog.pg_auth_members `",
"+",
"`WHERE member = $1 AND roleid = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"member",
",",
"roleid",
")",
"\n",
"pam",
":=",
"PgAuthMember",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"member",
",",
"roleid",
")",
".",
"Scan",
"(",
"&",
"pam",
".",
"Tableoid",
",",
"&",
"pam",
".",
"Cmax",
",",
"&",
"pam",
".",
"Xmax",
",",
"&",
"pam",
".",
"Cmin",
",",
"&",
"pam",
".",
"Xmin",
",",
"&",
"pam",
".",
"Ctid",
",",
"&",
"pam",
".",
"Roleid",
",",
"&",
"pam",
".",
"Member",
",",
"&",
"pam",
".",
"Grantor",
",",
"&",
"pam",
".",
"AdminOption",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pam",
",",
"nil",
"\n",
"}"
] |
// PgAuthMemberByMemberRoleid retrieves a row from 'pg_catalog.pg_auth_members' as a PgAuthMember.
//
// Generated from index 'pg_auth_members_member_role_index'.
|
[
"PgAuthMemberByMemberRoleid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_auth_members",
"as",
"a",
"PgAuthMember",
".",
"Generated",
"from",
"index",
"pg_auth_members_member_role_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42032-L42051
|
22,742
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgAuthidByOid
|
func PgAuthidByOid(db XODB, oid pgtypes.Oid) (*PgAuthid, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
`FROM pg_catalog.pg_authid ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAuthid{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil)
if err != nil {
return nil, err
}
return &pa, nil
}
|
go
|
func PgAuthidByOid(db XODB, oid pgtypes.Oid) (*PgAuthid, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil ` +
`FROM pg_catalog.pg_authid ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pa := PgAuthid{}
err = db.QueryRow(sqlstr, oid).Scan(&pa.Tableoid, &pa.Cmax, &pa.Xmax, &pa.Cmin, &pa.Xmin, &pa.Oid, &pa.Ctid, &pa.Rolname, &pa.Rolsuper, &pa.Rolinherit, &pa.Rolcreaterole, &pa.Rolcreatedb, &pa.Rolcanlogin, &pa.Rolreplication, &pa.Rolbypassrls, &pa.Rolconnlimit, &pa.Rolpassword, &pa.Rolvaliduntil)
if err != nil {
return nil, err
}
return &pa, nil
}
|
[
"func",
"PgAuthidByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgAuthid",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolbypassrls, rolconnlimit, rolpassword, rolvaliduntil `",
"+",
"`FROM pg_catalog.pg_authid `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pa",
":=",
"PgAuthid",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pa",
".",
"Tableoid",
",",
"&",
"pa",
".",
"Cmax",
",",
"&",
"pa",
".",
"Xmax",
",",
"&",
"pa",
".",
"Cmin",
",",
"&",
"pa",
".",
"Xmin",
",",
"&",
"pa",
".",
"Oid",
",",
"&",
"pa",
".",
"Ctid",
",",
"&",
"pa",
".",
"Rolname",
",",
"&",
"pa",
".",
"Rolsuper",
",",
"&",
"pa",
".",
"Rolinherit",
",",
"&",
"pa",
".",
"Rolcreaterole",
",",
"&",
"pa",
".",
"Rolcreatedb",
",",
"&",
"pa",
".",
"Rolcanlogin",
",",
"&",
"pa",
".",
"Rolreplication",
",",
"&",
"pa",
".",
"Rolbypassrls",
",",
"&",
"pa",
".",
"Rolconnlimit",
",",
"&",
"pa",
".",
"Rolpassword",
",",
"&",
"pa",
".",
"Rolvaliduntil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pa",
",",
"nil",
"\n",
"}"
] |
// PgAuthidByOid retrieves a row from 'pg_catalog.pg_authid' as a PgAuthid.
//
// Generated from index 'pg_authid_oid_index'.
|
[
"PgAuthidByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_authid",
"as",
"a",
"PgAuthid",
".",
"Generated",
"from",
"index",
"pg_authid_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42080-L42099
|
22,743
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgCastByOid
|
func PgCastByOid(db XODB, oid pgtypes.Oid) (*PgCast, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod ` +
`FROM pg_catalog.pg_cast ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCast{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgCastByOid(db XODB, oid pgtypes.Oid) (*PgCast, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod ` +
`FROM pg_catalog.pg_cast ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCast{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Castsource, &pc.Casttarget, &pc.Castfunc, &pc.Castcontext, &pc.Castmethod)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgCastByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCast",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, castsource, casttarget, castfunc, castcontext, castmethod `",
"+",
"`FROM pg_catalog.pg_cast `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCast",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Castsource",
",",
"&",
"pc",
".",
"Casttarget",
",",
"&",
"pc",
".",
"Castfunc",
",",
"&",
"pc",
".",
"Castcontext",
",",
"&",
"pc",
".",
"Castmethod",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgCastByOid retrieves a row from 'pg_catalog.pg_cast' as a PgCast.
//
// Generated from index 'pg_cast_oid_index'.
|
[
"PgCastByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_cast",
"as",
"a",
"PgCast",
".",
"Generated",
"from",
"index",
"pg_cast_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42128-L42147
|
22,744
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgClassByOid
|
func PgClassByOid(db XODB, oid pgtypes.Oid) (*PgClass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions ` +
`FROM pg_catalog.pg_class ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgClass{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasoids, &pc.Relhaspkey, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgClassByOid(db XODB, oid pgtypes.Oid) (*PgClass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions ` +
`FROM pg_catalog.pg_class ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgClass{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Relname, &pc.Relnamespace, &pc.Reltype, &pc.Reloftype, &pc.Relowner, &pc.Relam, &pc.Relfilenode, &pc.Reltablespace, &pc.Relpages, &pc.Reltuples, &pc.Relallvisible, &pc.Reltoastrelid, &pc.Relhasindex, &pc.Relisshared, &pc.Relpersistence, &pc.Relkind, &pc.Relnatts, &pc.Relchecks, &pc.Relhasoids, &pc.Relhaspkey, &pc.Relhasrules, &pc.Relhastriggers, &pc.Relhassubclass, &pc.Relrowsecurity, &pc.Relforcerowsecurity, &pc.Relispopulated, &pc.Relreplident, &pc.Relfrozenxid, &pc.Relminmxid, &pc.Relacl, &pc.Reloptions)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgClassByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgClass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, relname, relnamespace, reltype, reloftype, relowner, relam, relfilenode, reltablespace, relpages, reltuples, relallvisible, reltoastrelid, relhasindex, relisshared, relpersistence, relkind, relnatts, relchecks, relhasoids, relhaspkey, relhasrules, relhastriggers, relhassubclass, relrowsecurity, relforcerowsecurity, relispopulated, relreplident, relfrozenxid, relminmxid, relacl, reloptions `",
"+",
"`FROM pg_catalog.pg_class `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgClass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Relname",
",",
"&",
"pc",
".",
"Relnamespace",
",",
"&",
"pc",
".",
"Reltype",
",",
"&",
"pc",
".",
"Reloftype",
",",
"&",
"pc",
".",
"Relowner",
",",
"&",
"pc",
".",
"Relam",
",",
"&",
"pc",
".",
"Relfilenode",
",",
"&",
"pc",
".",
"Reltablespace",
",",
"&",
"pc",
".",
"Relpages",
",",
"&",
"pc",
".",
"Reltuples",
",",
"&",
"pc",
".",
"Relallvisible",
",",
"&",
"pc",
".",
"Reltoastrelid",
",",
"&",
"pc",
".",
"Relhasindex",
",",
"&",
"pc",
".",
"Relisshared",
",",
"&",
"pc",
".",
"Relpersistence",
",",
"&",
"pc",
".",
"Relkind",
",",
"&",
"pc",
".",
"Relnatts",
",",
"&",
"pc",
".",
"Relchecks",
",",
"&",
"pc",
".",
"Relhasoids",
",",
"&",
"pc",
".",
"Relhaspkey",
",",
"&",
"pc",
".",
"Relhasrules",
",",
"&",
"pc",
".",
"Relhastriggers",
",",
"&",
"pc",
".",
"Relhassubclass",
",",
"&",
"pc",
".",
"Relrowsecurity",
",",
"&",
"pc",
".",
"Relforcerowsecurity",
",",
"&",
"pc",
".",
"Relispopulated",
",",
"&",
"pc",
".",
"Relreplident",
",",
"&",
"pc",
".",
"Relfrozenxid",
",",
"&",
"pc",
".",
"Relminmxid",
",",
"&",
"pc",
".",
"Relacl",
",",
"&",
"pc",
".",
"Reloptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgClassByOid retrieves a row from 'pg_catalog.pg_class' as a PgClass.
//
// Generated from index 'pg_class_oid_index'.
|
[
"PgClassByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_class",
"as",
"a",
"PgClass",
".",
"Generated",
"from",
"index",
"pg_class_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42176-L42195
|
22,745
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgCollationByCollnameCollencodingCollnamespace
|
func PgCollationByCollnameCollencodingCollnamespace(db XODB, collname pgtypes.Name, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`
// run query
XOLog(sqlstr, collname, collencoding, collnamespace)
pc := PgCollation{}
err = db.QueryRow(sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgCollationByCollnameCollencodingCollnamespace(db XODB, collname pgtypes.Name, collencoding int, collnamespace pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`
// run query
XOLog(sqlstr, collname, collencoding, collnamespace)
pc := PgCollation{}
err = db.QueryRow(sqlstr, collname, collencoding, collnamespace).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgCollationByCollnameCollencodingCollnamespace",
"(",
"db",
"XODB",
",",
"collname",
"pgtypes",
".",
"Name",
",",
"collencoding",
"int",
",",
"collnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCollation",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype `",
"+",
"`FROM pg_catalog.pg_collation `",
"+",
"`WHERE collname = $1 AND collencoding = $2 AND collnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"collname",
",",
"collencoding",
",",
"collnamespace",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"collname",
",",
"collencoding",
",",
"collnamespace",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Collname",
",",
"&",
"pc",
".",
"Collnamespace",
",",
"&",
"pc",
".",
"Collowner",
",",
"&",
"pc",
".",
"Collencoding",
",",
"&",
"pc",
".",
"Collcollate",
",",
"&",
"pc",
".",
"Collctype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgCollationByCollnameCollencodingCollnamespace retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_name_enc_nsp_index'.
|
[
"PgCollationByCollnameCollencodingCollnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_collation",
"as",
"a",
"PgCollation",
".",
"Generated",
"from",
"index",
"pg_collation_name_enc_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42261-L42280
|
22,746
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgCollationByOid
|
func PgCollationByOid(db XODB, oid pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCollation{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgCollationByOid(db XODB, oid pgtypes.Oid) (*PgCollation, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype ` +
`FROM pg_catalog.pg_collation ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgCollation{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Collname, &pc.Collnamespace, &pc.Collowner, &pc.Collencoding, &pc.Collcollate, &pc.Collctype)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgCollationByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgCollation",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, collname, collnamespace, collowner, collencoding, collcollate, collctype `",
"+",
"`FROM pg_catalog.pg_collation `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgCollation",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Collname",
",",
"&",
"pc",
".",
"Collnamespace",
",",
"&",
"pc",
".",
"Collowner",
",",
"&",
"pc",
".",
"Collencoding",
",",
"&",
"pc",
".",
"Collcollate",
",",
"&",
"pc",
".",
"Collctype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgCollationByOid retrieves a row from 'pg_catalog.pg_collation' as a PgCollation.
//
// Generated from index 'pg_collation_oid_index'.
|
[
"PgCollationByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_collation",
"as",
"a",
"PgCollation",
".",
"Generated",
"from",
"index",
"pg_collation_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42285-L42304
|
22,747
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgConstraintsByConnameConnamespace
|
func PgConstraintsByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) ([]*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE conname = $1 AND connamespace = $2`
// run query
XOLog(sqlstr, conname, connamespace)
q, err := db.Query(sqlstr, conname, connamespace)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgConstraint{}
for q.Next() {
pc := PgConstraint{}
// scan
err = q.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
res = append(res, &pc)
}
return res, nil
}
|
go
|
func PgConstraintsByConnameConnamespace(db XODB, conname pgtypes.Name, connamespace pgtypes.Oid) ([]*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE conname = $1 AND connamespace = $2`
// run query
XOLog(sqlstr, conname, connamespace)
q, err := db.Query(sqlstr, conname, connamespace)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgConstraint{}
for q.Next() {
pc := PgConstraint{}
// scan
err = q.Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
res = append(res, &pc)
}
return res, nil
}
|
[
"func",
"PgConstraintsByConnameConnamespace",
"(",
"db",
"XODB",
",",
"conname",
"pgtypes",
".",
"Name",
",",
"connamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgConstraint",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc `",
"+",
"`FROM pg_catalog.pg_constraint `",
"+",
"`WHERE conname = $1 AND connamespace = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"conname",
",",
"connamespace",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"conname",
",",
"connamespace",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgConstraint",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Contype",
",",
"&",
"pc",
".",
"Condeferrable",
",",
"&",
"pc",
".",
"Condeferred",
",",
"&",
"pc",
".",
"Convalidated",
",",
"&",
"pc",
".",
"Conrelid",
",",
"&",
"pc",
".",
"Contypid",
",",
"&",
"pc",
".",
"Conindid",
",",
"&",
"pc",
".",
"Confrelid",
",",
"&",
"pc",
".",
"Confupdtype",
",",
"&",
"pc",
".",
"Confdeltype",
",",
"&",
"pc",
".",
"Confmatchtype",
",",
"&",
"pc",
".",
"Conislocal",
",",
"&",
"pc",
".",
"Coninhcount",
",",
"&",
"pc",
".",
"Connoinherit",
",",
"&",
"pc",
".",
"Conkey",
",",
"&",
"pc",
".",
"Confkey",
",",
"&",
"pc",
".",
"Conpfeqop",
",",
"&",
"pc",
".",
"Conppeqop",
",",
"&",
"pc",
".",
"Conffeqop",
",",
"&",
"pc",
".",
"Conexclop",
",",
"&",
"pc",
".",
"Conbin",
",",
"&",
"pc",
".",
"Consrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pc",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgConstraintsByConnameConnamespace retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_conname_nsp_index'.
|
[
"PgConstraintsByConnameConnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_constraint",
"as",
"a",
"PgConstraint",
".",
"Generated",
"from",
"index",
"pg_constraint_conname_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42309-L42341
|
22,748
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgConstraintByOid
|
func PgConstraintByOid(db XODB, oid pgtypes.Oid) (*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgConstraint{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgConstraintByOid(db XODB, oid pgtypes.Oid) (*PgConstraint, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc ` +
`FROM pg_catalog.pg_constraint ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pc := PgConstraint{}
err = db.QueryRow(sqlstr, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Contype, &pc.Condeferrable, &pc.Condeferred, &pc.Convalidated, &pc.Conrelid, &pc.Contypid, &pc.Conindid, &pc.Confrelid, &pc.Confupdtype, &pc.Confdeltype, &pc.Confmatchtype, &pc.Conislocal, &pc.Coninhcount, &pc.Connoinherit, &pc.Conkey, &pc.Confkey, &pc.Conpfeqop, &pc.Conppeqop, &pc.Conffeqop, &pc.Conexclop, &pc.Conbin, &pc.Consrc)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgConstraintByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgConstraint",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, contype, condeferrable, condeferred, convalidated, conrelid, contypid, conindid, confrelid, confupdtype, confdeltype, confmatchtype, conislocal, coninhcount, connoinherit, conkey, confkey, conpfeqop, conppeqop, conffeqop, conexclop, conbin, consrc `",
"+",
"`FROM pg_catalog.pg_constraint `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConstraint",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Contype",
",",
"&",
"pc",
".",
"Condeferrable",
",",
"&",
"pc",
".",
"Condeferred",
",",
"&",
"pc",
".",
"Convalidated",
",",
"&",
"pc",
".",
"Conrelid",
",",
"&",
"pc",
".",
"Contypid",
",",
"&",
"pc",
".",
"Conindid",
",",
"&",
"pc",
".",
"Confrelid",
",",
"&",
"pc",
".",
"Confupdtype",
",",
"&",
"pc",
".",
"Confdeltype",
",",
"&",
"pc",
".",
"Confmatchtype",
",",
"&",
"pc",
".",
"Conislocal",
",",
"&",
"pc",
".",
"Coninhcount",
",",
"&",
"pc",
".",
"Connoinherit",
",",
"&",
"pc",
".",
"Conkey",
",",
"&",
"pc",
".",
"Confkey",
",",
"&",
"pc",
".",
"Conpfeqop",
",",
"&",
"pc",
".",
"Conppeqop",
",",
"&",
"pc",
".",
"Conffeqop",
",",
"&",
"pc",
".",
"Conexclop",
",",
"&",
"pc",
".",
"Conbin",
",",
"&",
"pc",
".",
"Consrc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgConstraintByOid retrieves a row from 'pg_catalog.pg_constraint' as a PgConstraint.
//
// Generated from index 'pg_constraint_oid_index'.
|
[
"PgConstraintByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_constraint",
"as",
"a",
"PgConstraint",
".",
"Generated",
"from",
"index",
"pg_constraint_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42420-L42439
|
22,749
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgConversionByConnamespaceConforencodingContoencodingOid
|
func PgConversionByConnamespaceConforencodingContoencodingOid(db XODB, connamespace pgtypes.Oid, conforencoding int, contoencoding int, oid pgtypes.Oid) (*PgConversion, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
`FROM pg_catalog.pg_conversion ` +
`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`
// run query
XOLog(sqlstr, connamespace, conforencoding, contoencoding, oid)
pc := PgConversion{}
err = db.QueryRow(sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault)
if err != nil {
return nil, err
}
return &pc, nil
}
|
go
|
func PgConversionByConnamespaceConforencodingContoencodingOid(db XODB, connamespace pgtypes.Oid, conforencoding int, contoencoding int, oid pgtypes.Oid) (*PgConversion, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault ` +
`FROM pg_catalog.pg_conversion ` +
`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`
// run query
XOLog(sqlstr, connamespace, conforencoding, contoencoding, oid)
pc := PgConversion{}
err = db.QueryRow(sqlstr, connamespace, conforencoding, contoencoding, oid).Scan(&pc.Tableoid, &pc.Cmax, &pc.Xmax, &pc.Cmin, &pc.Xmin, &pc.Oid, &pc.Ctid, &pc.Conname, &pc.Connamespace, &pc.Conowner, &pc.Conforencoding, &pc.Contoencoding, &pc.Conproc, &pc.Condefault)
if err != nil {
return nil, err
}
return &pc, nil
}
|
[
"func",
"PgConversionByConnamespaceConforencodingContoencodingOid",
"(",
"db",
"XODB",
",",
"connamespace",
"pgtypes",
".",
"Oid",
",",
"conforencoding",
"int",
",",
"contoencoding",
"int",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgConversion",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, conname, connamespace, conowner, conforencoding, contoencoding, conproc, condefault `",
"+",
"`FROM pg_catalog.pg_conversion `",
"+",
"`WHERE connamespace = $1 AND conforencoding = $2 AND contoencoding = $3 AND oid = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"connamespace",
",",
"conforencoding",
",",
"contoencoding",
",",
"oid",
")",
"\n",
"pc",
":=",
"PgConversion",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"connamespace",
",",
"conforencoding",
",",
"contoencoding",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pc",
".",
"Tableoid",
",",
"&",
"pc",
".",
"Cmax",
",",
"&",
"pc",
".",
"Xmax",
",",
"&",
"pc",
".",
"Cmin",
",",
"&",
"pc",
".",
"Xmin",
",",
"&",
"pc",
".",
"Oid",
",",
"&",
"pc",
".",
"Ctid",
",",
"&",
"pc",
".",
"Conname",
",",
"&",
"pc",
".",
"Connamespace",
",",
"&",
"pc",
".",
"Conowner",
",",
"&",
"pc",
".",
"Conforencoding",
",",
"&",
"pc",
".",
"Contoencoding",
",",
"&",
"pc",
".",
"Conproc",
",",
"&",
"pc",
".",
"Condefault",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pc",
",",
"nil",
"\n",
"}"
] |
// PgConversionByConnamespaceConforencodingContoencodingOid retrieves a row from 'pg_catalog.pg_conversion' as a PgConversion.
//
// Generated from index 'pg_conversion_default_index'.
|
[
"PgConversionByConnamespaceConforencodingContoencodingOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_conversion",
"as",
"a",
"PgConversion",
".",
"Generated",
"from",
"index",
"pg_conversion_default_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42444-L42463
|
22,750
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDatabaseByDatname
|
func PgDatabaseByDatname(db XODB, datname pgtypes.Name) (*PgDatabase, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
`FROM pg_catalog.pg_database ` +
`WHERE datname = $1`
// run query
XOLog(sqlstr, datname)
pd := PgDatabase{}
err = db.QueryRow(sqlstr, datname).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Oid, &pd.Ctid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl)
if err != nil {
return nil, err
}
return &pd, nil
}
|
go
|
func PgDatabaseByDatname(db XODB, datname pgtypes.Name) (*PgDatabase, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl ` +
`FROM pg_catalog.pg_database ` +
`WHERE datname = $1`
// run query
XOLog(sqlstr, datname)
pd := PgDatabase{}
err = db.QueryRow(sqlstr, datname).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Oid, &pd.Ctid, &pd.Datname, &pd.Datdba, &pd.Encoding, &pd.Datcollate, &pd.Datctype, &pd.Datistemplate, &pd.Datallowconn, &pd.Datconnlimit, &pd.Datlastsysoid, &pd.Datfrozenxid, &pd.Datminmxid, &pd.Dattablespace, &pd.Datacl)
if err != nil {
return nil, err
}
return &pd, nil
}
|
[
"func",
"PgDatabaseByDatname",
"(",
"db",
"XODB",
",",
"datname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgDatabase",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, datname, datdba, encoding, datcollate, datctype, datistemplate, datallowconn, datconnlimit, datlastsysoid, datfrozenxid, datminmxid, dattablespace, datacl `",
"+",
"`FROM pg_catalog.pg_database `",
"+",
"`WHERE datname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"datname",
")",
"\n",
"pd",
":=",
"PgDatabase",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"datname",
")",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Oid",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Datname",
",",
"&",
"pd",
".",
"Datdba",
",",
"&",
"pd",
".",
"Encoding",
",",
"&",
"pd",
".",
"Datcollate",
",",
"&",
"pd",
".",
"Datctype",
",",
"&",
"pd",
".",
"Datistemplate",
",",
"&",
"pd",
".",
"Datallowconn",
",",
"&",
"pd",
".",
"Datconnlimit",
",",
"&",
"pd",
".",
"Datlastsysoid",
",",
"&",
"pd",
".",
"Datfrozenxid",
",",
"&",
"pd",
".",
"Datminmxid",
",",
"&",
"pd",
".",
"Dattablespace",
",",
"&",
"pd",
".",
"Datacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pd",
",",
"nil",
"\n",
"}"
] |
// PgDatabaseByDatname retrieves a row from 'pg_catalog.pg_database' as a PgDatabase.
//
// Generated from index 'pg_database_datname_index'.
|
[
"PgDatabaseByDatname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_database",
"as",
"a",
"PgDatabase",
".",
"Generated",
"from",
"index",
"pg_database_datname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42516-L42535
|
22,751
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDbRoleSettingBySetdatabaseSetrole
|
func PgDbRoleSettingBySetdatabaseSetrole(db XODB, setdatabase pgtypes.Oid, setrole pgtypes.Oid) (*PgDbRoleSetting, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig ` +
`FROM pg_catalog.pg_db_role_setting ` +
`WHERE setdatabase = $1 AND setrole = $2`
// run query
XOLog(sqlstr, setdatabase, setrole)
pdrs := PgDbRoleSetting{}
err = db.QueryRow(sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig)
if err != nil {
return nil, err
}
return &pdrs, nil
}
|
go
|
func PgDbRoleSettingBySetdatabaseSetrole(db XODB, setdatabase pgtypes.Oid, setrole pgtypes.Oid) (*PgDbRoleSetting, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig ` +
`FROM pg_catalog.pg_db_role_setting ` +
`WHERE setdatabase = $1 AND setrole = $2`
// run query
XOLog(sqlstr, setdatabase, setrole)
pdrs := PgDbRoleSetting{}
err = db.QueryRow(sqlstr, setdatabase, setrole).Scan(&pdrs.Tableoid, &pdrs.Cmax, &pdrs.Xmax, &pdrs.Cmin, &pdrs.Xmin, &pdrs.Ctid, &pdrs.Setdatabase, &pdrs.Setrole, &pdrs.Setconfig)
if err != nil {
return nil, err
}
return &pdrs, nil
}
|
[
"func",
"PgDbRoleSettingBySetdatabaseSetrole",
"(",
"db",
"XODB",
",",
"setdatabase",
"pgtypes",
".",
"Oid",
",",
"setrole",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgDbRoleSetting",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, setdatabase, setrole, setconfig `",
"+",
"`FROM pg_catalog.pg_db_role_setting `",
"+",
"`WHERE setdatabase = $1 AND setrole = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"setdatabase",
",",
"setrole",
")",
"\n",
"pdrs",
":=",
"PgDbRoleSetting",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"setdatabase",
",",
"setrole",
")",
".",
"Scan",
"(",
"&",
"pdrs",
".",
"Tableoid",
",",
"&",
"pdrs",
".",
"Cmax",
",",
"&",
"pdrs",
".",
"Xmax",
",",
"&",
"pdrs",
".",
"Cmin",
",",
"&",
"pdrs",
".",
"Xmin",
",",
"&",
"pdrs",
".",
"Ctid",
",",
"&",
"pdrs",
".",
"Setdatabase",
",",
"&",
"pdrs",
".",
"Setrole",
",",
"&",
"pdrs",
".",
"Setconfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pdrs",
",",
"nil",
"\n",
"}"
] |
// PgDbRoleSettingBySetdatabaseSetrole retrieves a row from 'pg_catalog.pg_db_role_setting' as a PgDbRoleSetting.
//
// Generated from index 'pg_db_role_setting_databaseid_rol_index'.
|
[
"PgDbRoleSettingBySetdatabaseSetrole",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_db_role_setting",
"as",
"a",
"PgDbRoleSetting",
".",
"Generated",
"from",
"index",
"pg_db_role_setting_databaseid_rol_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42564-L42583
|
22,752
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDefaultACLByOid
|
func PgDefaultACLByOid(db XODB, oid pgtypes.Oid) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
}
|
go
|
func PgDefaultACLByOid(db XODB, oid pgtypes.Oid) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, oid).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
}
|
[
"func",
"PgDefaultACLByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgDefaultACL",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl `",
"+",
"`FROM pg_catalog.pg_default_acl `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pda",
".",
"Tableoid",
",",
"&",
"pda",
".",
"Cmax",
",",
"&",
"pda",
".",
"Xmax",
",",
"&",
"pda",
".",
"Cmin",
",",
"&",
"pda",
".",
"Xmin",
",",
"&",
"pda",
".",
"Oid",
",",
"&",
"pda",
".",
"Ctid",
",",
"&",
"pda",
".",
"Defaclrole",
",",
"&",
"pda",
".",
"Defaclnamespace",
",",
"&",
"pda",
".",
"Defaclobjtype",
",",
"&",
"pda",
".",
"Defaclacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pda",
",",
"nil",
"\n",
"}"
] |
// PgDefaultACLByOid retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_oid_index'.
|
[
"PgDefaultACLByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_default_acl",
"as",
"a",
"PgDefaultACL",
".",
"Generated",
"from",
"index",
"pg_default_acl_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42588-L42607
|
22,753
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype
|
func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(db XODB, defaclrole pgtypes.Oid, defaclnamespace pgtypes.Oid, defaclobjtype uint8) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`
// run query
XOLog(sqlstr, defaclrole, defaclnamespace, defaclobjtype)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
}
|
go
|
func PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype(db XODB, defaclrole pgtypes.Oid, defaclnamespace pgtypes.Oid, defaclobjtype uint8) (*PgDefaultACL, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl ` +
`FROM pg_catalog.pg_default_acl ` +
`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`
// run query
XOLog(sqlstr, defaclrole, defaclnamespace, defaclobjtype)
pda := PgDefaultACL{}
err = db.QueryRow(sqlstr, defaclrole, defaclnamespace, defaclobjtype).Scan(&pda.Tableoid, &pda.Cmax, &pda.Xmax, &pda.Cmin, &pda.Xmin, &pda.Oid, &pda.Ctid, &pda.Defaclrole, &pda.Defaclnamespace, &pda.Defaclobjtype, &pda.Defaclacl)
if err != nil {
return nil, err
}
return &pda, nil
}
|
[
"func",
"PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype",
"(",
"db",
"XODB",
",",
"defaclrole",
"pgtypes",
".",
"Oid",
",",
"defaclnamespace",
"pgtypes",
".",
"Oid",
",",
"defaclobjtype",
"uint8",
")",
"(",
"*",
"PgDefaultACL",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, defaclrole, defaclnamespace, defaclobjtype, defaclacl `",
"+",
"`FROM pg_catalog.pg_default_acl `",
"+",
"`WHERE defaclrole = $1 AND defaclnamespace = $2 AND defaclobjtype = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"defaclrole",
",",
"defaclnamespace",
",",
"defaclobjtype",
")",
"\n",
"pda",
":=",
"PgDefaultACL",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"defaclrole",
",",
"defaclnamespace",
",",
"defaclobjtype",
")",
".",
"Scan",
"(",
"&",
"pda",
".",
"Tableoid",
",",
"&",
"pda",
".",
"Cmax",
",",
"&",
"pda",
".",
"Xmax",
",",
"&",
"pda",
".",
"Cmin",
",",
"&",
"pda",
".",
"Xmin",
",",
"&",
"pda",
".",
"Oid",
",",
"&",
"pda",
".",
"Ctid",
",",
"&",
"pda",
".",
"Defaclrole",
",",
"&",
"pda",
".",
"Defaclnamespace",
",",
"&",
"pda",
".",
"Defaclobjtype",
",",
"&",
"pda",
".",
"Defaclacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pda",
",",
"nil",
"\n",
"}"
] |
// PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype retrieves a row from 'pg_catalog.pg_default_acl' as a PgDefaultACL.
//
// Generated from index 'pg_default_acl_role_nsp_obj_index'.
|
[
"PgDefaultACLByDefaclroleDefaclnamespaceDefaclobjtype",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_default_acl",
"as",
"a",
"PgDefaultACL",
".",
"Generated",
"from",
"index",
"pg_default_acl_role_nsp_obj_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42612-L42631
|
22,754
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDependsByClassidObjidObjsubid
|
func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
}
|
go
|
func PgDependsByClassidObjidObjsubid(db XODB, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgDepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype ` +
`FROM pg_catalog.pg_depend ` +
`WHERE classid = $1 AND objid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, classid, objid, objsubid)
q, err := db.Query(sqlstr, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgDepend{}
for q.Next() {
pd := PgDepend{}
// scan
err = q.Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Classid, &pd.Objid, &pd.Objsubid, &pd.Refclassid, &pd.Refobjid, &pd.Refobjsubid, &pd.Deptype)
if err != nil {
return nil, err
}
res = append(res, &pd)
}
return res, nil
}
|
[
"func",
"PgDependsByClassidObjidObjsubid",
"(",
"db",
"XODB",
",",
"classid",
"pgtypes",
".",
"Oid",
",",
"objid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"[",
"]",
"*",
"PgDepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, classid, objid, objsubid, refclassid, refobjid, refobjsubid, deptype `",
"+",
"`FROM pg_catalog.pg_depend `",
"+",
"`WHERE classid = $1 AND objid = $2 AND objsubid = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgDepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pd",
":=",
"PgDepend",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Classid",
",",
"&",
"pd",
".",
"Objid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Refclassid",
",",
"&",
"pd",
".",
"Refobjid",
",",
"&",
"pd",
".",
"Refobjsubid",
",",
"&",
"pd",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pd",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgDependsByClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_depend' as a PgDepend.
//
// Generated from index 'pg_depend_depender_index'.
|
[
"PgDependsByClassidObjidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_depend",
"as",
"a",
"PgDepend",
".",
"Generated",
"from",
"index",
"pg_depend_depender_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42636-L42668
|
22,755
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgDescriptionByObjoidClassoidObjsubid
|
func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
}
|
go
|
func PgDescriptionByObjoidClassoidObjsubid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int) (*PgDescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description ` +
`FROM pg_catalog.pg_description ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`
// run query
XOLog(sqlstr, objoid, classoid, objsubid)
pd := PgDescription{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid).Scan(&pd.Tableoid, &pd.Cmax, &pd.Xmax, &pd.Cmin, &pd.Xmin, &pd.Ctid, &pd.Objoid, &pd.Classoid, &pd.Objsubid, &pd.Description)
if err != nil {
return nil, err
}
return &pd, nil
}
|
[
"func",
"PgDescriptionByObjoidClassoidObjsubid",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"*",
"PgDescription",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, description `",
"+",
"`FROM pg_catalog.pg_description `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
"\n",
"pd",
":=",
"PgDescription",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
")",
".",
"Scan",
"(",
"&",
"pd",
".",
"Tableoid",
",",
"&",
"pd",
".",
"Cmax",
",",
"&",
"pd",
".",
"Xmax",
",",
"&",
"pd",
".",
"Cmin",
",",
"&",
"pd",
".",
"Xmin",
",",
"&",
"pd",
".",
"Ctid",
",",
"&",
"pd",
".",
"Objoid",
",",
"&",
"pd",
".",
"Classoid",
",",
"&",
"pd",
".",
"Objsubid",
",",
"&",
"pd",
".",
"Description",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pd",
",",
"nil",
"\n",
"}"
] |
// PgDescriptionByObjoidClassoidObjsubid retrieves a row from 'pg_catalog.pg_description' as a PgDescription.
//
// Generated from index 'pg_description_o_c_o_index'.
|
[
"PgDescriptionByObjoidClassoidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_description",
"as",
"a",
"PgDescription",
".",
"Generated",
"from",
"index",
"pg_description_o_c_o_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42710-L42729
|
22,756
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByOid
|
func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByOid(db XODB, oid pgtypes.Oid) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pe := PgEnum{}
err = db.QueryRow(sqlstr, oid).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByOid retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_oid_index'.
|
[
"PgEnumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42734-L42753
|
22,757
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByEnumtypidEnumlabel
|
func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByEnumtypidEnumlabel(db XODB, enumtypid pgtypes.Oid, enumlabel pgtypes.Name) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumlabel = $2`
// run query
XOLog(sqlstr, enumtypid, enumlabel)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumlabel).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByEnumtypidEnumlabel",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumlabel",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumlabel = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumlabel",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByEnumtypidEnumlabel retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_label_index'.
|
[
"PgEnumByEnumtypidEnumlabel",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_label_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42758-L42777
|
22,758
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEnumByEnumtypidEnumsortorder
|
func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgEnumByEnumtypidEnumsortorder(db XODB, enumtypid pgtypes.Oid, enumsortorder float32) (*PgEnum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel ` +
`FROM pg_catalog.pg_enum ` +
`WHERE enumtypid = $1 AND enumsortorder = $2`
// run query
XOLog(sqlstr, enumtypid, enumsortorder)
pe := PgEnum{}
err = db.QueryRow(sqlstr, enumtypid, enumsortorder).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Enumtypid, &pe.Enumsortorder, &pe.Enumlabel)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgEnumByEnumtypidEnumsortorder",
"(",
"db",
"XODB",
",",
"enumtypid",
"pgtypes",
".",
"Oid",
",",
"enumsortorder",
"float32",
")",
"(",
"*",
"PgEnum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, enumtypid, enumsortorder, enumlabel `",
"+",
"`FROM pg_catalog.pg_enum `",
"+",
"`WHERE enumtypid = $1 AND enumsortorder = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
"\n",
"pe",
":=",
"PgEnum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"enumtypid",
",",
"enumsortorder",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Enumtypid",
",",
"&",
"pe",
".",
"Enumsortorder",
",",
"&",
"pe",
".",
"Enumlabel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgEnumByEnumtypidEnumsortorder retrieves a row from 'pg_catalog.pg_enum' as a PgEnum.
//
// Generated from index 'pg_enum_typid_sortorder_index'.
|
[
"PgEnumByEnumtypidEnumsortorder",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_enum",
"as",
"a",
"PgEnum",
".",
"Generated",
"from",
"index",
"pg_enum_typid_sortorder_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42782-L42801
|
22,759
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgEventTriggerByEvtname
|
func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
}
|
go
|
func PgEventTriggerByEvtname(db XODB, evtname pgtypes.Name) (*PgEventTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags ` +
`FROM pg_catalog.pg_event_trigger ` +
`WHERE evtname = $1`
// run query
XOLog(sqlstr, evtname)
pet := PgEventTrigger{}
err = db.QueryRow(sqlstr, evtname).Scan(&pet.Tableoid, &pet.Cmax, &pet.Xmax, &pet.Cmin, &pet.Xmin, &pet.Oid, &pet.Ctid, &pet.Evtname, &pet.Evtevent, &pet.Evtowner, &pet.Evtfoid, &pet.Evtenabled, &pet.Evttags)
if err != nil {
return nil, err
}
return &pet, nil
}
|
[
"func",
"PgEventTriggerByEvtname",
"(",
"db",
"XODB",
",",
"evtname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgEventTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, evtname, evtevent, evtowner, evtfoid, evtenabled, evttags `",
"+",
"`FROM pg_catalog.pg_event_trigger `",
"+",
"`WHERE evtname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"evtname",
")",
"\n",
"pet",
":=",
"PgEventTrigger",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"evtname",
")",
".",
"Scan",
"(",
"&",
"pet",
".",
"Tableoid",
",",
"&",
"pet",
".",
"Cmax",
",",
"&",
"pet",
".",
"Xmax",
",",
"&",
"pet",
".",
"Cmin",
",",
"&",
"pet",
".",
"Xmin",
",",
"&",
"pet",
".",
"Oid",
",",
"&",
"pet",
".",
"Ctid",
",",
"&",
"pet",
".",
"Evtname",
",",
"&",
"pet",
".",
"Evtevent",
",",
"&",
"pet",
".",
"Evtowner",
",",
"&",
"pet",
".",
"Evtfoid",
",",
"&",
"pet",
".",
"Evtenabled",
",",
"&",
"pet",
".",
"Evttags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pet",
",",
"nil",
"\n",
"}"
] |
// PgEventTriggerByEvtname retrieves a row from 'pg_catalog.pg_event_trigger' as a PgEventTrigger.
//
// Generated from index 'pg_event_trigger_evtname_index'.
|
[
"PgEventTriggerByEvtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_event_trigger",
"as",
"a",
"PgEventTrigger",
".",
"Generated",
"from",
"index",
"pg_event_trigger_evtname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42806-L42825
|
22,760
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgExtensionByExtname
|
func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
}
|
go
|
func PgExtensionByExtname(db XODB, extname pgtypes.Name) (*PgExtension, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition ` +
`FROM pg_catalog.pg_extension ` +
`WHERE extname = $1`
// run query
XOLog(sqlstr, extname)
pe := PgExtension{}
err = db.QueryRow(sqlstr, extname).Scan(&pe.Tableoid, &pe.Cmax, &pe.Xmax, &pe.Cmin, &pe.Xmin, &pe.Oid, &pe.Ctid, &pe.Extname, &pe.Extowner, &pe.Extnamespace, &pe.Extrelocatable, &pe.Extversion, &pe.Extconfig, &pe.Extcondition)
if err != nil {
return nil, err
}
return &pe, nil
}
|
[
"func",
"PgExtensionByExtname",
"(",
"db",
"XODB",
",",
"extname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgExtension",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, extname, extowner, extnamespace, extrelocatable, extversion, extconfig, extcondition `",
"+",
"`FROM pg_catalog.pg_extension `",
"+",
"`WHERE extname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"extname",
")",
"\n",
"pe",
":=",
"PgExtension",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"extname",
")",
".",
"Scan",
"(",
"&",
"pe",
".",
"Tableoid",
",",
"&",
"pe",
".",
"Cmax",
",",
"&",
"pe",
".",
"Xmax",
",",
"&",
"pe",
".",
"Cmin",
",",
"&",
"pe",
".",
"Xmin",
",",
"&",
"pe",
".",
"Oid",
",",
"&",
"pe",
".",
"Ctid",
",",
"&",
"pe",
".",
"Extname",
",",
"&",
"pe",
".",
"Extowner",
",",
"&",
"pe",
".",
"Extnamespace",
",",
"&",
"pe",
".",
"Extrelocatable",
",",
"&",
"pe",
".",
"Extversion",
",",
"&",
"pe",
".",
"Extconfig",
",",
"&",
"pe",
".",
"Extcondition",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pe",
",",
"nil",
"\n",
"}"
] |
// PgExtensionByExtname retrieves a row from 'pg_catalog.pg_extension' as a PgExtension.
//
// Generated from index 'pg_extension_name_index'.
|
[
"PgExtensionByExtname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_extension",
"as",
"a",
"PgExtension",
".",
"Generated",
"from",
"index",
"pg_extension_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42854-L42873
|
22,761
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignDataWrapperByOid
|
func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
}
|
go
|
func PgForeignDataWrapperByOid(db XODB, oid pgtypes.Oid) (*PgForeignDataWrapper, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions ` +
`FROM pg_catalog.pg_foreign_data_wrapper ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pfdw := PgForeignDataWrapper{}
err = db.QueryRow(sqlstr, oid).Scan(&pfdw.Tableoid, &pfdw.Cmax, &pfdw.Xmax, &pfdw.Cmin, &pfdw.Xmin, &pfdw.Oid, &pfdw.Ctid, &pfdw.Fdwname, &pfdw.Fdwowner, &pfdw.Fdwhandler, &pfdw.Fdwvalidator, &pfdw.Fdwacl, &pfdw.Fdwoptions)
if err != nil {
return nil, err
}
return &pfdw, nil
}
|
[
"func",
"PgForeignDataWrapperByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignDataWrapper",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, fdwname, fdwowner, fdwhandler, fdwvalidator, fdwacl, fdwoptions `",
"+",
"`FROM pg_catalog.pg_foreign_data_wrapper `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pfdw",
":=",
"PgForeignDataWrapper",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pfdw",
".",
"Tableoid",
",",
"&",
"pfdw",
".",
"Cmax",
",",
"&",
"pfdw",
".",
"Xmax",
",",
"&",
"pfdw",
".",
"Cmin",
",",
"&",
"pfdw",
".",
"Xmin",
",",
"&",
"pfdw",
".",
"Oid",
",",
"&",
"pfdw",
".",
"Ctid",
",",
"&",
"pfdw",
".",
"Fdwname",
",",
"&",
"pfdw",
".",
"Fdwowner",
",",
"&",
"pfdw",
".",
"Fdwhandler",
",",
"&",
"pfdw",
".",
"Fdwvalidator",
",",
"&",
"pfdw",
".",
"Fdwacl",
",",
"&",
"pfdw",
".",
"Fdwoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pfdw",
",",
"nil",
"\n",
"}"
] |
// PgForeignDataWrapperByOid retrieves a row from 'pg_catalog.pg_foreign_data_wrapper' as a PgForeignDataWrapper.
//
// Generated from index 'pg_foreign_data_wrapper_oid_index'.
|
[
"PgForeignDataWrapperByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_data_wrapper",
"as",
"a",
"PgForeignDataWrapper",
".",
"Generated",
"from",
"index",
"pg_foreign_data_wrapper_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42926-L42945
|
22,762
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignServerBySrvname
|
func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
}
|
go
|
func PgForeignServerBySrvname(db XODB, srvname pgtypes.Name) (*PgForeignServer, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions ` +
`FROM pg_catalog.pg_foreign_server ` +
`WHERE srvname = $1`
// run query
XOLog(sqlstr, srvname)
pfs := PgForeignServer{}
err = db.QueryRow(sqlstr, srvname).Scan(&pfs.Tableoid, &pfs.Cmax, &pfs.Xmax, &pfs.Cmin, &pfs.Xmin, &pfs.Oid, &pfs.Ctid, &pfs.Srvname, &pfs.Srvowner, &pfs.Srvfdw, &pfs.Srvtype, &pfs.Srvversion, &pfs.Srvacl, &pfs.Srvoptions)
if err != nil {
return nil, err
}
return &pfs, nil
}
|
[
"func",
"PgForeignServerBySrvname",
"(",
"db",
"XODB",
",",
"srvname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgForeignServer",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, srvname, srvowner, srvfdw, srvtype, srvversion, srvacl, srvoptions `",
"+",
"`FROM pg_catalog.pg_foreign_server `",
"+",
"`WHERE srvname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"srvname",
")",
"\n",
"pfs",
":=",
"PgForeignServer",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"srvname",
")",
".",
"Scan",
"(",
"&",
"pfs",
".",
"Tableoid",
",",
"&",
"pfs",
".",
"Cmax",
",",
"&",
"pfs",
".",
"Xmax",
",",
"&",
"pfs",
".",
"Cmin",
",",
"&",
"pfs",
".",
"Xmin",
",",
"&",
"pfs",
".",
"Oid",
",",
"&",
"pfs",
".",
"Ctid",
",",
"&",
"pfs",
".",
"Srvname",
",",
"&",
"pfs",
".",
"Srvowner",
",",
"&",
"pfs",
".",
"Srvfdw",
",",
"&",
"pfs",
".",
"Srvtype",
",",
"&",
"pfs",
".",
"Srvversion",
",",
"&",
"pfs",
".",
"Srvacl",
",",
"&",
"pfs",
".",
"Srvoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pfs",
",",
"nil",
"\n",
"}"
] |
// PgForeignServerBySrvname retrieves a row from 'pg_catalog.pg_foreign_server' as a PgForeignServer.
//
// Generated from index 'pg_foreign_server_name_index'.
|
[
"PgForeignServerBySrvname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_server",
"as",
"a",
"PgForeignServer",
".",
"Generated",
"from",
"index",
"pg_foreign_server_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42950-L42969
|
22,763
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgForeignTableByFtrelid
|
func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
}
|
go
|
func PgForeignTableByFtrelid(db XODB, ftrelid pgtypes.Oid) (*PgForeignTable, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions ` +
`FROM pg_catalog.pg_foreign_table ` +
`WHERE ftrelid = $1`
// run query
XOLog(sqlstr, ftrelid)
pft := PgForeignTable{}
err = db.QueryRow(sqlstr, ftrelid).Scan(&pft.Tableoid, &pft.Cmax, &pft.Xmax, &pft.Cmin, &pft.Xmin, &pft.Ctid, &pft.Ftrelid, &pft.Ftserver, &pft.Ftoptions)
if err != nil {
return nil, err
}
return &pft, nil
}
|
[
"func",
"PgForeignTableByFtrelid",
"(",
"db",
"XODB",
",",
"ftrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgForeignTable",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, ftrelid, ftserver, ftoptions `",
"+",
"`FROM pg_catalog.pg_foreign_table `",
"+",
"`WHERE ftrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"ftrelid",
")",
"\n",
"pft",
":=",
"PgForeignTable",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"ftrelid",
")",
".",
"Scan",
"(",
"&",
"pft",
".",
"Tableoid",
",",
"&",
"pft",
".",
"Cmax",
",",
"&",
"pft",
".",
"Xmax",
",",
"&",
"pft",
".",
"Cmin",
",",
"&",
"pft",
".",
"Xmin",
",",
"&",
"pft",
".",
"Ctid",
",",
"&",
"pft",
".",
"Ftrelid",
",",
"&",
"pft",
".",
"Ftserver",
",",
"&",
"pft",
".",
"Ftoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pft",
",",
"nil",
"\n",
"}"
] |
// PgForeignTableByFtrelid retrieves a row from 'pg_catalog.pg_foreign_table' as a PgForeignTable.
//
// Generated from index 'pg_foreign_table_relid_index'.
|
[
"PgForeignTableByFtrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_foreign_table",
"as",
"a",
"PgForeignTable",
".",
"Generated",
"from",
"index",
"pg_foreign_table_relid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L42998-L43017
|
22,764
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgIndexByIndexrelid
|
func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
}
|
go
|
func PgIndexByIndexrelid(db XODB, indexrelid pgtypes.Oid) (*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indexrelid = $1`
// run query
XOLog(sqlstr, indexrelid)
pi := PgIndex{}
err = db.QueryRow(sqlstr, indexrelid).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
return &pi, nil
}
|
[
"func",
"PgIndexByIndexrelid",
"(",
"db",
"XODB",
",",
"indexrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indexrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"indexrelid",
")",
"\n",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"indexrelid",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] |
// PgIndexByIndexrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indexrelid_index'.
|
[
"PgIndexByIndexrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indexrelid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43022-L43041
|
22,765
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgIndicesByIndrelid
|
func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
go
|
func PgIndicesByIndrelid(db XODB, indrelid pgtypes.Oid) ([]*PgIndex, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred ` +
`FROM pg_catalog.pg_index ` +
`WHERE indrelid = $1`
// run query
XOLog(sqlstr, indrelid)
q, err := db.Query(sqlstr, indrelid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgIndex{}
for q.Next() {
pi := PgIndex{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Indexrelid, &pi.Indrelid, &pi.Indnatts, &pi.Indisunique, &pi.Indisprimary, &pi.Indisexclusion, &pi.Indimmediate, &pi.Indisclustered, &pi.Indisvalid, &pi.Indcheckxmin, &pi.Indisready, &pi.Indislive, &pi.Indisreplident, &pi.Indkey, &pi.Indcollation, &pi.Indclass, &pi.Indoption, &pi.Indexprs, &pi.Indpred)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
[
"func",
"PgIndicesByIndrelid",
"(",
"db",
"XODB",
",",
"indrelid",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgIndex",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, indexrelid, indrelid, indnatts, indisunique, indisprimary, indisexclusion, indimmediate, indisclustered, indisvalid, indcheckxmin, indisready, indislive, indisreplident, indkey, indcollation, indclass, indoption, indexprs, indpred `",
"+",
"`FROM pg_catalog.pg_index `",
"+",
"`WHERE indrelid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"indrelid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgIndex",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgIndex",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Indexrelid",
",",
"&",
"pi",
".",
"Indrelid",
",",
"&",
"pi",
".",
"Indnatts",
",",
"&",
"pi",
".",
"Indisunique",
",",
"&",
"pi",
".",
"Indisprimary",
",",
"&",
"pi",
".",
"Indisexclusion",
",",
"&",
"pi",
".",
"Indimmediate",
",",
"&",
"pi",
".",
"Indisclustered",
",",
"&",
"pi",
".",
"Indisvalid",
",",
"&",
"pi",
".",
"Indcheckxmin",
",",
"&",
"pi",
".",
"Indisready",
",",
"&",
"pi",
".",
"Indislive",
",",
"&",
"pi",
".",
"Indisreplident",
",",
"&",
"pi",
".",
"Indkey",
",",
"&",
"pi",
".",
"Indcollation",
",",
"&",
"pi",
".",
"Indclass",
",",
"&",
"pi",
".",
"Indoption",
",",
"&",
"pi",
".",
"Indexprs",
",",
"&",
"pi",
".",
"Indpred",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgIndicesByIndrelid retrieves a row from 'pg_catalog.pg_index' as a PgIndex.
//
// Generated from index 'pg_index_indrelid_index'.
|
[
"PgIndicesByIndrelid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_index",
"as",
"a",
"PgIndex",
".",
"Generated",
"from",
"index",
"pg_index_indrelid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43046-L43078
|
22,766
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgInheritsByInhparent
|
func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
go
|
func PgInheritsByInhparent(db XODB, inhparent pgtypes.Oid) ([]*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhparent = $1`
// run query
XOLog(sqlstr, inhparent)
q, err := db.Query(sqlstr, inhparent)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgInherit{}
for q.Next() {
pi := PgInherit{}
// scan
err = q.Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
res = append(res, &pi)
}
return res, nil
}
|
[
"func",
"PgInheritsByInhparent",
"(",
"db",
"XODB",
",",
"inhparent",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhparent = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"inhparent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgInherit",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pi",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgInheritsByInhparent retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_parent_index'.
|
[
"PgInheritsByInhparent",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_parent_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43083-L43115
|
22,767
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgInheritByInhrelidInhseqno
|
func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
}
|
go
|
func PgInheritByInhrelidInhseqno(db XODB, inhrelid pgtypes.Oid, inhseqno int) (*PgInherit, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno ` +
`FROM pg_catalog.pg_inherits ` +
`WHERE inhrelid = $1 AND inhseqno = $2`
// run query
XOLog(sqlstr, inhrelid, inhseqno)
pi := PgInherit{}
err = db.QueryRow(sqlstr, inhrelid, inhseqno).Scan(&pi.Tableoid, &pi.Cmax, &pi.Xmax, &pi.Cmin, &pi.Xmin, &pi.Ctid, &pi.Inhrelid, &pi.Inhparent, &pi.Inhseqno)
if err != nil {
return nil, err
}
return &pi, nil
}
|
[
"func",
"PgInheritByInhrelidInhseqno",
"(",
"db",
"XODB",
",",
"inhrelid",
"pgtypes",
".",
"Oid",
",",
"inhseqno",
"int",
")",
"(",
"*",
"PgInherit",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, inhrelid, inhparent, inhseqno `",
"+",
"`FROM pg_catalog.pg_inherits `",
"+",
"`WHERE inhrelid = $1 AND inhseqno = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
"\n",
"pi",
":=",
"PgInherit",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"inhrelid",
",",
"inhseqno",
")",
".",
"Scan",
"(",
"&",
"pi",
".",
"Tableoid",
",",
"&",
"pi",
".",
"Cmax",
",",
"&",
"pi",
".",
"Xmax",
",",
"&",
"pi",
".",
"Cmin",
",",
"&",
"pi",
".",
"Xmin",
",",
"&",
"pi",
".",
"Ctid",
",",
"&",
"pi",
".",
"Inhrelid",
",",
"&",
"pi",
".",
"Inhparent",
",",
"&",
"pi",
".",
"Inhseqno",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pi",
",",
"nil",
"\n",
"}"
] |
// PgInheritByInhrelidInhseqno retrieves a row from 'pg_catalog.pg_inherits' as a PgInherit.
//
// Generated from index 'pg_inherits_relid_seqno_index'.
|
[
"PgInheritByInhrelidInhseqno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_inherits",
"as",
"a",
"PgInherit",
".",
"Generated",
"from",
"index",
"pg_inherits_relid_seqno_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43120-L43139
|
22,768
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLanguageByLanname
|
func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
}
|
go
|
func PgLanguageByLanname(db XODB, lanname pgtypes.Name) (*PgLanguage, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl ` +
`FROM pg_catalog.pg_language ` +
`WHERE lanname = $1`
// run query
XOLog(sqlstr, lanname)
pl := PgLanguage{}
err = db.QueryRow(sqlstr, lanname).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Oid, &pl.Ctid, &pl.Lanname, &pl.Lanowner, &pl.Lanispl, &pl.Lanpltrusted, &pl.Lanplcallfoid, &pl.Laninline, &pl.Lanvalidator, &pl.Lanacl)
if err != nil {
return nil, err
}
return &pl, nil
}
|
[
"func",
"PgLanguageByLanname",
"(",
"db",
"XODB",
",",
"lanname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgLanguage",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lanname, lanowner, lanispl, lanpltrusted, lanplcallfoid, laninline, lanvalidator, lanacl `",
"+",
"`FROM pg_catalog.pg_language `",
"+",
"`WHERE lanname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"lanname",
")",
"\n",
"pl",
":=",
"PgLanguage",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"lanname",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Oid",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Lanname",
",",
"&",
"pl",
".",
"Lanowner",
",",
"&",
"pl",
".",
"Lanispl",
",",
"&",
"pl",
".",
"Lanpltrusted",
",",
"&",
"pl",
".",
"Lanplcallfoid",
",",
"&",
"pl",
".",
"Laninline",
",",
"&",
"pl",
".",
"Lanvalidator",
",",
"&",
"pl",
".",
"Lanacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] |
// PgLanguageByLanname retrieves a row from 'pg_catalog.pg_language' as a PgLanguage.
//
// Generated from index 'pg_language_name_index'.
|
[
"PgLanguageByLanname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_language",
"as",
"a",
"PgLanguage",
".",
"Generated",
"from",
"index",
"pg_language_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43144-L43163
|
22,769
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLargeobjectByLoidPageno
|
func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
}
|
go
|
func PgLargeobjectByLoidPageno(db XODB, loid pgtypes.Oid, pageno int) (*PgLargeobject, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data ` +
`FROM pg_catalog.pg_largeobject ` +
`WHERE loid = $1 AND pageno = $2`
// run query
XOLog(sqlstr, loid, pageno)
pl := PgLargeobject{}
err = db.QueryRow(sqlstr, loid, pageno).Scan(&pl.Tableoid, &pl.Cmax, &pl.Xmax, &pl.Cmin, &pl.Xmin, &pl.Ctid, &pl.Loid, &pl.Pageno, &pl.Data)
if err != nil {
return nil, err
}
return &pl, nil
}
|
[
"func",
"PgLargeobjectByLoidPageno",
"(",
"db",
"XODB",
",",
"loid",
"pgtypes",
".",
"Oid",
",",
"pageno",
"int",
")",
"(",
"*",
"PgLargeobject",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, loid, pageno, data `",
"+",
"`FROM pg_catalog.pg_largeobject `",
"+",
"`WHERE loid = $1 AND pageno = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
"\n",
"pl",
":=",
"PgLargeobject",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"loid",
",",
"pageno",
")",
".",
"Scan",
"(",
"&",
"pl",
".",
"Tableoid",
",",
"&",
"pl",
".",
"Cmax",
",",
"&",
"pl",
".",
"Xmax",
",",
"&",
"pl",
".",
"Cmin",
",",
"&",
"pl",
".",
"Xmin",
",",
"&",
"pl",
".",
"Ctid",
",",
"&",
"pl",
".",
"Loid",
",",
"&",
"pl",
".",
"Pageno",
",",
"&",
"pl",
".",
"Data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pl",
",",
"nil",
"\n",
"}"
] |
// PgLargeobjectByLoidPageno retrieves a row from 'pg_catalog.pg_largeobject' as a PgLargeobject.
//
// Generated from index 'pg_largeobject_loid_pn_index'.
|
[
"PgLargeobjectByLoidPageno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject",
"as",
"a",
"PgLargeobject",
".",
"Generated",
"from",
"index",
"pg_largeobject_loid_pn_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43192-L43211
|
22,770
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgLargeobjectMetadatumByOid
|
func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
}
|
go
|
func PgLargeobjectMetadatumByOid(db XODB, oid pgtypes.Oid) (*PgLargeobjectMetadatum, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl ` +
`FROM pg_catalog.pg_largeobject_metadata ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
plm := PgLargeobjectMetadatum{}
err = db.QueryRow(sqlstr, oid).Scan(&plm.Tableoid, &plm.Cmax, &plm.Xmax, &plm.Cmin, &plm.Xmin, &plm.Oid, &plm.Ctid, &plm.Lomowner, &plm.Lomacl)
if err != nil {
return nil, err
}
return &plm, nil
}
|
[
"func",
"PgLargeobjectMetadatumByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgLargeobjectMetadatum",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, lomowner, lomacl `",
"+",
"`FROM pg_catalog.pg_largeobject_metadata `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"plm",
":=",
"PgLargeobjectMetadatum",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"plm",
".",
"Tableoid",
",",
"&",
"plm",
".",
"Cmax",
",",
"&",
"plm",
".",
"Xmax",
",",
"&",
"plm",
".",
"Cmin",
",",
"&",
"plm",
".",
"Xmin",
",",
"&",
"plm",
".",
"Oid",
",",
"&",
"plm",
".",
"Ctid",
",",
"&",
"plm",
".",
"Lomowner",
",",
"&",
"plm",
".",
"Lomacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"plm",
",",
"nil",
"\n",
"}"
] |
// PgLargeobjectMetadatumByOid retrieves a row from 'pg_catalog.pg_largeobject_metadata' as a PgLargeobjectMetadatum.
//
// Generated from index 'pg_largeobject_metadata_oid_index'.
|
[
"PgLargeobjectMetadatumByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_largeobject_metadata",
"as",
"a",
"PgLargeobjectMetadatum",
".",
"Generated",
"from",
"index",
"pg_largeobject_metadata_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43216-L43235
|
22,771
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgNamespaceByNspname
|
func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
}
|
go
|
func PgNamespaceByNspname(db XODB, nspname pgtypes.Name) (*PgNamespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl ` +
`FROM pg_catalog.pg_namespace ` +
`WHERE nspname = $1`
// run query
XOLog(sqlstr, nspname)
pn := PgNamespace{}
err = db.QueryRow(sqlstr, nspname).Scan(&pn.Tableoid, &pn.Cmax, &pn.Xmax, &pn.Cmin, &pn.Xmin, &pn.Oid, &pn.Ctid, &pn.Nspname, &pn.Nspowner, &pn.Nspacl)
if err != nil {
return nil, err
}
return &pn, nil
}
|
[
"func",
"PgNamespaceByNspname",
"(",
"db",
"XODB",
",",
"nspname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgNamespace",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, nspname, nspowner, nspacl `",
"+",
"`FROM pg_catalog.pg_namespace `",
"+",
"`WHERE nspname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"nspname",
")",
"\n",
"pn",
":=",
"PgNamespace",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"nspname",
")",
".",
"Scan",
"(",
"&",
"pn",
".",
"Tableoid",
",",
"&",
"pn",
".",
"Cmax",
",",
"&",
"pn",
".",
"Xmax",
",",
"&",
"pn",
".",
"Cmin",
",",
"&",
"pn",
".",
"Xmin",
",",
"&",
"pn",
".",
"Oid",
",",
"&",
"pn",
".",
"Ctid",
",",
"&",
"pn",
".",
"Nspname",
",",
"&",
"pn",
".",
"Nspowner",
",",
"&",
"pn",
".",
"Nspacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pn",
",",
"nil",
"\n",
"}"
] |
// PgNamespaceByNspname retrieves a row from 'pg_catalog.pg_namespace' as a PgNamespace.
//
// Generated from index 'pg_namespace_nspname_index'.
|
[
"PgNamespaceByNspname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_namespace",
"as",
"a",
"PgNamespace",
".",
"Generated",
"from",
"index",
"pg_namespace_nspname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43240-L43259
|
22,772
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpclassByOpcmethodOpcnameOpcnamespace
|
func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpclassByOpcmethodOpcnameOpcnamespace(db XODB, opcmethod pgtypes.Oid, opcname pgtypes.Name, opcnamespace pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`
// run query
XOLog(sqlstr, opcmethod, opcname, opcnamespace)
po := PgOpclass{}
err = db.QueryRow(sqlstr, opcmethod, opcname, opcnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"(",
"db",
"XODB",
",",
"opcmethod",
"pgtypes",
".",
"Oid",
",",
"opcname",
"pgtypes",
".",
"Name",
",",
"opcnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE opcmethod = $1 AND opcname = $2 AND opcnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opcmethod",
",",
"opcname",
",",
"opcnamespace",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpclassByOpcmethodOpcnameOpcnamespace retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_am_name_nsp_index'.
|
[
"PgOpclassByOpcmethodOpcnameOpcnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_am_name_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43288-L43307
|
22,773
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpclassByOid
|
func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpclassByOid(db XODB, oid pgtypes.Oid) (*PgOpclass, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype ` +
`FROM pg_catalog.pg_opclass ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpclass{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opcmethod, &po.Opcname, &po.Opcnamespace, &po.Opcowner, &po.Opcfamily, &po.Opcintype, &po.Opcdefault, &po.Opckeytype)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpclassByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpclass",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opcmethod, opcname, opcnamespace, opcowner, opcfamily, opcintype, opcdefault, opckeytype `",
"+",
"`FROM pg_catalog.pg_opclass `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpclass",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opcmethod",
",",
"&",
"po",
".",
"Opcname",
",",
"&",
"po",
".",
"Opcnamespace",
",",
"&",
"po",
".",
"Opcowner",
",",
"&",
"po",
".",
"Opcfamily",
",",
"&",
"po",
".",
"Opcintype",
",",
"&",
"po",
".",
"Opcdefault",
",",
"&",
"po",
".",
"Opckeytype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpclassByOid retrieves a row from 'pg_catalog.pg_opclass' as a PgOpclass.
//
// Generated from index 'pg_opclass_oid_index'.
|
[
"PgOpclassByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opclass",
"as",
"a",
"PgOpclass",
".",
"Generated",
"from",
"index",
"pg_opclass_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43312-L43331
|
22,774
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOperatorByOid
|
func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOperatorByOid(db XODB, oid pgtypes.Oid) (*PgOperator, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin ` +
`FROM pg_catalog.pg_operator ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOperator{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Oprname, &po.Oprnamespace, &po.Oprowner, &po.Oprkind, &po.Oprcanmerge, &po.Oprcanhash, &po.Oprleft, &po.Oprright, &po.Oprresult, &po.Oprcom, &po.Oprnegate, &po.Oprcode, &po.Oprrest, &po.Oprjoin)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOperatorByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOperator",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, oprname, oprnamespace, oprowner, oprkind, oprcanmerge, oprcanhash, oprleft, oprright, oprresult, oprcom, oprnegate, oprcode, oprrest, oprjoin `",
"+",
"`FROM pg_catalog.pg_operator `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOperator",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Oprname",
",",
"&",
"po",
".",
"Oprnamespace",
",",
"&",
"po",
".",
"Oprowner",
",",
"&",
"po",
".",
"Oprkind",
",",
"&",
"po",
".",
"Oprcanmerge",
",",
"&",
"po",
".",
"Oprcanhash",
",",
"&",
"po",
".",
"Oprleft",
",",
"&",
"po",
".",
"Oprright",
",",
"&",
"po",
".",
"Oprresult",
",",
"&",
"po",
".",
"Oprcom",
",",
"&",
"po",
".",
"Oprnegate",
",",
"&",
"po",
".",
"Oprcode",
",",
"&",
"po",
".",
"Oprrest",
",",
"&",
"po",
".",
"Oprjoin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOperatorByOid retrieves a row from 'pg_catalog.pg_operator' as a PgOperator.
//
// Generated from index 'pg_operator_oid_index'.
|
[
"PgOperatorByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_operator",
"as",
"a",
"PgOperator",
".",
"Generated",
"from",
"index",
"pg_operator_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43336-L43355
|
22,775
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpfamilyByOpfmethodOpfnameOpfnamespace
|
func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpfamilyByOpfmethodOpfnameOpfnamespace(db XODB, opfmethod pgtypes.Oid, opfname pgtypes.Name, opfnamespace pgtypes.Oid) (*PgOpfamily, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner ` +
`FROM pg_catalog.pg_opfamily ` +
`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`
// run query
XOLog(sqlstr, opfmethod, opfname, opfnamespace)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, opfmethod, opfname, opfnamespace).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"(",
"db",
"XODB",
",",
"opfmethod",
"pgtypes",
".",
"Oid",
",",
"opfname",
"pgtypes",
".",
"Name",
",",
"opfnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpfamily",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner `",
"+",
"`FROM pg_catalog.pg_opfamily `",
"+",
"`WHERE opfmethod = $1 AND opfname = $2 AND opfnamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"opfmethod",
",",
"opfname",
",",
"opfnamespace",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opfmethod",
",",
"&",
"po",
".",
"Opfname",
",",
"&",
"po",
".",
"Opfnamespace",
",",
"&",
"po",
".",
"Opfowner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpfamilyByOpfmethodOpfnameOpfnamespace retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_am_name_nsp_index'.
|
[
"PgOpfamilyByOpfmethodOpfnameOpfnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opfamily",
"as",
"a",
"PgOpfamily",
".",
"Generated",
"from",
"index",
"pg_opfamily_am_name_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43384-L43403
|
22,776
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgOpfamilyByOid
|
func PgOpfamilyByOid(db XODB, oid 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 oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
go
|
func PgOpfamilyByOid(db XODB, oid 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 oid = $1`
// run query
XOLog(sqlstr, oid)
po := PgOpfamily{}
err = db.QueryRow(sqlstr, oid).Scan(&po.Tableoid, &po.Cmax, &po.Xmax, &po.Cmin, &po.Xmin, &po.Oid, &po.Ctid, &po.Opfmethod, &po.Opfname, &po.Opfnamespace, &po.Opfowner)
if err != nil {
return nil, err
}
return &po, nil
}
|
[
"func",
"PgOpfamilyByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgOpfamily",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, opfmethod, opfname, opfnamespace, opfowner `",
"+",
"`FROM pg_catalog.pg_opfamily `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"po",
":=",
"PgOpfamily",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"po",
".",
"Tableoid",
",",
"&",
"po",
".",
"Cmax",
",",
"&",
"po",
".",
"Xmax",
",",
"&",
"po",
".",
"Cmin",
",",
"&",
"po",
".",
"Xmin",
",",
"&",
"po",
".",
"Oid",
",",
"&",
"po",
".",
"Ctid",
",",
"&",
"po",
".",
"Opfmethod",
",",
"&",
"po",
".",
"Opfname",
",",
"&",
"po",
".",
"Opfnamespace",
",",
"&",
"po",
".",
"Opfowner",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"po",
",",
"nil",
"\n",
"}"
] |
// PgOpfamilyByOid retrieves a row from 'pg_catalog.pg_opfamily' as a PgOpfamily.
//
// Generated from index 'pg_opfamily_oid_index'.
|
[
"PgOpfamilyByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_opfamily",
"as",
"a",
"PgOpfamily",
".",
"Generated",
"from",
"index",
"pg_opfamily_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43408-L43427
|
22,777
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgPltemplateByTmplname
|
func PgPltemplateByTmplname(db XODB, tmplname pgtypes.Name) (*PgPltemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl ` +
`FROM pg_catalog.pg_pltemplate ` +
`WHERE tmplname = $1`
// run query
XOLog(sqlstr, tmplname)
pp := PgPltemplate{}
err = db.QueryRow(sqlstr, tmplname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Tmplname, &pp.Tmpltrusted, &pp.Tmpldbacreate, &pp.Tmplhandler, &pp.Tmplinline, &pp.Tmplvalidator, &pp.Tmpllibrary, &pp.Tmplacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgPltemplateByTmplname(db XODB, tmplname pgtypes.Name) (*PgPltemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl ` +
`FROM pg_catalog.pg_pltemplate ` +
`WHERE tmplname = $1`
// run query
XOLog(sqlstr, tmplname)
pp := PgPltemplate{}
err = db.QueryRow(sqlstr, tmplname).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Ctid, &pp.Tmplname, &pp.Tmpltrusted, &pp.Tmpldbacreate, &pp.Tmplhandler, &pp.Tmplinline, &pp.Tmplvalidator, &pp.Tmpllibrary, &pp.Tmplacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgPltemplateByTmplname",
"(",
"db",
"XODB",
",",
"tmplname",
"pgtypes",
".",
"Name",
")",
"(",
"*",
"PgPltemplate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, tmplname, tmpltrusted, tmpldbacreate, tmplhandler, tmplinline, tmplvalidator, tmpllibrary, tmplacl `",
"+",
"`FROM pg_catalog.pg_pltemplate `",
"+",
"`WHERE tmplname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"tmplname",
")",
"\n",
"pp",
":=",
"PgPltemplate",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"tmplname",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Tmplname",
",",
"&",
"pp",
".",
"Tmpltrusted",
",",
"&",
"pp",
".",
"Tmpldbacreate",
",",
"&",
"pp",
".",
"Tmplhandler",
",",
"&",
"pp",
".",
"Tmplinline",
",",
"&",
"pp",
".",
"Tmplvalidator",
",",
"&",
"pp",
".",
"Tmpllibrary",
",",
"&",
"pp",
".",
"Tmplacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgPltemplateByTmplname retrieves a row from 'pg_catalog.pg_pltemplate' as a PgPltemplate.
//
// Generated from index 'pg_pltemplate_name_index'.
|
[
"PgPltemplateByTmplname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_pltemplate",
"as",
"a",
"PgPltemplate",
".",
"Generated",
"from",
"index",
"pg_pltemplate_name_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43432-L43451
|
22,778
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgPolicyByOid
|
func PgPolicyByOid(db XODB, oid pgtypes.Oid) (*PgPolicy, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck ` +
`FROM pg_catalog.pg_policy ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pp := PgPolicy{}
err = db.QueryRow(sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgPolicyByOid(db XODB, oid pgtypes.Oid) (*PgPolicy, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck ` +
`FROM pg_catalog.pg_policy ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pp := PgPolicy{}
err = db.QueryRow(sqlstr, oid).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Polname, &pp.Polrelid, &pp.Polcmd, &pp.Polroles, &pp.Polqual, &pp.Polwithcheck)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgPolicyByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgPolicy",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, polname, polrelid, polcmd, polroles, polqual, polwithcheck `",
"+",
"`FROM pg_catalog.pg_policy `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pp",
":=",
"PgPolicy",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Oid",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Polname",
",",
"&",
"pp",
".",
"Polrelid",
",",
"&",
"pp",
".",
"Polcmd",
",",
"&",
"pp",
".",
"Polroles",
",",
"&",
"pp",
".",
"Polqual",
",",
"&",
"pp",
".",
"Polwithcheck",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgPolicyByOid retrieves a row from 'pg_catalog.pg_policy' as a PgPolicy.
//
// Generated from index 'pg_policy_oid_index'.
|
[
"PgPolicyByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_policy",
"as",
"a",
"PgPolicy",
".",
"Generated",
"from",
"index",
"pg_policy_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43456-L43475
|
22,779
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgProcByPronameProargtypesPronamespace
|
func PgProcByPronameProargtypesPronamespace(db XODB, proname pgtypes.Name, proargtypes pgtypes.Oidvector, pronamespace pgtypes.Oid) (*PgProc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
`FROM pg_catalog.pg_proc ` +
`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`
// run query
XOLog(sqlstr, proname, proargtypes, pronamespace)
pp := PgProc{}
err = db.QueryRow(sqlstr, proname, proargtypes, pronamespace).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Protransform, &pp.Proisagg, &pp.Proiswindow, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
go
|
func PgProcByPronameProargtypesPronamespace(db XODB, proname pgtypes.Name, proargtypes pgtypes.Oidvector, pronamespace pgtypes.Oid) (*PgProc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl ` +
`FROM pg_catalog.pg_proc ` +
`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`
// run query
XOLog(sqlstr, proname, proargtypes, pronamespace)
pp := PgProc{}
err = db.QueryRow(sqlstr, proname, proargtypes, pronamespace).Scan(&pp.Tableoid, &pp.Cmax, &pp.Xmax, &pp.Cmin, &pp.Xmin, &pp.Oid, &pp.Ctid, &pp.Proname, &pp.Pronamespace, &pp.Proowner, &pp.Prolang, &pp.Procost, &pp.Prorows, &pp.Provariadic, &pp.Protransform, &pp.Proisagg, &pp.Proiswindow, &pp.Prosecdef, &pp.Proleakproof, &pp.Proisstrict, &pp.Proretset, &pp.Provolatile, &pp.Pronargs, &pp.Pronargdefaults, &pp.Prorettype, &pp.Proargtypes, &pp.Proallargtypes, &pp.Proargmodes, &pp.Proargnames, &pp.Proargdefaults, &pp.Protrftypes, &pp.Prosrc, &pp.Probin, &pp.Proconfig, &pp.Proacl)
if err != nil {
return nil, err
}
return &pp, nil
}
|
[
"func",
"PgProcByPronameProargtypesPronamespace",
"(",
"db",
"XODB",
",",
"proname",
"pgtypes",
".",
"Name",
",",
"proargtypes",
"pgtypes",
".",
"Oidvector",
",",
"pronamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgProc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, proname, pronamespace, proowner, prolang, procost, prorows, provariadic, protransform, proisagg, proiswindow, prosecdef, proleakproof, proisstrict, proretset, provolatile, pronargs, pronargdefaults, prorettype, proargtypes, proallargtypes, proargmodes, proargnames, proargdefaults, protrftypes, prosrc, probin, proconfig, proacl `",
"+",
"`FROM pg_catalog.pg_proc `",
"+",
"`WHERE proname = $1 AND proargtypes = $2 AND pronamespace = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"proname",
",",
"proargtypes",
",",
"pronamespace",
")",
"\n",
"pp",
":=",
"PgProc",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"proname",
",",
"proargtypes",
",",
"pronamespace",
")",
".",
"Scan",
"(",
"&",
"pp",
".",
"Tableoid",
",",
"&",
"pp",
".",
"Cmax",
",",
"&",
"pp",
".",
"Xmax",
",",
"&",
"pp",
".",
"Cmin",
",",
"&",
"pp",
".",
"Xmin",
",",
"&",
"pp",
".",
"Oid",
",",
"&",
"pp",
".",
"Ctid",
",",
"&",
"pp",
".",
"Proname",
",",
"&",
"pp",
".",
"Pronamespace",
",",
"&",
"pp",
".",
"Proowner",
",",
"&",
"pp",
".",
"Prolang",
",",
"&",
"pp",
".",
"Procost",
",",
"&",
"pp",
".",
"Prorows",
",",
"&",
"pp",
".",
"Provariadic",
",",
"&",
"pp",
".",
"Protransform",
",",
"&",
"pp",
".",
"Proisagg",
",",
"&",
"pp",
".",
"Proiswindow",
",",
"&",
"pp",
".",
"Prosecdef",
",",
"&",
"pp",
".",
"Proleakproof",
",",
"&",
"pp",
".",
"Proisstrict",
",",
"&",
"pp",
".",
"Proretset",
",",
"&",
"pp",
".",
"Provolatile",
",",
"&",
"pp",
".",
"Pronargs",
",",
"&",
"pp",
".",
"Pronargdefaults",
",",
"&",
"pp",
".",
"Prorettype",
",",
"&",
"pp",
".",
"Proargtypes",
",",
"&",
"pp",
".",
"Proallargtypes",
",",
"&",
"pp",
".",
"Proargmodes",
",",
"&",
"pp",
".",
"Proargnames",
",",
"&",
"pp",
".",
"Proargdefaults",
",",
"&",
"pp",
".",
"Protrftypes",
",",
"&",
"pp",
".",
"Prosrc",
",",
"&",
"pp",
".",
"Probin",
",",
"&",
"pp",
".",
"Proconfig",
",",
"&",
"pp",
".",
"Proacl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pp",
",",
"nil",
"\n",
"}"
] |
// PgProcByPronameProargtypesPronamespace retrieves a row from 'pg_catalog.pg_proc' as a PgProc.
//
// Generated from index 'pg_proc_proname_args_nsp_index'.
|
[
"PgProcByPronameProargtypesPronamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_proc",
"as",
"a",
"PgProc",
".",
"Generated",
"from",
"index",
"pg_proc_proname_args_nsp_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43528-L43547
|
22,780
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgRangeByRngtypid
|
func PgRangeByRngtypid(db XODB, rngtypid pgtypes.Oid) (*PgRange, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff ` +
`FROM pg_catalog.pg_range ` +
`WHERE rngtypid = $1`
// run query
XOLog(sqlstr, rngtypid)
pr := PgRange{}
err = db.QueryRow(sqlstr, rngtypid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Rngtypid, &pr.Rngsubtype, &pr.Rngcollation, &pr.Rngsubopc, &pr.Rngcanonical, &pr.Rngsubdiff)
if err != nil {
return nil, err
}
return &pr, nil
}
|
go
|
func PgRangeByRngtypid(db XODB, rngtypid pgtypes.Oid) (*PgRange, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff ` +
`FROM pg_catalog.pg_range ` +
`WHERE rngtypid = $1`
// run query
XOLog(sqlstr, rngtypid)
pr := PgRange{}
err = db.QueryRow(sqlstr, rngtypid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Ctid, &pr.Rngtypid, &pr.Rngsubtype, &pr.Rngcollation, &pr.Rngsubopc, &pr.Rngcanonical, &pr.Rngsubdiff)
if err != nil {
return nil, err
}
return &pr, nil
}
|
[
"func",
"PgRangeByRngtypid",
"(",
"db",
"XODB",
",",
"rngtypid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgRange",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, rngtypid, rngsubtype, rngcollation, rngsubopc, rngcanonical, rngsubdiff `",
"+",
"`FROM pg_catalog.pg_range `",
"+",
"`WHERE rngtypid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"rngtypid",
")",
"\n",
"pr",
":=",
"PgRange",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"rngtypid",
")",
".",
"Scan",
"(",
"&",
"pr",
".",
"Tableoid",
",",
"&",
"pr",
".",
"Cmax",
",",
"&",
"pr",
".",
"Xmax",
",",
"&",
"pr",
".",
"Cmin",
",",
"&",
"pr",
".",
"Xmin",
",",
"&",
"pr",
".",
"Ctid",
",",
"&",
"pr",
".",
"Rngtypid",
",",
"&",
"pr",
".",
"Rngsubtype",
",",
"&",
"pr",
".",
"Rngcollation",
",",
"&",
"pr",
".",
"Rngsubopc",
",",
"&",
"pr",
".",
"Rngcanonical",
",",
"&",
"pr",
".",
"Rngsubdiff",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pr",
",",
"nil",
"\n",
"}"
] |
// PgRangeByRngtypid retrieves a row from 'pg_catalog.pg_range' as a PgRange.
//
// Generated from index 'pg_range_rngtypid_index'.
|
[
"PgRangeByRngtypid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_range",
"as",
"a",
"PgRange",
".",
"Generated",
"from",
"index",
"pg_range_rngtypid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43552-L43571
|
22,781
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgReplicationOriginByRoident
|
func PgReplicationOriginByRoident(db XODB, roident pgtypes.Oid) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roident = $1`
// run query
XOLog(sqlstr, roident)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roident).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
go
|
func PgReplicationOriginByRoident(db XODB, roident pgtypes.Oid) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roident = $1`
// run query
XOLog(sqlstr, roident)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roident).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
[
"func",
"PgReplicationOriginByRoident",
"(",
"db",
"XODB",
",",
"roident",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgReplicationOrigin",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `",
"+",
"`FROM pg_catalog.pg_replication_origin `",
"+",
"`WHERE roident = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"roident",
")",
"\n",
"pro",
":=",
"PgReplicationOrigin",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"roident",
")",
".",
"Scan",
"(",
"&",
"pro",
".",
"Tableoid",
",",
"&",
"pro",
".",
"Cmax",
",",
"&",
"pro",
".",
"Xmax",
",",
"&",
"pro",
".",
"Cmin",
",",
"&",
"pro",
".",
"Xmin",
",",
"&",
"pro",
".",
"Ctid",
",",
"&",
"pro",
".",
"Roident",
",",
"&",
"pro",
".",
"Roname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pro",
",",
"nil",
"\n",
"}"
] |
// PgReplicationOriginByRoident retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roiident_index'.
|
[
"PgReplicationOriginByRoident",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_replication_origin",
"as",
"a",
"PgReplicationOrigin",
".",
"Generated",
"from",
"index",
"pg_replication_origin_roiident_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43576-L43595
|
22,782
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgReplicationOriginByRoname
|
func PgReplicationOriginByRoname(db XODB, roname string) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roname = $1`
// run query
XOLog(sqlstr, roname)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roname).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
go
|
func PgReplicationOriginByRoname(db XODB, roname string) (*PgReplicationOrigin, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname ` +
`FROM pg_catalog.pg_replication_origin ` +
`WHERE roname = $1`
// run query
XOLog(sqlstr, roname)
pro := PgReplicationOrigin{}
err = db.QueryRow(sqlstr, roname).Scan(&pro.Tableoid, &pro.Cmax, &pro.Xmax, &pro.Cmin, &pro.Xmin, &pro.Ctid, &pro.Roident, &pro.Roname)
if err != nil {
return nil, err
}
return &pro, nil
}
|
[
"func",
"PgReplicationOriginByRoname",
"(",
"db",
"XODB",
",",
"roname",
"string",
")",
"(",
"*",
"PgReplicationOrigin",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, roident, roname `",
"+",
"`FROM pg_catalog.pg_replication_origin `",
"+",
"`WHERE roname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"roname",
")",
"\n",
"pro",
":=",
"PgReplicationOrigin",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"roname",
")",
".",
"Scan",
"(",
"&",
"pro",
".",
"Tableoid",
",",
"&",
"pro",
".",
"Cmax",
",",
"&",
"pro",
".",
"Xmax",
",",
"&",
"pro",
".",
"Cmin",
",",
"&",
"pro",
".",
"Xmin",
",",
"&",
"pro",
".",
"Ctid",
",",
"&",
"pro",
".",
"Roident",
",",
"&",
"pro",
".",
"Roname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pro",
",",
"nil",
"\n",
"}"
] |
// PgReplicationOriginByRoname retrieves a row from 'pg_catalog.pg_replication_origin' as a PgReplicationOrigin.
//
// Generated from index 'pg_replication_origin_roname_index'.
|
[
"PgReplicationOriginByRoname",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_replication_origin",
"as",
"a",
"PgReplicationOrigin",
".",
"Generated",
"from",
"index",
"pg_replication_origin_roname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43600-L43619
|
22,783
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgRewriteByOid
|
func PgRewriteByOid(db XODB, oid pgtypes.Oid) (*PgRewrite, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
`FROM pg_catalog.pg_rewrite ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pr := PgRewrite{}
err = db.QueryRow(sqlstr, oid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Oid, &pr.Ctid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction)
if err != nil {
return nil, err
}
return &pr, nil
}
|
go
|
func PgRewriteByOid(db XODB, oid pgtypes.Oid) (*PgRewrite, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action ` +
`FROM pg_catalog.pg_rewrite ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pr := PgRewrite{}
err = db.QueryRow(sqlstr, oid).Scan(&pr.Tableoid, &pr.Cmax, &pr.Xmax, &pr.Cmin, &pr.Xmin, &pr.Oid, &pr.Ctid, &pr.Rulename, &pr.EvClass, &pr.EvType, &pr.EvEnabled, &pr.IsInstead, &pr.EvQual, &pr.EvAction)
if err != nil {
return nil, err
}
return &pr, nil
}
|
[
"func",
"PgRewriteByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgRewrite",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, rulename, ev_class, ev_type, ev_enabled, is_instead, ev_qual, ev_action `",
"+",
"`FROM pg_catalog.pg_rewrite `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pr",
":=",
"PgRewrite",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pr",
".",
"Tableoid",
",",
"&",
"pr",
".",
"Cmax",
",",
"&",
"pr",
".",
"Xmax",
",",
"&",
"pr",
".",
"Cmin",
",",
"&",
"pr",
".",
"Xmin",
",",
"&",
"pr",
".",
"Oid",
",",
"&",
"pr",
".",
"Ctid",
",",
"&",
"pr",
".",
"Rulename",
",",
"&",
"pr",
".",
"EvClass",
",",
"&",
"pr",
".",
"EvType",
",",
"&",
"pr",
".",
"EvEnabled",
",",
"&",
"pr",
".",
"IsInstead",
",",
"&",
"pr",
".",
"EvQual",
",",
"&",
"pr",
".",
"EvAction",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pr",
",",
"nil",
"\n",
"}"
] |
// PgRewriteByOid retrieves a row from 'pg_catalog.pg_rewrite' as a PgRewrite.
//
// Generated from index 'pg_rewrite_oid_index'.
|
[
"PgRewriteByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_rewrite",
"as",
"a",
"PgRewrite",
".",
"Generated",
"from",
"index",
"pg_rewrite_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43624-L43643
|
22,784
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgSeclabelByObjoidClassoidObjsubidProvider
|
func PgSeclabelByObjoidClassoidObjsubidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int, provider string) (*PgSeclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label ` +
`FROM pg_catalog.pg_seclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`
// run query
XOLog(sqlstr, objoid, classoid, objsubid, provider)
ps := PgSeclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Objsubid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgSeclabelByObjoidClassoidObjsubidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, objsubid int, provider string) (*PgSeclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label ` +
`FROM pg_catalog.pg_seclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`
// run query
XOLog(sqlstr, objoid, classoid, objsubid, provider)
ps := PgSeclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, objsubid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Objsubid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgSeclabelByObjoidClassoidObjsubidProvider",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
",",
"provider",
"string",
")",
"(",
"*",
"PgSeclabel",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, objsubid, provider, label `",
"+",
"`FROM pg_catalog.pg_seclabel `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND objsubid = $3 AND provider = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
",",
"provider",
")",
"\n",
"ps",
":=",
"PgSeclabel",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"objsubid",
",",
"provider",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Provider",
",",
"&",
"ps",
".",
"Label",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgSeclabelByObjoidClassoidObjsubidProvider retrieves a row from 'pg_catalog.pg_seclabel' as a PgSeclabel.
//
// Generated from index 'pg_seclabel_object_index'.
|
[
"PgSeclabelByObjoidClassoidObjsubidProvider",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_seclabel",
"as",
"a",
"PgSeclabel",
".",
"Generated",
"from",
"index",
"pg_seclabel_object_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43672-L43691
|
22,785
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdependsByDbidClassidObjidObjsubid
|
func PgShdependsByDbidClassidObjidObjsubid(db XODB, dbid pgtypes.Oid, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`
// run query
XOLog(sqlstr, dbid, classid, objid, objsubid)
q, err := db.Query(sqlstr, dbid, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
go
|
func PgShdependsByDbidClassidObjidObjsubid(db XODB, dbid pgtypes.Oid, classid pgtypes.Oid, objid pgtypes.Oid, objsubid int) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`
// run query
XOLog(sqlstr, dbid, classid, objid, objsubid)
q, err := db.Query(sqlstr, dbid, classid, objid, objsubid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
[
"func",
"PgShdependsByDbidClassidObjidObjsubid",
"(",
"db",
"XODB",
",",
"dbid",
"pgtypes",
".",
"Oid",
",",
"classid",
"pgtypes",
".",
"Oid",
",",
"objid",
"pgtypes",
".",
"Oid",
",",
"objsubid",
"int",
")",
"(",
"[",
"]",
"*",
"PgShdepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `",
"+",
"`FROM pg_catalog.pg_shdepend `",
"+",
"`WHERE dbid = $1 AND classid = $2 AND objid = $3 AND objsubid = $4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dbid",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"dbid",
",",
"classid",
",",
"objid",
",",
"objsubid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgShdepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ps",
":=",
"PgShdepend",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Dbid",
",",
"&",
"ps",
".",
"Classid",
",",
"&",
"ps",
".",
"Objid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Refclassid",
",",
"&",
"ps",
".",
"Refobjid",
",",
"&",
"ps",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ps",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgShdependsByDbidClassidObjidObjsubid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_depender_index'.
|
[
"PgShdependsByDbidClassidObjidObjsubid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdepend",
"as",
"a",
"PgShdepend",
".",
"Generated",
"from",
"index",
"pg_shdepend_depender_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43696-L43728
|
22,786
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdependsByRefclassidRefobjid
|
func PgShdependsByRefclassidRefobjid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE refclassid = $1 AND refobjid = $2`
// run query
XOLog(sqlstr, refclassid, refobjid)
q, err := db.Query(sqlstr, refclassid, refobjid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
go
|
func PgShdependsByRefclassidRefobjid(db XODB, refclassid pgtypes.Oid, refobjid pgtypes.Oid) ([]*PgShdepend, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype ` +
`FROM pg_catalog.pg_shdepend ` +
`WHERE refclassid = $1 AND refobjid = $2`
// run query
XOLog(sqlstr, refclassid, refobjid)
q, err := db.Query(sqlstr, refclassid, refobjid)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgShdepend{}
for q.Next() {
ps := PgShdepend{}
// scan
err = q.Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Dbid, &ps.Classid, &ps.Objid, &ps.Objsubid, &ps.Refclassid, &ps.Refobjid, &ps.Deptype)
if err != nil {
return nil, err
}
res = append(res, &ps)
}
return res, nil
}
|
[
"func",
"PgShdependsByRefclassidRefobjid",
"(",
"db",
"XODB",
",",
"refclassid",
"pgtypes",
".",
"Oid",
",",
"refobjid",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgShdepend",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, dbid, classid, objid, objsubid, refclassid, refobjid, deptype `",
"+",
"`FROM pg_catalog.pg_shdepend `",
"+",
"`WHERE refclassid = $1 AND refobjid = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"refclassid",
",",
"refobjid",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"refclassid",
",",
"refobjid",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgShdepend",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ps",
":=",
"PgShdepend",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Dbid",
",",
"&",
"ps",
".",
"Classid",
",",
"&",
"ps",
".",
"Objid",
",",
"&",
"ps",
".",
"Objsubid",
",",
"&",
"ps",
".",
"Refclassid",
",",
"&",
"ps",
".",
"Refobjid",
",",
"&",
"ps",
".",
"Deptype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ps",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgShdependsByRefclassidRefobjid retrieves a row from 'pg_catalog.pg_shdepend' as a PgShdepend.
//
// Generated from index 'pg_shdepend_reference_index'.
|
[
"PgShdependsByRefclassidRefobjid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdepend",
"as",
"a",
"PgShdepend",
".",
"Generated",
"from",
"index",
"pg_shdepend_reference_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43733-L43765
|
22,787
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShdescriptionByObjoidClassoid
|
func PgShdescriptionByObjoidClassoid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid) (*PgShdescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description ` +
`FROM pg_catalog.pg_shdescription ` +
`WHERE objoid = $1 AND classoid = $2`
// run query
XOLog(sqlstr, objoid, classoid)
ps := PgShdescription{}
err = db.QueryRow(sqlstr, objoid, classoid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Description)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgShdescriptionByObjoidClassoid(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid) (*PgShdescription, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description ` +
`FROM pg_catalog.pg_shdescription ` +
`WHERE objoid = $1 AND classoid = $2`
// run query
XOLog(sqlstr, objoid, classoid)
ps := PgShdescription{}
err = db.QueryRow(sqlstr, objoid, classoid).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Description)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgShdescriptionByObjoidClassoid",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgShdescription",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, description `",
"+",
"`FROM pg_catalog.pg_shdescription `",
"+",
"`WHERE objoid = $1 AND classoid = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
")",
"\n",
"ps",
":=",
"PgShdescription",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Description",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgShdescriptionByObjoidClassoid retrieves a row from 'pg_catalog.pg_shdescription' as a PgShdescription.
//
// Generated from index 'pg_shdescription_o_c_index'.
|
[
"PgShdescriptionByObjoidClassoid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shdescription",
"as",
"a",
"PgShdescription",
".",
"Generated",
"from",
"index",
"pg_shdescription_o_c_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43770-L43789
|
22,788
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgShseclabelByObjoidClassoidProvider
|
func PgShseclabelByObjoidClassoidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label ` +
`FROM pg_catalog.pg_shseclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND provider = $3`
// run query
XOLog(sqlstr, objoid, classoid, provider)
ps := PgShseclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgShseclabelByObjoidClassoidProvider(db XODB, objoid pgtypes.Oid, classoid pgtypes.Oid, provider string) (*PgShseclabel, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label ` +
`FROM pg_catalog.pg_shseclabel ` +
`WHERE objoid = $1 AND classoid = $2 AND provider = $3`
// run query
XOLog(sqlstr, objoid, classoid, provider)
ps := PgShseclabel{}
err = db.QueryRow(sqlstr, objoid, classoid, provider).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Objoid, &ps.Classoid, &ps.Provider, &ps.Label)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgShseclabelByObjoidClassoidProvider",
"(",
"db",
"XODB",
",",
"objoid",
"pgtypes",
".",
"Oid",
",",
"classoid",
"pgtypes",
".",
"Oid",
",",
"provider",
"string",
")",
"(",
"*",
"PgShseclabel",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, objoid, classoid, provider, label `",
"+",
"`FROM pg_catalog.pg_shseclabel `",
"+",
"`WHERE objoid = $1 AND classoid = $2 AND provider = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"provider",
")",
"\n",
"ps",
":=",
"PgShseclabel",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"objoid",
",",
"classoid",
",",
"provider",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Objoid",
",",
"&",
"ps",
".",
"Classoid",
",",
"&",
"ps",
".",
"Provider",
",",
"&",
"ps",
".",
"Label",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgShseclabelByObjoidClassoidProvider retrieves a row from 'pg_catalog.pg_shseclabel' as a PgShseclabel.
//
// Generated from index 'pg_shseclabel_object_index'.
|
[
"PgShseclabelByObjoidClassoidProvider",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_shseclabel",
"as",
"a",
"PgShseclabel",
".",
"Generated",
"from",
"index",
"pg_shseclabel_object_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43794-L43813
|
22,789
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgStatisticByStarelidStaattnumStainherit
|
func PgStatisticByStarelidStaattnumStainherit(db XODB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 ` +
`FROM pg_catalog.pg_statistic ` +
`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`
// run query
XOLog(sqlstr, starelid, staattnum, stainherit)
ps := PgStatistic{}
err = db.QueryRow(sqlstr, starelid, staattnum, stainherit).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Starelid, &ps.Staattnum, &ps.Stainherit, &ps.Stanullfrac, &ps.Stawidth, &ps.Stadistinct, &ps.Stakind1, &ps.Stakind2, &ps.Stakind3, &ps.Stakind4, &ps.Stakind5, &ps.Staop1, &ps.Staop2, &ps.Staop3, &ps.Staop4, &ps.Staop5, &ps.Stanumbers1, &ps.Stanumbers2, &ps.Stanumbers3, &ps.Stanumbers4, &ps.Stanumbers5, &ps.Stavalues1, &ps.Stavalues2, &ps.Stavalues3, &ps.Stavalues4, &ps.Stavalues5)
if err != nil {
return nil, err
}
return &ps, nil
}
|
go
|
func PgStatisticByStarelidStaattnumStainherit(db XODB, starelid pgtypes.Oid, staattnum int16, stainherit bool) (*PgStatistic, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 ` +
`FROM pg_catalog.pg_statistic ` +
`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`
// run query
XOLog(sqlstr, starelid, staattnum, stainherit)
ps := PgStatistic{}
err = db.QueryRow(sqlstr, starelid, staattnum, stainherit).Scan(&ps.Tableoid, &ps.Cmax, &ps.Xmax, &ps.Cmin, &ps.Xmin, &ps.Ctid, &ps.Starelid, &ps.Staattnum, &ps.Stainherit, &ps.Stanullfrac, &ps.Stawidth, &ps.Stadistinct, &ps.Stakind1, &ps.Stakind2, &ps.Stakind3, &ps.Stakind4, &ps.Stakind5, &ps.Staop1, &ps.Staop2, &ps.Staop3, &ps.Staop4, &ps.Staop5, &ps.Stanumbers1, &ps.Stanumbers2, &ps.Stanumbers3, &ps.Stanumbers4, &ps.Stanumbers5, &ps.Stavalues1, &ps.Stavalues2, &ps.Stavalues3, &ps.Stavalues4, &ps.Stavalues5)
if err != nil {
return nil, err
}
return &ps, nil
}
|
[
"func",
"PgStatisticByStarelidStaattnumStainherit",
"(",
"db",
"XODB",
",",
"starelid",
"pgtypes",
".",
"Oid",
",",
"staattnum",
"int16",
",",
"stainherit",
"bool",
")",
"(",
"*",
"PgStatistic",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, starelid, staattnum, stainherit, stanullfrac, stawidth, stadistinct, stakind1, stakind2, stakind3, stakind4, stakind5, staop1, staop2, staop3, staop4, staop5, stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5, stavalues1, stavalues2, stavalues3, stavalues4, stavalues5 `",
"+",
"`FROM pg_catalog.pg_statistic `",
"+",
"`WHERE starelid = $1 AND staattnum = $2 AND stainherit = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"starelid",
",",
"staattnum",
",",
"stainherit",
")",
"\n",
"ps",
":=",
"PgStatistic",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"starelid",
",",
"staattnum",
",",
"stainherit",
")",
".",
"Scan",
"(",
"&",
"ps",
".",
"Tableoid",
",",
"&",
"ps",
".",
"Cmax",
",",
"&",
"ps",
".",
"Xmax",
",",
"&",
"ps",
".",
"Cmin",
",",
"&",
"ps",
".",
"Xmin",
",",
"&",
"ps",
".",
"Ctid",
",",
"&",
"ps",
".",
"Starelid",
",",
"&",
"ps",
".",
"Staattnum",
",",
"&",
"ps",
".",
"Stainherit",
",",
"&",
"ps",
".",
"Stanullfrac",
",",
"&",
"ps",
".",
"Stawidth",
",",
"&",
"ps",
".",
"Stadistinct",
",",
"&",
"ps",
".",
"Stakind1",
",",
"&",
"ps",
".",
"Stakind2",
",",
"&",
"ps",
".",
"Stakind3",
",",
"&",
"ps",
".",
"Stakind4",
",",
"&",
"ps",
".",
"Stakind5",
",",
"&",
"ps",
".",
"Staop1",
",",
"&",
"ps",
".",
"Staop2",
",",
"&",
"ps",
".",
"Staop3",
",",
"&",
"ps",
".",
"Staop4",
",",
"&",
"ps",
".",
"Staop5",
",",
"&",
"ps",
".",
"Stanumbers1",
",",
"&",
"ps",
".",
"Stanumbers2",
",",
"&",
"ps",
".",
"Stanumbers3",
",",
"&",
"ps",
".",
"Stanumbers4",
",",
"&",
"ps",
".",
"Stanumbers5",
",",
"&",
"ps",
".",
"Stavalues1",
",",
"&",
"ps",
".",
"Stavalues2",
",",
"&",
"ps",
".",
"Stavalues3",
",",
"&",
"ps",
".",
"Stavalues4",
",",
"&",
"ps",
".",
"Stavalues5",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ps",
",",
"nil",
"\n",
"}"
] |
// PgStatisticByStarelidStaattnumStainherit retrieves a row from 'pg_catalog.pg_statistic' as a PgStatistic.
//
// Generated from index 'pg_statistic_relid_att_inh_index'.
|
[
"PgStatisticByStarelidStaattnumStainherit",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_statistic",
"as",
"a",
"PgStatistic",
".",
"Generated",
"from",
"index",
"pg_statistic_relid_att_inh_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43818-L43837
|
22,790
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTablespaceByOid
|
func PgTablespaceByOid(db XODB, oid pgtypes.Oid) (*PgTablespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions ` +
`FROM pg_catalog.pg_tablespace ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTablespace{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTablespaceByOid(db XODB, oid pgtypes.Oid) (*PgTablespace, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions ` +
`FROM pg_catalog.pg_tablespace ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTablespace{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Spcname, &pt.Spcowner, &pt.Spcacl, &pt.Spcoptions)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTablespaceByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTablespace",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, spcname, spcowner, spcacl, spcoptions `",
"+",
"`FROM pg_catalog.pg_tablespace `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTablespace",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Spcname",
",",
"&",
"pt",
".",
"Spcowner",
",",
"&",
"pt",
".",
"Spcacl",
",",
"&",
"pt",
".",
"Spcoptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTablespaceByOid retrieves a row from 'pg_catalog.pg_tablespace' as a PgTablespace.
//
// Generated from index 'pg_tablespace_oid_index'.
|
[
"PgTablespaceByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_tablespace",
"as",
"a",
"PgTablespace",
".",
"Generated",
"from",
"index",
"pg_tablespace_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43842-L43861
|
22,791
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTransformByOid
|
func PgTransformByOid(db XODB, oid pgtypes.Oid) (*PgTransform, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql ` +
`FROM pg_catalog.pg_transform ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTransform{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTransformByOid(db XODB, oid pgtypes.Oid) (*PgTransform, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql ` +
`FROM pg_catalog.pg_transform ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTransform{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Trftype, &pt.Trflang, &pt.Trffromsql, &pt.Trftosql)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTransformByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTransform",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, trftype, trflang, trffromsql, trftosql `",
"+",
"`FROM pg_catalog.pg_transform `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTransform",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Trftype",
",",
"&",
"pt",
".",
"Trflang",
",",
"&",
"pt",
".",
"Trffromsql",
",",
"&",
"pt",
".",
"Trftosql",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTransformByOid retrieves a row from 'pg_catalog.pg_transform' as a PgTransform.
//
// Generated from index 'pg_transform_oid_index'.
|
[
"PgTransformByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_transform",
"as",
"a",
"PgTransform",
".",
"Generated",
"from",
"index",
"pg_transform_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43890-L43909
|
22,792
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTriggerByOid
|
func PgTriggerByOid(db XODB, oid pgtypes.Oid) (*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTrigger{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
return &pt, nil
}
|
go
|
func PgTriggerByOid(db XODB, oid pgtypes.Oid) (*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
pt := PgTrigger{}
err = db.QueryRow(sqlstr, oid).Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
return &pt, nil
}
|
[
"func",
"PgTriggerByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `",
"+",
"`FROM pg_catalog.pg_trigger `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"pt",
":=",
"PgTrigger",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Tgrelid",
",",
"&",
"pt",
".",
"Tgname",
",",
"&",
"pt",
".",
"Tgfoid",
",",
"&",
"pt",
".",
"Tgtype",
",",
"&",
"pt",
".",
"Tgenabled",
",",
"&",
"pt",
".",
"Tgisinternal",
",",
"&",
"pt",
".",
"Tgconstrrelid",
",",
"&",
"pt",
".",
"Tgconstrindid",
",",
"&",
"pt",
".",
"Tgconstraint",
",",
"&",
"pt",
".",
"Tgdeferrable",
",",
"&",
"pt",
".",
"Tginitdeferred",
",",
"&",
"pt",
".",
"Tgnargs",
",",
"&",
"pt",
".",
"Tgattr",
",",
"&",
"pt",
".",
"Tgargs",
",",
"&",
"pt",
".",
"Tgqual",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"pt",
",",
"nil",
"\n",
"}"
] |
// PgTriggerByOid retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_oid_index'.
|
[
"PgTriggerByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_trigger",
"as",
"a",
"PgTrigger",
".",
"Generated",
"from",
"index",
"pg_trigger_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43938-L43957
|
22,793
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTriggersByTgconstraint
|
func PgTriggersByTgconstraint(db XODB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE tgconstraint = $1`
// run query
XOLog(sqlstr, tgconstraint)
q, err := db.Query(sqlstr, tgconstraint)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgTrigger{}
for q.Next() {
pt := PgTrigger{}
// scan
err = q.Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
res = append(res, &pt)
}
return res, nil
}
|
go
|
func PgTriggersByTgconstraint(db XODB, tgconstraint pgtypes.Oid) ([]*PgTrigger, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual ` +
`FROM pg_catalog.pg_trigger ` +
`WHERE tgconstraint = $1`
// run query
XOLog(sqlstr, tgconstraint)
q, err := db.Query(sqlstr, tgconstraint)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*PgTrigger{}
for q.Next() {
pt := PgTrigger{}
// scan
err = q.Scan(&pt.Tableoid, &pt.Cmax, &pt.Xmax, &pt.Cmin, &pt.Xmin, &pt.Oid, &pt.Ctid, &pt.Tgrelid, &pt.Tgname, &pt.Tgfoid, &pt.Tgtype, &pt.Tgenabled, &pt.Tgisinternal, &pt.Tgconstrrelid, &pt.Tgconstrindid, &pt.Tgconstraint, &pt.Tgdeferrable, &pt.Tginitdeferred, &pt.Tgnargs, &pt.Tgattr, &pt.Tgargs, &pt.Tgqual)
if err != nil {
return nil, err
}
res = append(res, &pt)
}
return res, nil
}
|
[
"func",
"PgTriggersByTgconstraint",
"(",
"db",
"XODB",
",",
"tgconstraint",
"pgtypes",
".",
"Oid",
")",
"(",
"[",
"]",
"*",
"PgTrigger",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tgrelid, tgname, tgfoid, tgtype, tgenabled, tgisinternal, tgconstrrelid, tgconstrindid, tgconstraint, tgdeferrable, tginitdeferred, tgnargs, tgattr, tgargs, tgqual `",
"+",
"`FROM pg_catalog.pg_trigger `",
"+",
"`WHERE tgconstraint = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"tgconstraint",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"tgconstraint",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"PgTrigger",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pt",
":=",
"PgTrigger",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pt",
".",
"Tableoid",
",",
"&",
"pt",
".",
"Cmax",
",",
"&",
"pt",
".",
"Xmax",
",",
"&",
"pt",
".",
"Cmin",
",",
"&",
"pt",
".",
"Xmin",
",",
"&",
"pt",
".",
"Oid",
",",
"&",
"pt",
".",
"Ctid",
",",
"&",
"pt",
".",
"Tgrelid",
",",
"&",
"pt",
".",
"Tgname",
",",
"&",
"pt",
".",
"Tgfoid",
",",
"&",
"pt",
".",
"Tgtype",
",",
"&",
"pt",
".",
"Tgenabled",
",",
"&",
"pt",
".",
"Tgisinternal",
",",
"&",
"pt",
".",
"Tgconstrrelid",
",",
"&",
"pt",
".",
"Tgconstrindid",
",",
"&",
"pt",
".",
"Tgconstraint",
",",
"&",
"pt",
".",
"Tgdeferrable",
",",
"&",
"pt",
".",
"Tginitdeferred",
",",
"&",
"pt",
".",
"Tgnargs",
",",
"&",
"pt",
".",
"Tgattr",
",",
"&",
"pt",
".",
"Tgargs",
",",
"&",
"pt",
".",
"Tgqual",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pt",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] |
// PgTriggersByTgconstraint retrieves a row from 'pg_catalog.pg_trigger' as a PgTrigger.
//
// Generated from index 'pg_trigger_tgconstraint_index'.
|
[
"PgTriggersByTgconstraint",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_trigger",
"as",
"a",
"PgTrigger",
".",
"Generated",
"from",
"index",
"pg_trigger_tgconstraint_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L43962-L43994
|
22,794
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigByCfgnameCfgnamespace
|
func PgTsConfigByCfgnameCfgnamespace(db XODB, cfgname pgtypes.Name, cfgnamespace pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE cfgname = $1 AND cfgnamespace = $2`
// run query
XOLog(sqlstr, cfgname, cfgnamespace)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, cfgname, cfgnamespace).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
go
|
func PgTsConfigByCfgnameCfgnamespace(db XODB, cfgname pgtypes.Name, cfgnamespace pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE cfgname = $1 AND cfgnamespace = $2`
// run query
XOLog(sqlstr, cfgname, cfgnamespace)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, cfgname, cfgnamespace).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
[
"func",
"PgTsConfigByCfgnameCfgnamespace",
"(",
"db",
"XODB",
",",
"cfgname",
"pgtypes",
".",
"Name",
",",
"cfgnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `",
"+",
"`FROM pg_catalog.pg_ts_config `",
"+",
"`WHERE cfgname = $1 AND cfgnamespace = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"cfgname",
",",
"cfgnamespace",
")",
"\n",
"ptc",
":=",
"PgTsConfig",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"cfgname",
",",
"cfgnamespace",
")",
".",
"Scan",
"(",
"&",
"ptc",
".",
"Tableoid",
",",
"&",
"ptc",
".",
"Cmax",
",",
"&",
"ptc",
".",
"Xmax",
",",
"&",
"ptc",
".",
"Cmin",
",",
"&",
"ptc",
".",
"Xmin",
",",
"&",
"ptc",
".",
"Oid",
",",
"&",
"ptc",
".",
"Ctid",
",",
"&",
"ptc",
".",
"Cfgname",
",",
"&",
"ptc",
".",
"Cfgnamespace",
",",
"&",
"ptc",
".",
"Cfgowner",
",",
"&",
"ptc",
".",
"Cfgparser",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptc",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigByCfgnameCfgnamespace retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_cfgname_index'.
|
[
"PgTsConfigByCfgnameCfgnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config",
"as",
"a",
"PgTsConfig",
".",
"Generated",
"from",
"index",
"pg_ts_config_cfgname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44023-L44042
|
22,795
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigByOid
|
func PgTsConfigByOid(db XODB, oid pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, oid).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
go
|
func PgTsConfigByOid(db XODB, oid pgtypes.Oid) (*PgTsConfig, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser ` +
`FROM pg_catalog.pg_ts_config ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptc := PgTsConfig{}
err = db.QueryRow(sqlstr, oid).Scan(&ptc.Tableoid, &ptc.Cmax, &ptc.Xmax, &ptc.Cmin, &ptc.Xmin, &ptc.Oid, &ptc.Ctid, &ptc.Cfgname, &ptc.Cfgnamespace, &ptc.Cfgowner, &ptc.Cfgparser)
if err != nil {
return nil, err
}
return &ptc, nil
}
|
[
"func",
"PgTsConfigByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsConfig",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, cfgname, cfgnamespace, cfgowner, cfgparser `",
"+",
"`FROM pg_catalog.pg_ts_config `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptc",
":=",
"PgTsConfig",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptc",
".",
"Tableoid",
",",
"&",
"ptc",
".",
"Cmax",
",",
"&",
"ptc",
".",
"Xmax",
",",
"&",
"ptc",
".",
"Cmin",
",",
"&",
"ptc",
".",
"Xmin",
",",
"&",
"ptc",
".",
"Oid",
",",
"&",
"ptc",
".",
"Ctid",
",",
"&",
"ptc",
".",
"Cfgname",
",",
"&",
"ptc",
".",
"Cfgnamespace",
",",
"&",
"ptc",
".",
"Cfgowner",
",",
"&",
"ptc",
".",
"Cfgparser",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptc",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigByOid retrieves a row from 'pg_catalog.pg_ts_config' as a PgTsConfig.
//
// Generated from index 'pg_ts_config_oid_index'.
|
[
"PgTsConfigByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config",
"as",
"a",
"PgTsConfig",
".",
"Generated",
"from",
"index",
"pg_ts_config_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44047-L44066
|
22,796
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsConfigMapByMapcfgMaptokentypeMapseqno
|
func PgTsConfigMapByMapcfgMaptokentypeMapseqno(db XODB, mapcfg pgtypes.Oid, maptokentype int, mapseqno int) (*PgTsConfigMap, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict ` +
`FROM pg_catalog.pg_ts_config_map ` +
`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`
// run query
XOLog(sqlstr, mapcfg, maptokentype, mapseqno)
ptcm := PgTsConfigMap{}
err = db.QueryRow(sqlstr, mapcfg, maptokentype, mapseqno).Scan(&ptcm.Tableoid, &ptcm.Cmax, &ptcm.Xmax, &ptcm.Cmin, &ptcm.Xmin, &ptcm.Ctid, &ptcm.Mapcfg, &ptcm.Maptokentype, &ptcm.Mapseqno, &ptcm.Mapdict)
if err != nil {
return nil, err
}
return &ptcm, nil
}
|
go
|
func PgTsConfigMapByMapcfgMaptokentypeMapseqno(db XODB, mapcfg pgtypes.Oid, maptokentype int, mapseqno int) (*PgTsConfigMap, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict ` +
`FROM pg_catalog.pg_ts_config_map ` +
`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`
// run query
XOLog(sqlstr, mapcfg, maptokentype, mapseqno)
ptcm := PgTsConfigMap{}
err = db.QueryRow(sqlstr, mapcfg, maptokentype, mapseqno).Scan(&ptcm.Tableoid, &ptcm.Cmax, &ptcm.Xmax, &ptcm.Cmin, &ptcm.Xmin, &ptcm.Ctid, &ptcm.Mapcfg, &ptcm.Maptokentype, &ptcm.Mapseqno, &ptcm.Mapdict)
if err != nil {
return nil, err
}
return &ptcm, nil
}
|
[
"func",
"PgTsConfigMapByMapcfgMaptokentypeMapseqno",
"(",
"db",
"XODB",
",",
"mapcfg",
"pgtypes",
".",
"Oid",
",",
"maptokentype",
"int",
",",
"mapseqno",
"int",
")",
"(",
"*",
"PgTsConfigMap",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, ctid, mapcfg, maptokentype, mapseqno, mapdict `",
"+",
"`FROM pg_catalog.pg_ts_config_map `",
"+",
"`WHERE mapcfg = $1 AND maptokentype = $2 AND mapseqno = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"mapcfg",
",",
"maptokentype",
",",
"mapseqno",
")",
"\n",
"ptcm",
":=",
"PgTsConfigMap",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"mapcfg",
",",
"maptokentype",
",",
"mapseqno",
")",
".",
"Scan",
"(",
"&",
"ptcm",
".",
"Tableoid",
",",
"&",
"ptcm",
".",
"Cmax",
",",
"&",
"ptcm",
".",
"Xmax",
",",
"&",
"ptcm",
".",
"Cmin",
",",
"&",
"ptcm",
".",
"Xmin",
",",
"&",
"ptcm",
".",
"Ctid",
",",
"&",
"ptcm",
".",
"Mapcfg",
",",
"&",
"ptcm",
".",
"Maptokentype",
",",
"&",
"ptcm",
".",
"Mapseqno",
",",
"&",
"ptcm",
".",
"Mapdict",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptcm",
",",
"nil",
"\n",
"}"
] |
// PgTsConfigMapByMapcfgMaptokentypeMapseqno retrieves a row from 'pg_catalog.pg_ts_config_map' as a PgTsConfigMap.
//
// Generated from index 'pg_ts_config_map_index'.
|
[
"PgTsConfigMapByMapcfgMaptokentypeMapseqno",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_config_map",
"as",
"a",
"PgTsConfigMap",
".",
"Generated",
"from",
"index",
"pg_ts_config_map_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44071-L44090
|
22,797
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsDictByDictnameDictnamespace
|
func PgTsDictByDictnameDictnamespace(db XODB, dictname pgtypes.Name, dictnamespace pgtypes.Oid) (*PgTsDict, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
`FROM pg_catalog.pg_ts_dict ` +
`WHERE dictname = $1 AND dictnamespace = $2`
// run query
XOLog(sqlstr, dictname, dictnamespace)
ptd := PgTsDict{}
err = db.QueryRow(sqlstr, dictname, dictnamespace).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Oid, &ptd.Ctid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption)
if err != nil {
return nil, err
}
return &ptd, nil
}
|
go
|
func PgTsDictByDictnameDictnamespace(db XODB, dictname pgtypes.Name, dictnamespace pgtypes.Oid) (*PgTsDict, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption ` +
`FROM pg_catalog.pg_ts_dict ` +
`WHERE dictname = $1 AND dictnamespace = $2`
// run query
XOLog(sqlstr, dictname, dictnamespace)
ptd := PgTsDict{}
err = db.QueryRow(sqlstr, dictname, dictnamespace).Scan(&ptd.Tableoid, &ptd.Cmax, &ptd.Xmax, &ptd.Cmin, &ptd.Xmin, &ptd.Oid, &ptd.Ctid, &ptd.Dictname, &ptd.Dictnamespace, &ptd.Dictowner, &ptd.Dicttemplate, &ptd.Dictinitoption)
if err != nil {
return nil, err
}
return &ptd, nil
}
|
[
"func",
"PgTsDictByDictnameDictnamespace",
"(",
"db",
"XODB",
",",
"dictname",
"pgtypes",
".",
"Name",
",",
"dictnamespace",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsDict",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, dictname, dictnamespace, dictowner, dicttemplate, dictinitoption `",
"+",
"`FROM pg_catalog.pg_ts_dict `",
"+",
"`WHERE dictname = $1 AND dictnamespace = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dictname",
",",
"dictnamespace",
")",
"\n",
"ptd",
":=",
"PgTsDict",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"dictname",
",",
"dictnamespace",
")",
".",
"Scan",
"(",
"&",
"ptd",
".",
"Tableoid",
",",
"&",
"ptd",
".",
"Cmax",
",",
"&",
"ptd",
".",
"Xmax",
",",
"&",
"ptd",
".",
"Cmin",
",",
"&",
"ptd",
".",
"Xmin",
",",
"&",
"ptd",
".",
"Oid",
",",
"&",
"ptd",
".",
"Ctid",
",",
"&",
"ptd",
".",
"Dictname",
",",
"&",
"ptd",
".",
"Dictnamespace",
",",
"&",
"ptd",
".",
"Dictowner",
",",
"&",
"ptd",
".",
"Dicttemplate",
",",
"&",
"ptd",
".",
"Dictinitoption",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptd",
",",
"nil",
"\n",
"}"
] |
// PgTsDictByDictnameDictnamespace retrieves a row from 'pg_catalog.pg_ts_dict' as a PgTsDict.
//
// Generated from index 'pg_ts_dict_dictname_index'.
|
[
"PgTsDictByDictnameDictnamespace",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_dict",
"as",
"a",
"PgTsDict",
".",
"Generated",
"from",
"index",
"pg_ts_dict_dictname_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44095-L44114
|
22,798
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsParserByOid
|
func PgTsParserByOid(db XODB, oid pgtypes.Oid) (*PgTsParser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
`FROM pg_catalog.pg_ts_parser ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptp := PgTsParser{}
err = db.QueryRow(sqlstr, oid).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Oid, &ptp.Ctid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype)
if err != nil {
return nil, err
}
return &ptp, nil
}
|
go
|
func PgTsParserByOid(db XODB, oid pgtypes.Oid) (*PgTsParser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype ` +
`FROM pg_catalog.pg_ts_parser ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptp := PgTsParser{}
err = db.QueryRow(sqlstr, oid).Scan(&ptp.Tableoid, &ptp.Cmax, &ptp.Xmax, &ptp.Cmin, &ptp.Xmin, &ptp.Oid, &ptp.Ctid, &ptp.Prsname, &ptp.Prsnamespace, &ptp.Prsstart, &ptp.Prstoken, &ptp.Prsend, &ptp.Prsheadline, &ptp.Prslextype)
if err != nil {
return nil, err
}
return &ptp, nil
}
|
[
"func",
"PgTsParserByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsParser",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, prsname, prsnamespace, prsstart, prstoken, prsend, prsheadline, prslextype `",
"+",
"`FROM pg_catalog.pg_ts_parser `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptp",
":=",
"PgTsParser",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptp",
".",
"Tableoid",
",",
"&",
"ptp",
".",
"Cmax",
",",
"&",
"ptp",
".",
"Xmax",
",",
"&",
"ptp",
".",
"Cmin",
",",
"&",
"ptp",
".",
"Xmin",
",",
"&",
"ptp",
".",
"Oid",
",",
"&",
"ptp",
".",
"Ctid",
",",
"&",
"ptp",
".",
"Prsname",
",",
"&",
"ptp",
".",
"Prsnamespace",
",",
"&",
"ptp",
".",
"Prsstart",
",",
"&",
"ptp",
".",
"Prstoken",
",",
"&",
"ptp",
".",
"Prsend",
",",
"&",
"ptp",
".",
"Prsheadline",
",",
"&",
"ptp",
".",
"Prslextype",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptp",
",",
"nil",
"\n",
"}"
] |
// PgTsParserByOid retrieves a row from 'pg_catalog.pg_ts_parser' as a PgTsParser.
//
// Generated from index 'pg_ts_parser_oid_index'.
|
[
"PgTsParserByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_parser",
"as",
"a",
"PgTsParser",
".",
"Generated",
"from",
"index",
"pg_ts_parser_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44143-L44162
|
22,799
|
xo/xo
|
examples/pgcatalog/pgcatalog/pgcatalog.xo.go
|
PgTsTemplateByOid
|
func PgTsTemplateByOid(db XODB, oid pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, oid).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
go
|
func PgTsTemplateByOid(db XODB, oid pgtypes.Oid) (*PgTsTemplate, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize ` +
`FROM pg_catalog.pg_ts_template ` +
`WHERE oid = $1`
// run query
XOLog(sqlstr, oid)
ptt := PgTsTemplate{}
err = db.QueryRow(sqlstr, oid).Scan(&ptt.Tableoid, &ptt.Cmax, &ptt.Xmax, &ptt.Cmin, &ptt.Xmin, &ptt.Oid, &ptt.Ctid, &ptt.Tmplname, &ptt.Tmplnamespace, &ptt.Tmplinit, &ptt.Tmpllexize)
if err != nil {
return nil, err
}
return &ptt, nil
}
|
[
"func",
"PgTsTemplateByOid",
"(",
"db",
"XODB",
",",
"oid",
"pgtypes",
".",
"Oid",
")",
"(",
"*",
"PgTsTemplate",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`tableoid, cmax, xmax, cmin, xmin, oid, ctid, tmplname, tmplnamespace, tmplinit, tmpllexize `",
"+",
"`FROM pg_catalog.pg_ts_template `",
"+",
"`WHERE oid = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"oid",
")",
"\n",
"ptt",
":=",
"PgTsTemplate",
"{",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"oid",
")",
".",
"Scan",
"(",
"&",
"ptt",
".",
"Tableoid",
",",
"&",
"ptt",
".",
"Cmax",
",",
"&",
"ptt",
".",
"Xmax",
",",
"&",
"ptt",
".",
"Cmin",
",",
"&",
"ptt",
".",
"Xmin",
",",
"&",
"ptt",
".",
"Oid",
",",
"&",
"ptt",
".",
"Ctid",
",",
"&",
"ptt",
".",
"Tmplname",
",",
"&",
"ptt",
".",
"Tmplnamespace",
",",
"&",
"ptt",
".",
"Tmplinit",
",",
"&",
"ptt",
".",
"Tmpllexize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ptt",
",",
"nil",
"\n",
"}"
] |
// PgTsTemplateByOid retrieves a row from 'pg_catalog.pg_ts_template' as a PgTsTemplate.
//
// Generated from index 'pg_ts_template_oid_index'.
|
[
"PgTsTemplateByOid",
"retrieves",
"a",
"row",
"from",
"pg_catalog",
".",
"pg_ts_template",
"as",
"a",
"PgTsTemplate",
".",
"Generated",
"from",
"index",
"pg_ts_template_oid_index",
"."
] |
1a94fa516029cb306cce6d379d086e4d5b5bb232
|
https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/pgcatalog/pgcatalog/pgcatalog.xo.go#L44191-L44210
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.