duckdb 0.5.2-dev2.0 → 0.5.2-dev2001.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. package/.mocharc.json +5 -0
  2. package/lib/duckdb.d.ts +103 -0
  3. package/lib/duckdb.js +182 -12
  4. package/package.json +16 -4
  5. package/src/connection.cpp +117 -10
  6. package/src/duckdb.cpp +121772 -103769
  7. package/src/duckdb.hpp +10933 -8241
  8. package/src/duckdb_node.hpp +9 -2
  9. package/src/parquet-amalgamation.cpp +32150 -31985
  10. package/src/parquet-amalgamation.hpp +6 -3
  11. package/src/statement.cpp +124 -7
  12. package/test/data_type_support.test.js +6 -0
  13. package/test/open_close.test.js +2 -2
  14. package/test/support/createdb.js +13 -11
  15. package/test/typescript_decls.test.ts +209 -0
  16. package/test/udf.test.js +42 -42
  17. package/tsconfig.json +12 -0
package/test/udf.test.js CHANGED
@@ -9,142 +9,142 @@ describe('UDFs', function() {
9
9
  });
10
10
 
11
11
  it('0ary int', function(done) {
12
- db.register("udf", "integer", () => 42);
12
+ db.register_udf("udf", "integer", () => 42);
13
13
  db.all("select udf() v", function(err, rows) {
14
14
  if (err) throw err;
15
15
  assert.equal(rows[0].v, 42);
16
16
  });
17
- db.unregister("udf", done);
17
+ db.unregister_udf("udf", done);
18
18
  });
19
19
 
20
20
  it('0ary double', function(done) {
21
- db.register("udf", "double", () => 4.2);
21
+ db.register_udf("udf", "double", () => 4.2);
22
22
  db.all("select udf() v", function(err, rows) {
23
23
  if (err) throw err;
24
24
  assert.equal(rows[0].v, 4.2);
25
25
  });
26
- db.unregister("udf", done);
26
+ db.unregister_udf("udf", done);
27
27
  });
28
28
 
29
29
  it('0ary string', function(done) {
30
- db.register("udf", "varchar", () => 'hello');
30
+ db.register_udf("udf", "varchar", () => 'hello');
31
31
  db.all("select udf() v", function(err, rows) {
32
32
  if (err) throw err;
33
33
  assert.equal(rows[0].v, 'hello');
34
34
  });
35
- db.unregister("udf", done);
35
+ db.unregister_udf("udf", done);
36
36
  });
37
37
 
38
38
  it('0ary int null', function(done) {
39
- db.register("udf", "integer", () => undefined);
39
+ db.register_udf("udf", "integer", () => undefined);
40
40
  db.all("select udf() v", function(err, rows) {
41
41
  if (err) throw err;
42
42
  assert.equal(rows[0].v, undefined);
43
43
  });
44
- db.unregister("udf", done);
44
+ db.unregister_udf("udf", done);
45
45
  });
46
46
 
47
47
 
48
48
  it('0ary string null', function(done) {
49
- db.register("udf", "varchar", () => undefined);
49
+ db.register_udf("udf", "varchar", () => undefined);
50
50
  db.all("select udf() v", function(err, rows) {
51
51
  if (err) throw err;
52
52
  assert.equal(rows[0].v, undefined);
53
53
  });
54
- db.unregister("udf", done);
54
+ db.unregister_udf("udf", done);
55
55
  });
56
56
 
57
57
 
58
58
  it('unary int', function(done) {
59
- db.register("udf", "integer", (x) => x+1);
59
+ db.register_udf("udf", "integer", (x) => x+1);
60
60
  db.all("select udf(42) v", function(err, rows) {
61
61
  if (err) throw err;
62
62
  assert.equal(rows[0].v, 43);
63
63
  });
64
- db.unregister("udf", done);
64
+ db.unregister_udf("udf", done);
65
65
  });
66
66
 
