duckdb 0.3.5-dev964.0 → 0.3.5-dev974.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.5-dev964.0",
+  "version": "0.3.5-dev974.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;
 
@@ -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;
@@ -97509,12 +97511,28 @@ struct IsInfiniteOperator {
 	}
 };
 
+template <>
+bool IsInfiniteOperator::Operation(date_t input) {
+	return !Value::IsFinite(input);
+}
+
+template <>
+bool IsInfiniteOperator::Operation(timestamp_t input) {
+	return !Value::IsFinite(input);
+}
+
 void IsInfiniteFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet funcs("isinf");
 	funcs.AddFunction(ScalarFunction({LogicalType::FLOAT}, LogicalType::BOOLEAN,
 	                                 ScalarFunction::UnaryFunction<float, bool, IsInfiniteOperator>));
 	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
 	                                 ScalarFunction::UnaryFunction<double, bool, IsInfiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<date_t, bool, IsInfiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsInfiniteOperator>));
 	set.AddFunction(funcs);
 }
 
@@ -97534,6 +97552,12 @@ void IsFiniteFun::RegisterFunction(BuiltinFunctions &set) {
 	                                 ScalarFunction::UnaryFunction<float, bool, IsFiniteOperator>));
 	funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE}, LogicalType::BOOLEAN,
 	                                 ScalarFunction::UnaryFunction<double, bool, IsFiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::DATE}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<date_t, bool, IsFiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
+	funcs.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ}, LogicalType::BOOLEAN,
+	                                 ScalarFunction::UnaryFunction<timestamp_t, bool, IsFiniteOperator>));
 	set.AddFunction(funcs);
 }
 
@@ -165221,7 +165245,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
@@ -179074,7 +179100,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
@@ -179084,7 +179113,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());
@@ -179112,9 +179141,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());
@@ -179137,7 +179166,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();
@@ -179173,7 +179202,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]);
 		}
 	}
 
@@ -179229,10 +179258,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]);
 		}
 	}
 
@@ -179263,7 +179291,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();
 	}
@@ -179756,7 +179784,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;
@@ -179790,7 +179818,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());
 	}
 }
 
@@ -180235,7 +180263,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);
 }
@@ -180268,7 +180296,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));
 }
 
 //===--------------------------------------------------------------------===//
@@ -180353,7 +180381,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();
 }
 
 //===--------------------------------------------------------------------===//
@@ -180364,7 +180392,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();
@@ -181830,6 +181858,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 "950e78c27"
-#define DUCKDB_VERSION "v0.3.5-dev964"
+#define DUCKDB_SOURCE_ID "05499e7c7"
+#define DUCKDB_VERSION "v0.3.5-dev974"
 //===----------------------------------------------------------------------===//
 //                         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