-
Notifications
You must be signed in to change notification settings - Fork 92
/
decode.ts
278 lines (244 loc) · 7.28 KB
/
decode.ts
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
import { Oid } from "./oid.ts";
import { Column, Format } from "./connection.ts";
import { parseArray } from "./array_parser.ts";
// Datetime parsing based on:
// https://github.com/bendrucker/postgres-date/blob/master/index.js
const DATETIME_RE =
/^(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?/;
const DATE_RE = /^(\d{1,})-(\d{2})-(\d{2})$/;
const TIMEZONE_RE = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/;
const BC_RE = /BC$/;
function decodeDate(dateStr: string): null | Date {
const matches = DATE_RE.exec(dateStr);
if (!matches) {
return null;
}
const year = parseInt(matches[1], 10);
// remember JS dates are 0-based
const month = parseInt(matches[2], 10) - 1;
const day = parseInt(matches[3], 10);
const date = new Date(year, month, day);
// use `setUTCFullYear` because if date is from first
// century `Date`'s compatibility for millenium bug
// would set it as 19XX
date.setUTCFullYear(year);
return date;
}
/**
* Decode numerical timezone offset from provided date string.
*
* Matched these kinds:
* - `Z (UTC)`
* - `-05`
* - `+06:30`
* - `+06:30:10`
*
* Returns offset in miliseconds.
*/
function decodeTimezoneOffset(dateStr: string): null | number {
// get rid of date part as TIMEZONE_RE would match '-MM` part
const timeStr = dateStr.split(" ")[1];
const matches = TIMEZONE_RE.exec(timeStr);
if (!matches) {
return null;
}
const type = matches[1];
if (type === "Z") {
// Zulu timezone === UTC === 0
return 0;
}
// in JS timezone offsets are reversed, ie. timezones
// that are "positive" (+01:00) are represented as negative
// offsets and vice-versa
const sign = type === "-" ? 1 : -1;
const hours = parseInt(matches[2], 10);
const minutes = parseInt(matches[3] || "0", 10);
const seconds = parseInt(matches[4] || "0", 10);
const offset = hours * 3600 + minutes * 60 + seconds;
return sign * offset * 1000;
}
function decodeDatetime(dateStr: string): null | number | Date {
/**
* Postgres uses ISO 8601 style date output by default:
* 1997-12-17 07:37:16-08
*/
// there are special `infinity` and `-infinity`
// cases representing out-of-range dates
if (dateStr === "infinity") {
return Number(Infinity);
} else if (dateStr === "-infinity") {
return Number(-Infinity);
}
const matches = DATETIME_RE.exec(dateStr);
if (!matches) {
return decodeDate(dateStr);
}
const isBC = BC_RE.test(dateStr);
const year = parseInt(matches[1], 10) * (isBC ? -1 : 1);
// remember JS dates are 0-based
const month = parseInt(matches[2], 10) - 1;
const day = parseInt(matches[3], 10);
const hour = parseInt(matches[4], 10);
const minute = parseInt(matches[5], 10);
const second = parseInt(matches[6], 10);
// ms are written as .007
const msMatch = matches[7];
const ms = msMatch ? 1000 * parseFloat(msMatch) : 0;
let date: Date;
const offset = decodeTimezoneOffset(dateStr);
if (offset === null) {
date = new Date(year, month, day, hour, minute, second, ms);
} else {
// This returns miliseconds from 1 January, 1970, 00:00:00,
// adding decoded timezone offset will construct proper date object.
const utc = Date.UTC(year, month, day, hour, minute, second, ms);
date = new Date(utc + offset);
}
// use `setUTCFullYear` because if date is from first
// century `Date`'s compatibility for millenium bug
// would set it as 19XX
date.setUTCFullYear(year);
return date;
}
function decodeBinary() {
throw new Error("Not implemented!");
}
const HEX = 16;
const BACKSLASH_BYTE_VALUE = 92;
const HEX_PREFIX_REGEX = /^\\x/;
function decodeBytea(byteaStr: string): Uint8Array {
if (HEX_PREFIX_REGEX.test(byteaStr)) {
return decodeByteaHex(byteaStr);
} else {
return decodeByteaEscape(byteaStr);
}
}
function decodeByteaHex(byteaStr: string): Uint8Array {
const bytesStr = byteaStr.slice(2);
const bytes = new Uint8Array(bytesStr.length / 2);
for (let i = 0, j = 0; i < bytesStr.length; i += 2, j++) {
bytes[j] = parseInt(bytesStr[i] + bytesStr[i + 1], HEX);
}
return bytes;
}
function decodeByteaEscape(byteaStr: string): Uint8Array {
const bytes = [];
let i = 0;
let k = 0;
while (i < byteaStr.length) {
if (byteaStr[i] !== "\\") {
bytes.push(byteaStr.charCodeAt(i));
++i;
} else {
if (/[0-7]{3}/.test(byteaStr.substr(i + 1, 3))) {
bytes.push(parseInt(byteaStr.substr(i + 1, 3), 8));
i += 4;
} else {
let backslashes = 1;
while (
i + backslashes < byteaStr.length &&
byteaStr[i + backslashes] === "\\"
) {
backslashes++;
}
for (k = 0; k < Math.floor(backslashes / 2); ++k) {
bytes.push(BACKSLASH_BYTE_VALUE);
}
i += Math.floor(backslashes / 2) * 2;
}
}
}
return new Uint8Array(bytes);
}
const decoder = new TextDecoder();
// deno-lint-ignore no-explicit-any
function decodeStringArray(value: string): any {
if (!value) return null;
return parseArray(value, undefined);
}
function decodeBaseTenInt(value: string): number {
return parseInt(value, 10);
}
// deno-lint-ignore no-explicit-any
function decodeIntArray(value: string): any {
if (!value) return null;
return parseArray(value, decodeBaseTenInt);
}
function decodeJsonArray(value: string): unknown[] {
return parseArray(value, JSON.parse);
}
// deno-lint-ignore no-explicit-any
function decodeText(value: Uint8Array, typeOid: number): any {
const strValue = decoder.decode(value);
switch (typeOid) {
case Oid.char:
case Oid.varchar:
case Oid.text:
case Oid.time:
case Oid.timetz:
case Oid.inet:
case Oid.cidr:
case Oid.macaddr:
case Oid.name:
case Oid.uuid:
case Oid.oid:
case Oid.regproc:
case Oid.regprocedure:
case Oid.regoper:
case Oid.regoperator:
case Oid.regclass:
case Oid.regtype:
case Oid.regrole:
case Oid.regnamespace:
case Oid.regconfig:
case Oid.regdictionary:
case Oid.int8: // @see https://github.com/buildondata/deno-postgres/issues/91.
case Oid.numeric:
case Oid.void:
case Oid.bpchar:
return strValue;
case Oid._text:
case Oid._varchar:
case Oid._macaddr:
case Oid._cidr:
case Oid._inet:
case Oid._bpchar:
case Oid._uuid:
return decodeStringArray(strValue);
case Oid.bool:
return strValue[0] === "t";
case Oid.int2:
case Oid.int4:
return decodeBaseTenInt(strValue);
case Oid._int2:
case Oid._int4:
return decodeIntArray(strValue);
case Oid.float4:
case Oid.float8:
return parseFloat(strValue);
case Oid.timestamptz:
case Oid.timestamp:
return decodeDatetime(strValue);
case Oid.date:
return decodeDate(strValue);
case Oid.json:
case Oid.jsonb:
return JSON.parse(strValue);
case Oid.json_array:
case Oid.jsonb_array:
return decodeJsonArray(strValue);
case Oid.bytea:
return decodeBytea(strValue);
default:
throw new Error(`Don't know how to parse column type: ${typeOid}`);
}
}
export function decode(value: Uint8Array, column: Column) {
if (column.format === Format.BINARY) {
return decodeBinary();
} else if (column.format === Format.TEXT) {
return decodeText(value, column.typeOid);
} else {
throw new Error(`Unknown column format: ${column.format}`);
}
}