67
67
  it('unary double', function(done) {
68
- db.register("udf", "double", (x) => x);
68
+ db.register_udf("udf", "double", (x) => x);
69
69
  db.all("select udf(4.2::double) v", function(err, rows) {
70
70
  if (err) throw err;
71
71
  assert.equal(rows[0].v, 4.2);
72
72
  });
73
- db.unregister("udf", done);
73
+ db.unregister_udf("udf", done);
74
74
  });
75
75
 
76
76
  it('unary int null', function(done) {
77
- db.register("udf", "integer", (x) => undefined);
77
+ db.register_udf("udf", "integer", (x) => undefined);
78
78
  db.all("select udf(42) v", function(err, rows) {
79
79
  if (err) throw err;
80
80
  assert.equal(rows[0].v, undefined);
81
81
  });
82
- db.unregister("udf", done);
82
+ db.unregister_udf("udf", done);
83
83
  });
84
84
 
85
85
 
86
86
  it('unary double null', function(done) {
87
- db.register("udf", "double", (x) => undefined);
87
+ db.register_udf("udf", "double", (x) => undefined);
88
88
  db.all("select udf(4.2::double) v", function(err, rows) {
89
89
  if (err) throw err;
90
90
  assert.equal(rows[0].v, undefined);
91
91
  });
92
- db.unregister("udf", done);
92
+ db.unregister_udf("udf", done);
93
93
  });
94
94
 
95
95
 
96
96
  it('unary string', function(done) {
97
- db.register("udf", "varchar", (x) => 'hello ' + x);
97
+ db.register_udf("udf", "varchar", (x) => 'hello ' + x);
98
98
  db.all("select udf('world') v", function(err, rows) {
99
99
  if (err) throw err;
100
100
  assert.equal(rows[0].v, 'hello world');
101
101
  });
102
- db.unregister("udf", done);
102
+ db.unregister_udf("udf", done);
103
103
  });
104
104
 
105
105
  it('unary string null', function(done) {
106
- db.register("udf", "varchar", (x) => undefined);
106
+ db.register_udf("udf", "varchar", (x) => undefined);
107
107
  db.all("select udf('world') v", function(err, rows) {
108
108
  if (err) throw err;
109
109
  assert.equal(rows[0].v, undefined);
110
110
  });
111
- db.unregister("udf", done);
111
+ db.unregister_udf("udf", done);
112
112
  });
113
113
 
114
114
  it('binary int', function(done) {
115
- db.register("udf", "integer", (x, y) => x + y);
115
+ db.register_udf("udf", "integer", (x, y) => x + y);
116
116
  db.all("select udf(40, 2) v", function(err, rows) {
117
117
  if (err) throw err;
118
118
  assert.equal(rows[0].v, 42);
119
119
  });
120
- db.unregister("udf", done);
120
+ db.unregister_udf("udf", done);
121
121
  });
122
122
 
123
123
  it('binary string', function(done) {
124
- db.register("udf", "varchar", (x, y) => x + ' ' + y);
124
+ db.register_udf("udf", "varchar", (x, y) => x + ' ' + y);
125
125
  db.all("select udf('hello', 'world') v", function(err, rows) {
126
126
  if (err) throw err;
127
127
  assert.equal(rows[0].v, 'hello world');
128
128
  });
129
- db.unregister("udf", done);
129
+ db.unregister_udf("udf", done);
130
130
  });
131
131
 
132
132
  it('ternary int', function(done) {
133
- db.register("udf", "integer", (x, y, z) => x + y + z);
133
+ db.register_udf("udf", "integer", (x, y, z) => x + y + z);
134
134
  db.all("select udf(21, 20, 1) v", function(err, rows) {
135
135
  if (err) throw err;
136
136
  assert.equal(rows[0].v, 42);
137
137
  });
138
- db.unregister("udf", done);
138
+ db.unregister_udf("udf", done);
139
139
  });
140
140
 
141
141
  it('unary larger series', function(done) {
142
- db.register("udf", "integer", (x) => 1);
142
+ db.register_udf("udf", "integer", (x) => 1);
143
143
  db.all("select sum(udf(range::double)) v from range(10000)", function(err, rows) {
144
144
  if (err) throw err;
145
145
  assert.equal(rows[0].v, 10000);
146
146
  });
147
- db.unregister("udf", done);
147
+ db.unregister_udf("udf", done);
148
148
  });
