duckdb 0.3.5-dev966.0 → 0.3.5-dev983.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.5-dev966.0",
+  "version": "0.3.5-dev983.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -297,7 +297,6 @@ public:
 
 namespace duckdb {
 
-class ColumnStatistics;
 class DataTable;
 struct CreateViewInfo;
 
@@ -1531,7 +1530,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&... args) {
+	RETURN_TYPE ReadSerializable(RETURN_TYPE default_value, ARGS &&...args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			return default_value;
@@ -1553,7 +1552,7 @@ public:
 	}
 
 	template <class T, class RETURN_TYPE = unique_ptr<T>, typename... ARGS>
-	RETURN_TYPE ReadRequiredSerializable(ARGS &&... args) {
+	RETURN_TYPE ReadRequiredSerializable(ARGS &&...args) {
 		if (field_count >= max_field_count) {
 			// field is not there, read the default value
 			throw SerializationException("Attempting to read mandatory field, but field is missing");
@@ -3594,10 +3593,13 @@ TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schem
       column_dependency_manager(move(info->column_dependency_manager)) {
 	this->temporary = info->Base().temporary;
 	// add lower case aliases
+	this->name_map = move(info->name_map);
+#ifdef DEBUG
+	D_ASSERT(name_map.size() == columns.size());
 	for (idx_t i = 0; i < columns.size(); i++) {
-		D_ASSERT(name_map.find(columns[i].Name()) == name_map.end());
-		name_map[columns[i].Name()] = i;
+		D_ASSERT(name_map[columns[i].Name()] == i);
 	}
+#endif
 	// add the "rowid" alias, if there is no rowid column specified in the table
 	if (name_map.find("rowid") == name_map.end()) {
 		name_map["rowid"] = COLUMN_IDENTIFIER_ROW_ID;
@@ -98694,6 +98696,9 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 	functions.AddFunction(ListConcatFun::GetFunction());
 
 	set.AddFunction(functions);
+
+	functions.name = "add";
+	set.AddFunction(functions);
 }
 
 //===--------------------------------------------------------------------===//
@@ -98912,6 +98917,9 @@ void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 	// we can negate intervals
 	functions.AddFunction(GetFunction(LogicalType::INTERVAL));
 	set.AddFunction(functions);
+
+	functions.name = "subtract";
+	set.AddFunction(functions);
 }
 
 //===--------------------------------------------------------------------===//
@@ -99044,6 +99052,9 @@ void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 	    ScalarFunction({LogicalType::BIGINT, LogicalType::INTERVAL}, LogicalType::INTERVAL,
 	                   ScalarFunction::BinaryFunction<int64_t, interval_t, interval_t, MultiplyOperator>, true));
 	set.AddFunction(functions);
+
+	functions.name = "multiply";
+	set.AddFunction(functions);
 }
 
 //===--------------------------------------------------------------------===//
@@ -99165,6 +99176,9 @@ void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
 
 	set.AddFunction(functions);
+
+	functions.name = "divide";
+	set.AddFunction(functions);
 }
 
 //===--------------------------------------------------------------------===//
@@ -165243,7 +165257,9 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		if (column.Generated()) {
 			continue;
 		}
-		ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
+		if (column.Type().id() == LogicalTypeId::VARCHAR) {
+			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
+		}
 		BindLogicalType(context, column.TypeMutable());
 		if (column.Type().id() == LogicalTypeId::ENUM) {
 			// We add a catalog dependency
@@ -179096,7 +179112,10 @@ DataTable::DataTable(DatabaseInstance &db, const string &schema, const string &t
 			}
 			row_groups->AppendSegment(move(new_row_group));
 		}
-		column_stats = move(data->column_stats);
+		column_stats.reserve(data->column_stats.size());
+		for (auto &stats : data->column_stats) {
+			column_stats.push_back(make_shared<ColumnStatistics>(move(stats)));
+		}
 		if (column_stats.size() != types.size()) { // LCOV_EXCL_START
 			throw IOException("Table statistics column count is not aligned with table column count. Corrupt file?");
 		} // LCOV_EXCL_STOP
@@ -179106,7 +179125,7 @@ DataTable::DataTable(DatabaseInstance &db, const string &schema, const string &t
 
 		AppendRowGroup(0);
 		for (auto &type : types) {
-			column_stats.push_back(BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS));
+			column_stats.push_back(ColumnStatistics::CreateEmptyStats(type));
 		}
 	} else {
 		D_ASSERT(column_stats.size() == types.size());
@@ -179134,9 +179153,9 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition
 
 	// set up the statistics
 	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
-		column_stats.push_back(parent.column_stats[i]->Copy());
+		column_stats.push_back(parent.column_stats[i]);
 	}
