duckdb 0.8.1-dev180.0 → 0.8.1-dev194.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 (4) hide show
  1. package/package.json +1 -1
  2. package/src/duckdb/src/catalog/default/default_types.cpp +9 -84
  3. package/src/duckdb/src/function/table/version/pragma_version.cpp +2 -2
  4. package/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp +97 -0
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "duckdb",
3
3
  "main": "./lib/duckdb.js",
4
4
  "types": "./lib/duckdb.d.ts",
5
- "version": "0.8.1-dev180.0",
5
+ "version": "0.8.1-dev194.0",
6
6
  "description": "DuckDB node.js API",
7
7
  "gypfile": true,
8
8
  "dependencies": {
package/src/duckdb/src/catalog/default/default_types.cpp CHANGED
@@ -4,94 +4,18 @@
4
4
  #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
5
5
  #include "duckdb/common/string_util.hpp"
6
6
  #include "duckdb/parser/parsed_data/create_type_info.hpp"
7
+ #include "duckdb/catalog/default/builtin_types/types.hpp"
7
8
 
8
9
  namespace duckdb {
9
10
 
10
- struct DefaultType {
11
- const char *name;
12
- LogicalTypeId type;
13
- };
14
-
15
- static DefaultType internal_types[] = {{"int", LogicalTypeId::INTEGER},
16
- {"int4", LogicalTypeId::INTEGER},
17
- {"signed", LogicalTypeId::INTEGER},
18
- {"integer", LogicalTypeId::INTEGER},
19
- {"integral", LogicalTypeId::INTEGER},
20
- {"int32", LogicalTypeId::INTEGER},
21
- {"varchar", LogicalTypeId::VARCHAR},
22
- {"bpchar", LogicalTypeId::VARCHAR},
23
- {"text", LogicalTypeId::VARCHAR},
24
- {"string", LogicalTypeId::VARCHAR},
25
- {"char", LogicalTypeId::VARCHAR},
26
- {"nvarchar", LogicalTypeId::VARCHAR},
27
- {"bytea", LogicalTypeId::BLOB},
28
- {"blob", LogicalTypeId::BLOB},
29
- {"varbinary", LogicalTypeId::BLOB},
30
- {"binary", LogicalTypeId::BLOB},
31
- {"bit", LogicalTypeId::BIT},
32
- {"bitstring", LogicalTypeId::BIT},
33
- {"int8", LogicalTypeId::BIGINT},
34
- {"bigint", LogicalTypeId::BIGINT},
35
- {"int64", LogicalTypeId::BIGINT},
36
- {"long", LogicalTypeId::BIGINT},
37
- {"oid", LogicalTypeId::BIGINT},
38
- {"int2", LogicalTypeId::SMALLINT},
39
- {"smallint", LogicalTypeId::SMALLINT},
40
- {"short", LogicalTypeId::SMALLINT},
41
- {"int16", LogicalTypeId::SMALLINT},
42
- {"timestamp", LogicalTypeId::TIMESTAMP},
43
- {"datetime", LogicalTypeId::TIMESTAMP},
44
- {"timestamp_us", LogicalTypeId::TIMESTAMP},
45
- {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
46
- {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
47
- {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
48
- {"bool", LogicalTypeId::BOOLEAN},
49
- {"boolean", LogicalTypeId::BOOLEAN},
50
- {"logical", LogicalTypeId::BOOLEAN},
51
- {"decimal", LogicalTypeId::DECIMAL},
52
- {"dec", LogicalTypeId::DECIMAL},
53
- {"numeric", LogicalTypeId::DECIMAL},
54
- {"real", LogicalTypeId::FLOAT},
55
- {"float4", LogicalTypeId::FLOAT},
56
- {"float", LogicalTypeId::FLOAT},
57
- {"double", LogicalTypeId::DOUBLE},
58
- {"float8", LogicalTypeId::DOUBLE},
59
- {"tinyint", LogicalTypeId::TINYINT},
60
- {"int1", LogicalTypeId::TINYINT},
61
- {"date", LogicalTypeId::DATE},
62
- {"time", LogicalTypeId::TIME},
63
- {"interval", LogicalTypeId::INTERVAL},
64
- {"hugeint", LogicalTypeId::HUGEINT},
65
- {"int128", LogicalTypeId::HUGEINT},
66
- {"uuid", LogicalTypeId::UUID},
67
- {"guid", LogicalTypeId::UUID},
68
- {"struct", LogicalTypeId::STRUCT},
69
- {"row", LogicalTypeId::STRUCT},
70
- {"list", LogicalTypeId::LIST},
71
- {"map", LogicalTypeId::MAP},
72
- {"utinyint", LogicalTypeId::UTINYINT},
73
- {"uint8", LogicalTypeId::UTINYINT},
74
- {"usmallint", LogicalTypeId::USMALLINT},
75
- {"uint16", LogicalTypeId::USMALLINT},
76
- {"uinteger", LogicalTypeId::UINTEGER},
77
- {"uint32", LogicalTypeId::UINTEGER},
78
- {"ubigint", LogicalTypeId::UBIGINT},
79
- {"uint64", LogicalTypeId::UBIGINT},
80
- {"union", LogicalTypeId::UNION},
81
- {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
82
- {"timetz", LogicalTypeId::TIME_TZ},
83
- {"enum", LogicalTypeId::ENUM},
84
- {"null", LogicalTypeId::SQLNULL},
85
- {nullptr, LogicalTypeId::INVALID}};
86
-
87
11
  LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) {
88
- auto lower_str = StringUtil::Lower(name);
89
- for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
90
- if (internal_types[index].name == lower_str) {
91
- return internal_types[index].type;
12
+ auto &internal_types = BUILTIN_TYPES;
13
+ for (auto &type : internal_types) {
14
+ if (StringUtil::CIEquals(name, type.name)) {
15
+ return type.type;
92
16
  }
93
17
  }
94
- return LogicalTypeId::INVALID;
18
+ return LogicalType::INVALID;
95
19
  }
96
20
 
97
21
  DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema)
@@ -119,8 +43,9 @@ vector<string> DefaultTypeGenerator::GetDefaultEntries() {
119
43
  if (schema.name != DEFAULT_SCHEMA) {
120
44
  return result;
121
45
  }
122
- for (idx_t index = 0; internal_types[index].name != nullptr; index++) {
123
- result.emplace_back(internal_types[index].name);
46
+ auto &internal_types = BUILTIN_TYPES;
47
+ for (auto &type : internal_types) {
48
+ result.emplace_back(StringUtil::Lower(type.name));
124
49
  }
125
50
  return result;
126
51
  }
package/src/duckdb/src/function/table/version/pragma_version.cpp CHANGED
@@ -1,8 +1,8 @@
1
1
  #ifndef DUCKDB_VERSION
2
- #define DUCKDB_VERSION "0.8.1-dev180"
2
+ #define DUCKDB_VERSION "0.8.1-dev194"
3
3
  #endif
4
4
  #ifndef DUCKDB_SOURCE_ID
5
- #define DUCKDB_SOURCE_ID "e9f6ba553a"
5
+ #define DUCKDB_SOURCE_ID "54a1955565"
6
6
  #endif
7
7
  #include "duckdb/function/table/system_functions.hpp"
8
8
  #include "duckdb/main/database.hpp"
package/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp ADDED
@@ -0,0 +1,97 @@
1
+ //===----------------------------------------------------------------------===//
2
+ // DuckDB
3
+ //
4
+ // duckdb/catalog/default/builtin_types/types.hpp
5
+ //
6
+ //
7
+ //===----------------------------------------------------------------------===//
8
+ // This file is generated by scripts/generate_builtin_types.py
9
+
10
+ #pragma once
11
+
12
+ #include "duckdb/common/types.hpp"
13
+ #include "duckdb/common/array.hpp"
14
+
15
+ namespace duckdb {
16
+
17
+ struct DefaultType {
18
+ const char *name;
19
+ LogicalTypeId type;
20
+ };
21
+
22
+ using builtin_type_array = std::array<DefaultType, 70>;
23
+
24
+ static constexpr const builtin_type_array BUILTIN_TYPES{{
25
+ {"decimal", LogicalTypeId::DECIMAL},
26
+ {"dec", LogicalTypeId::DECIMAL},
27
+ {"numeric", LogicalTypeId::DECIMAL},
28
+ {"time", LogicalTypeId::TIME},
29
+ {"date", LogicalTypeId::DATE},
30
+ {"timestamp", LogicalTypeId::TIMESTAMP},
31
+ {"datetime", LogicalTypeId::TIMESTAMP},
32
+ {"timestamp_us", LogicalTypeId::TIMESTAMP},
33
+ {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
34
+ {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
35
+ {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
36
+ {"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
37
+ {"timetz", LogicalTypeId::TIME_TZ},
38
+ {"interval", LogicalTypeId::INTERVAL},
39
+ {"varchar", LogicalTypeId::VARCHAR},
40
+ {"bpchar", LogicalTypeId::VARCHAR},
41
+ {"string", LogicalTypeId::VARCHAR},
42
+ {"char", LogicalTypeId::VARCHAR},
43
+ {"nvarchar", LogicalTypeId::VARCHAR},
44
+ {"text", LogicalTypeId::VARCHAR},
45
+ {"blob", LogicalTypeId::BLOB},
46
+ {"bytea", LogicalTypeId::BLOB},
47
+ {"varbinary", LogicalTypeId::BLOB},
48
+ {"binary", LogicalTypeId::BLOB},
49
+ {"hugeint", LogicalTypeId::HUGEINT},
50
+ {"int128", LogicalTypeId::HUGEINT},
51
+ {"bigint", LogicalTypeId::BIGINT},
52
+ {"oid", LogicalTypeId::BIGINT},
53
+ {"long", LogicalTypeId::BIGINT},
54
+ {"int8", LogicalTypeId::BIGINT},
55
+ {"int64", LogicalTypeId::BIGINT},
56
+ {"ubigint", LogicalTypeId::UBIGINT},
57
+ {"uint64", LogicalTypeId::UBIGINT},
58
+ {"integer", LogicalTypeId::INTEGER},
59
+ {"int", LogicalTypeId::INTEGER},
60
+ {"int4", LogicalTypeId::INTEGER},
61
+ {"signed", LogicalTypeId::INTEGER},
62
+ {"integral", LogicalTypeId::INTEGER},
63
+ {"int32", LogicalTypeId::INTEGER},
64
+ {"uinteger", LogicalTypeId::UINTEGER},
65
+ {"uint32", LogicalTypeId::UINTEGER},
66
+ {"smallint", LogicalTypeId::SMALLINT},
67
+ {"int2", LogicalTypeId::SMALLINT},
68
+ {"short", LogicalTypeId::SMALLINT},
69
+ {"int16", LogicalTypeId::SMALLINT},
70
+ {"usmallint", LogicalTypeId::USMALLINT},
71
+ {"uint16", LogicalTypeId::USMALLINT},
72
+ {"tinyint", LogicalTypeId::TINYINT},
73
+ {"int1", LogicalTypeId::TINYINT},
74
+ {"utinyint", LogicalTypeId::UTINYINT},
75
+ {"uint8", LogicalTypeId::UTINYINT},
76
+ {"struct", LogicalTypeId::STRUCT},
77
+ {"row", LogicalTypeId::STRUCT},
78
+ {"list", LogicalTypeId::LIST},
79
+ {"map", LogicalTypeId::MAP},
80
+ {"union", LogicalTypeId::UNION},
81
+ {"bit", LogicalTypeId::BIT},
82
+ {"bitstring", LogicalTypeId::BIT},
83
+ {"boolean", LogicalTypeId::BOOLEAN},
84
+ {"bool", LogicalTypeId::BOOLEAN},
85
+ {"logical", LogicalTypeId::BOOLEAN},
86
+ {"uuid", LogicalTypeId::UUID},
87
+ {"guid", LogicalTypeId::UUID},
88
+ {"enum", LogicalTypeId::ENUM},
89
+ {"null", LogicalTypeId::SQLNULL},
90
+ {"float", LogicalTypeId::FLOAT},
91
+ {"real", LogicalTypeId::FLOAT},
92
+ {"float4", LogicalTypeId::FLOAT},
93
+ {"double", LogicalTypeId::DOUBLE},
94
+ {"float8", LogicalTypeId::DOUBLE}
95
+ }};
96
+
97
+ } // namespace duckdb