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
import { DataType, nil, QueryError, _IType } from '../interfaces-private.ts';import { TypeBase } from './datatype-base.ts';import { Evaluator } from '../evaluator.ts';import moment from 'https://deno.land/x/momentjs@2.29.1-deno/mod.ts';import { parseTime, nullIsh } from '../utils.ts';
export class TimestampType extends TypeBase<Date> {

    constructor(readonly primary: DataType, readonly precision: number | null = null) {        super();    }
    get name(): string {        if (!nullIsh(this.precision)) {            return `${this.primary}(${this.precision})`;        }        switch (this.primary) {            case DataType.timestamp:                return 'timestamp without time zone';            case DataType.timestamptz:                return 'timestamp with time zone';            case DataType.date:                return 'date';            case DataType.time:                return 'time without time zone';            case DataType.timetz:                return 'time with time zone';        }        return this.primary;    }
    doCanCast(to: _IType) {        switch (to.primary) {            case DataType.timestamp:            case DataType.timestamptz:            case DataType.date:                return this.primary !== DataType.time && this.primary !== DataType.timetz;            case DataType.time:                return this.primary !== DataType.date;            case DataType.timetz:                return this.primary !== DataType.date && this.primary !== DataType.timestamp;        }        return null;    }
    doCanConvertImplicit(to: _IType) {        switch (to.primary) {            case DataType.timestamp:                return this.primary === DataType.timestamp                    || this.primary === DataType.date;            case DataType.timestamptz:                return this.primary !== DataType.time;            case DataType.date:                return this.primary === DataType.date;            case DataType.time:                return this.primary === DataType.time; // nothing can implicitly cast to time        }        return false;    }
    doCast(value: Evaluator, to: _IType) {        switch (to.primary) {            case DataType.timestamp:            case DataType.timestamptz:                return value;            case DataType.date:                return value                    .setConversion(raw => moment.utc(raw).startOf('day').toDate()                        , toDate => ({ toDate }));            case DataType.time:            case DataType.timetz:                return value                    .setConversion(raw => moment.utc(raw).format('HH:mm:ss') + '.000000'                        , toDate => ({ toDate }));        }        throw new Error('Unexpected cast error');    }

    doCanBuildFrom(from: _IType) {        switch (from.primary) {            case DataType.text:                return true;        }        return false;    }
    doBuildFrom(value: Evaluator, from: _IType): Evaluator<Date> | nil {        switch (from.primary) {            case DataType.text:                switch (this.primary) {                    case DataType.timestamp:                    case DataType.timestamptz:                        return value                            .setConversion(str => {                                const conv = moment.utc(str);                                if (!conv.isValid()) {                                    throw new QueryError(`Invalid timestamp format: ` + str);                                }                                return conv.toDate()                            }                                , toTs => ({ toTs, t: this.primary }));                    case DataType.date:                        return value                            .setConversion(str => {                                const conv = moment.utc(str);                                if (!conv.isValid()) {                                    throw new QueryError(`Invalid timestamp format: ` + str);                                }                                return conv.startOf('day').toDate();                            }                                , toDate => ({ toDate }));                    case DataType.time:                    case DataType.timetz:                        return value                            .setConversion(str => {                                parseTime(str); // will throw an error if invalid format                                return str;                            }                                , toTime => ({ toTime, t: this.primary }));                }        }        return null;    }


    doEquals(a: any, b: any): boolean {        return Math.abs(moment(a).diff(moment(b))) < 0.1;    }    doGt(a: any, b: any): boolean {        return moment(a).diff(moment(b)) > 0;    }    doLt(a: any, b: any): boolean {        return moment(a).diff(moment(b)) < 0;    }}