-	column_stats.push_back(BaseStatistics::CreateEmpty(new_column_type, StatisticsType::GLOBAL_STATS));
+	column_stats.push_back(ColumnStatistics::CreateEmptyStats(new_column_type));
 
 	// add the column definitions from this DataTable
 	column_definitions.emplace_back(new_column.Copy());
@@ -179159,7 +179178,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, ColumnDefinition
 	while (current_row_group) {
 		auto new_row_group = current_row_group->AddColumn(context, new_column, executor, default_value, result);
 		// merge in the statistics
-		column_stats[new_column_idx]->Merge(*new_row_group->GetStatistics(new_column_idx));
+		column_stats[new_column_idx]->stats->Merge(*new_row_group->GetStatistics(new_column_idx));
 
 		row_groups->AppendSegment(move(new_row_group));
 		current_row_group = (RowGroup *)current_row_group->next.get();
@@ -179195,7 +179214,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t removed_co
 	// erase the stats from this DataTable
 	for (idx_t i = 0; i < parent.column_stats.size(); i++) {
 		if (i != removed_column) {
-			column_stats.push_back(parent.column_stats[i]->Copy());
+			column_stats.push_back(parent.column_stats[i]);
 		}
 	}
 
@@ -179251,10 +179270,9 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_id
 	// the column that had its type changed will have the new statistics computed during conversion
 	for (idx_t i = 0; i < column_definitions.size(); i++) {
 		if (i == changed_idx) {
-			column_stats.push_back(
-			    BaseStatistics::CreateEmpty(column_definitions[i].Type(), StatisticsType::GLOBAL_STATS));
+			column_stats.push_back(ColumnStatistics::CreateEmptyStats(column_definitions[i].Type()));
 		} else {
-			column_stats.push_back(parent.column_stats[i]->Copy());
+			column_stats.push_back(parent.column_stats[i]);
 		}
 	}
 
@@ -179285,7 +179303,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_id
 	while (current_row_group) {
 		auto new_row_group =
 		    current_row_group->AlterType(context, target_type, changed_idx, executor, scan_state, scan_chunk);
-		column_stats[changed_idx]->Merge(*new_row_group->GetStatistics(changed_idx));
+		column_stats[changed_idx]->stats->Merge(*new_row_group->GetStatistics(changed_idx));
 		row_groups->AppendSegment(move(new_row_group));
 		current_row_group = (RowGroup *)current_row_group->next.get();
 	}
@@ -179778,7 +179796,7 @@ void DataTable::Append(Transaction &transaction, DataChunk &chunk, TableAppendSt
 			// merge the stats
 			lock_guard<mutex> stats_guard(stats_lock);
 			for (idx_t i = 0; i < column_definitions.size(); i++) {
-				column_stats[i]->Merge(*current_row_group->GetStatistics(i));
+				column_stats[i]->stats->Merge(*current_row_group->GetStatistics(i));
 			}
 		}
 		state.remaining_append_count -= append_count;
@@ -179812,7 +179830,7 @@ void DataTable::Append(Transaction &transaction, DataChunk &chunk, TableAppendSt
 		if (type == PhysicalType::LIST || type == PhysicalType::STRUCT) {
 			continue;
 		}
-		column_stats[col_idx]->UpdateDistinctStatistics(chunk.data[col_idx], chunk.size());
+		column_stats[col_idx]->stats->UpdateDistinctStatistics(chunk.data[col_idx], chunk.size());
 	}
 }
 