149
149
  });
150
150
 
@@ -155,60 +155,60 @@ describe('UDFs', function() {
155
155
  });
156
156
 
157
157
  it('tinyint', function(done) {
158
- db.register("udf", "integer", (x) => x+1);
158
+ db.register_udf("udf", "integer", (x) => x+1);
159
159
  db.all("select udf(42::tinyint) v", function(err, rows) {
160
160
  if (err) throw err;
161
161
  assert.equal(rows[0].v, 43);
162
162
  });
163
- db.unregister("udf", done);
163
+ db.unregister_udf("udf", done);
164
164
  });
165
165
 
166
166
  it('smallint', function(done) {
167
- db.register("udf", "integer", (x) => x+1);
167
+ db.register_udf("udf", "integer", (x) => x+1);
168
168
  db.all("select udf(42::smallint) v", function(err, rows) {
169
169
  if (err) throw err;
170
170
  assert.equal(rows[0].v, 43);
171
171
  });
172
- db.unregister("udf", done);
172
+ db.unregister_udf("udf", done);
173
173
  });
174
174
 
175
175
  it('int', function(done) {
176
- db.register("udf", "integer", (x) => x+1);
176
+ db.register_udf("udf", "integer", (x) => x+1);
177
177
  db.all("select udf(42::integer) v", function(err, rows) {
178
178
  if (err) throw err;
179
179
  assert.equal(rows[0].v, 43);
180
180
  });
181
- db.unregister("udf", done);
181
+ db.unregister_udf("udf", done);
182
182
  });
183
183
 
184
184
  it('timestamp', function(done) {
185
- db.register("udf", "timestamp", (x) => x);
185
+ db.register_udf("udf", "timestamp", (x) => x);
186
186
  db.all("select udf(timestamp '1992-09-20 11:30:00') v", function(err, rows) {
187
187
  if (err) throw err;
188
188
  });
189
- db.unregister("udf", done);
189
+ db.unregister_udf("udf", done);
190
190
  });
191
191
 
192
192
  it('struct', function(done) {
193
- db.register("udf", "integer", a => {
193
+ db.register_udf("udf", "integer", a => {
194
194
  return (a.x == null ? -100 : a.x);
195
195
  });
196
196
  db.all("SELECT min(udf({'x': (case when v % 2 = 0 then v else null end)::INTEGER, 'y': 42}))::INTEGER as foo FROM generate_series(1, 10000) as t(v)", function(err, rows) {
197
197
  if (err) throw err;
198
198
  assert.equal(rows[0].foo, -100);
199
199
  });
200
- db.unregister("udf", done);
200
+ db.unregister_udf("udf", done);
201
201
  });
202
202
 
203
203
  it('structnestednull', function(done) {
204
- db.register("udf", "integer", a => {
204
+ db.register_udf("udf", "integer", a => {
205
205
  return (a.x == null ? -100 : a.x.y);
206
206
  });
207
207
  db.all("SELECT min(udf({'x': (case when v % 2 = 0 then {'y': v::INTEGER } else null end), 'z': 42}))::INTEGER as foo FROM generate_series(1, 10000) as t(v)", function(err, rows) {
208
208
  if (err) throw err;
209
209
  assert.equal(rows[0].foo, -100);
210
210
  });
211
- db.unregister("udf", done);
211
+ db.unregister_udf("udf", done);
212
212
  });
213
213
  });
214
214
  });
package/tsconfig.json ADDED
@@ -0,0 +1,12 @@
1
+ {
2
+ "compilerOptions": {
3
+ "allowJs": false,
4
+ "esModuleInterop": true,
5
+ "noImplicitAny": true,
6
+ "strict": true,
7
+ "outDir": "./dist",
8
+ "types": ["node", "mocha"]
9
+ },
10
+ "include": ["test/**/*"],
11
+ "exclude": ["node_modules"]
12
+ }