-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathutil.go
More file actions
240 lines (222 loc) · 6.17 KB
/
util.go
File metadata and controls
240 lines (222 loc) · 6.17 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
package ora
import (
"errors"
"fmt"
"runtime"
"strings"
)
// checkNumericColumn returns nil when the column type is numeric; otherwise, an error.
func checkNumericColumn(gct GoColumnType, columnName string) error {
switch gct {
case I64, I32, I16, I8, U64, U32, U16, U8, F64, F32, OraI64, OraI32, OraI16, OraI8, OraU64, OraU32, OraU16, OraU8, OraF64, OraF32:
return nil
}
if columnName == "" {
return errF("Invalid go column type (%v) specified for numeric sql column. Expected go column type I64, I32, I16, I8, U64, U32, U16, U8, F64, F32, OraI64, OraI32, OraI16, OraI8, OraU64, OraU32, OraU16, OraU8, OraF64 or OraF32.", GctName(gct))
} else {
return errF("Invalid go column type (%v) specified for numeric sql column (%v). Expected go column type I64, I32, I16, I8, U64, U32, U16, U8, F64, F32, OraI64, OraI32, OraI16, OraI8, OraU64, OraU32, OraU16, OraU8, OraF64 or OraF32.", GctName(gct), columnName)
}
}
// checkTimeColumn returns nil when the column type is time; otherwise, an error.
func checkTimeColumn(gct GoColumnType) error {
switch gct {
case T, OraT:
return nil
}
return errF("Invalid go column type (%v) specified for time-based sql column. Expected go column type T or OraT.", GctName(gct))
}
// checkStringColumn returns nil when the column type is string; otherwise, an error.
func checkStringColumn(gct GoColumnType) error {
switch gct {
case S, OraS:
return nil
}
return errF("Invalid go column type (%v) specified for string-based sql column. Expected go column type S or OraS.", GctName(gct))
}
// checkBoolOrStringColumn returns nil when the column type is bool; otherwise, an error.
func checkBoolOrStringColumn(gct GoColumnType) error {
switch gct {
case B, OraB, S, OraS:
return nil
}
return errF("Invalid go column type (%v) specified. Expected go column type B, OraB, S, or OraS.", GctName(gct))
}
// checkBinOrU8Column returns nil when the column type is Bin or U8; otherwise, an error.
func checkBinOrU8Column(gct GoColumnType) error {
switch gct {
case Bin, U8:
return nil
}
return errF("Invalid go column type (%v) specified. Expected go column type Bin or U8.", GctName(gct))
}
// checkBitsColumn returns nil when the column type is Bin or OraBits; otherwise, an error.
func checkBinColumn(gct GoColumnType) error {
switch gct {
case Bin, OraBin:
return nil
}
return errF("Invalid go column type (%v) specified. Expected go column type Bits or OraBits.", GctName(gct))
}
func GctName(gct GoColumnType) string {
switch gct {
case D:
return "D"
case I64:
return "I64"
case I32:
return "I32"
case I16:
return "I16"
case I8:
return "I8"
case U64:
return "U64"
case U32:
return "U32"
case U16:
return "U16"
case U8:
return "U8"
case F64:
return "F64"
case F32:
return "F32"
case OraI64:
return "OraI64"
case OraI32:
return "OraI32"
case OraI16:
return "OraI16"
case OraI8:
return "OraI8"
case OraU64:
return "OraU64"
case OraU32:
return "OraU32"
case OraU16:
return "OraU16"
case OraU8:
return "OraU8"
case OraF64:
return "OraF64"
case OraF32:
return "OraF32"
case T:
return "T"
case OraT:
return "OraT"
case S:
return "S"
case OraS:
return "OraS"
case B:
return "B"
case OraB:
return "OraB"
case Bin:
return "Bin"
case OraBin:
return "OraBin"
}
return ""
}
func stringTrimmed(buffer []byte, pad byte) string {
// Find length of non-padded string value
// String buffer returned from Oracle is padded with Space char (32)
//fmt.Println("stringTrimmed: len(buffer): ", len(buffer))
var n int
for n = len(buffer) - 1; n > -1; n-- {
if buffer[n] != pad {
n++
break
}
}
if n > 0 {
return string(buffer[:n])
}
return ""
}
func clear(buffer []byte, fill byte) {
for n, _ := range buffer {
buffer[n] = fill
}
}
func errNew(str string) error {
return errors.New("ora: " + str)
}
func callInfo(depth int) string {
// get caller method name; remove main. prefix
pc, file, _, _ := runtime.Caller(depth + 1)
// get file name without path or suffix
file = file[strings.LastIndex(file, "/")+1 : len(file)-3]
method := runtime.FuncForPC(pc).Name()
n := strings.LastIndex(method, ")")
m := strings.LastIndex(method, "*")
if n < 0 {
m = strings.LastIndex(method, "(")
}
if n < 0 { // main.func·015
return fmt.Sprintf("[%v]", method)
} else { // main.(*core).open
return fmt.Sprintf("[%v.%v]", method[m+1:n], method[n+2:])
}
}
func errInfo(depth int) string {
// get caller method name; remove main. prefix
pc, file, line, _ := runtime.Caller(depth + 1)
file = file[strings.LastIndex(file, "/")+1:]
method := runtime.FuncForPC(pc).Name()
n := strings.LastIndex(method, ")")
m := strings.LastIndex(method, "*")
if n < 0 {
m = strings.LastIndex(method, "(")
}
if n > -1 { // main.(*core).open
return fmt.Sprintf("%v.%v", method[m+1:n], method[n+2:])
}
return fmt.Sprintf("%v:%v:%v", file, line, method)
}
// log writes a message with caller info.
func log(enabled bool, v ...interface{}) {
if enabled {
if len(v) == 0 {
_drv.cfg.Log.Logger.Infof("%v", callInfo(1))
} else {
_drv.cfg.Log.Logger.Infof("%v %v", callInfo(1), fmt.Sprint(v...))
}
}
}
// log writes a formatted message with caller info.
func logF(enabled bool, format string, v ...interface{}) {
if enabled {
if len(v) == 0 {
_drv.cfg.Log.Logger.Infof("%v", callInfo(1))
} else {
_drv.cfg.Log.Logger.Infof("%v %v", callInfo(1), fmt.Sprintf(format, v...))
}
}
}
// err creates an error with caller info.
func er(v ...interface{}) (err error) {
err = errors.New(fmt.Sprintf("%v %v", errInfo(1), fmt.Sprint(v...)))
_drv.cfg.Log.Logger.Errorln(err)
return err
}
// errF creates a formatted error with caller info.
func errF(format string, v ...interface{}) (err error) {
err = errors.New(fmt.Sprintf("%v %v", errInfo(1), fmt.Sprintf(format, v...)))
_drv.cfg.Log.Logger.Errorln(err)
return err
}
// errR creates a recovered error with caller info.
func errR(v ...interface{}) (err error) {
err = errors.New(fmt.Sprintf("%v recovered: %v", errInfo(1), fmt.Sprint(v...)))
_drv.cfg.Log.Logger.Errorln(err)
return err
}
// errE wraps an error with caller info.
func errE(e error) (err error) {
err = errors.New(fmt.Sprintf("%v %v", errInfo(1), e.Error()))
_drv.cfg.Log.Logger.Errorln(err)
return err
}