@@ -180257,7 +180275,7 @@ void DataTable::Update(TableCatalogEntry &table, ClientContext &context, Vector
 		lock_guard<mutex> stats_guard(stats_lock);
 		for (idx_t i = 0; i < column_ids.size(); i++) {
 			auto column_id = column_ids[i];
-			column_stats[column_id]->Merge(*row_group->GetStatistics(column_id));
+			column_stats[column_id]->stats->Merge(*row_group->GetStatistics(column_id));
 		}
 	} while (pos < count);
 }
@@ -180290,7 +180308,7 @@ void DataTable::UpdateColumn(TableCatalogEntry &table, ClientContext &context, V
 	row_group->UpdateColumn(transaction, updates, row_ids, column_path);
 
 	lock_guard<mutex> stats_guard(stats_lock);
-	column_stats[primary_column_idx]->Merge(*row_group->GetStatistics(primary_column_idx));
+	column_stats[primary_column_idx]->stats->Merge(*row_group->GetStatistics(primary_column_idx));
 }
 
 //===--------------------------------------------------------------------===//
@@ -180375,7 +180393,7 @@ unique_ptr<BaseStatistics> DataTable::GetStatistics(ClientContext &context, colu
 		return nullptr;
 	}
 	lock_guard<mutex> stats_guard(stats_lock);
-	return column_stats[column_id]->Copy();
+	return column_stats[column_id]->stats->Copy();
 }
 
 //===--------------------------------------------------------------------===//
@@ -180386,7 +180404,7 @@ BlockPointer DataTable::Checkpoint(TableDataWriter &writer) {
 	// FIXME: we might want to combine adjacent row groups in case they have had deletions...
 	vector<unique_ptr<BaseStatistics>> global_stats;
 	for (idx_t i = 0; i < column_definitions.size(); i++) {
-		global_stats.push_back(column_stats[i]->Copy());
+		global_stats.push_back(column_stats[i]->stats->Copy());
 	}
 
 	auto row_group = (RowGroup *)row_groups->GetRootSegment();
@@ -181852,6 +181870,19 @@ void BaseStatistics::Verify(Vector &vector, idx_t count) const {
 } // namespace duckdb
 
 
+namespace duckdb {
+
+ColumnStatistics::ColumnStatistics(unique_ptr<BaseStatistics> stats_p) : stats(move(stats_p)) {
+}
+
+shared_ptr<ColumnStatistics> ColumnStatistics::CreateEmptyStats(const LogicalType &type) {
+	auto col_stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
+	return make_shared<ColumnStatistics>(move(col_stats));
+}
+
+} // namespace duckdb
+
+
 
 
 

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "466fb1f9d"
-#define DUCKDB_VERSION "v0.3.5-dev966"
+#define DUCKDB_SOURCE_ID "8b86bff5a"
+#define DUCKDB_VERSION "v0.3.5-dev983"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -11653,7 +11653,6 @@ private:
 
 namespace duckdb {
 
-class ColumnStatistics;
 class DataTable;
 struct CreateTableInfo;
 struct BoundCreateTableInfo;
@@ -21370,6 +21369,32 @@ private:
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/column_statistics.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+class ColumnStatistics {
+public:
+	explicit ColumnStatistics(unique_ptr<BaseStatistics> stats_p);
+
+	unique_ptr<BaseStatistics> stats;
+
+public:
+	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
+};
+
+} // namespace duckdb
+
 
 
 
@@ -21604,7 +21629,7 @@ private:
 	//! The segment trees holding the various row_groups of the table
 	shared_ptr<SegmentTree> row_groups;
 	//! Column statistics
-	vector<unique_ptr<BaseStatistics>> column_stats;
+	vector<shared_ptr<ColumnStatistics>> column_stats;
 	//! The statistics lock
 	mutex stats_lock;
 	//! Whether or not the data table is the root DataTable for this table; the root DataTable is the newest version