duckdb 0.7.1-dev100.0 → 0.7.1-dev107.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.1-dev100.0",
+  "version": "0.7.1-dev107.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -65,9 +65,12 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// ON CONFLICT DO UPDATE clause
 		auto &insert_op = (LogicalInsert &)op;
 		if (insert_op.action_type != OnConflictAction::THROW) {
+			// Get the bindings from the children
 			VisitOperatorChildren(op);
-			auto dummy_bindings = LogicalOperator::GenerateColumnBindings(
-			    insert_op.excluded_table_index, insert_op.table->GetColumns().PhysicalColumnCount());
+			auto column_count = insert_op.table->GetColumns().PhysicalColumnCount();
+			auto dummy_bindings = LogicalOperator::GenerateColumnBindings(insert_op.excluded_table_index, column_count);
+			// Now insert our dummy bindings at the start of the bindings,
+			// so the first 'column_count' indices of the chunk are reserved for our 'excluded' columns
 			bindings.insert(bindings.begin(), dummy_bindings.begin(), dummy_bindings.end());
 			if (insert_op.on_conflict_condition) {
 				VisitExpression(&insert_op.on_conflict_condition);

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -1,10 +1,12 @@
-#include "duckdb/function/pragma/pragma_functions.hpp"
-#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/constants.hpp"
 #include "duckdb/common/file_system.hpp"
-#include "duckdb/parser/statement/export_statement.hpp"
-#include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/parser/parser.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/function/pragma/pragma_functions.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/parser/qualified_name.hpp"
+#include "duckdb/parser/statement/copy_statement.hpp"
+#include "duckdb/parser/statement/export_statement.hpp"
 
 namespace duckdb {
 
@@ -58,10 +60,35 @@ string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &pa
 
 string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
 	// PRAGMA table_info but with some aliases
-	return StringUtil::Format(
-	    "SELECT name AS \"column_name\", type as \"column_type\", CASE WHEN \"notnull\" THEN 'NO' ELSE 'YES' "
-	    "END AS \"null\", NULL AS \"key\", dflt_value AS \"default\", NULL AS \"extra\" FROM pragma_table_info('%s');",
-	    parameters.values[0].ToString());
+	auto table = QualifiedName::Parse(parameters.values[0].ToString());
+
+	// clang-format off
+    string sql = R"(
+	SELECT
+		name AS "column_name",
+		type as "column_type",
+		CASE WHEN "notnull" THEN 'NO' ELSE 'YES' END AS "null",
+		(SELECT 
+			MIN(CASE 
+				WHEN constraint_type='PRIMARY KEY' THEN 'PRI'
+				WHEN constraint_type='UNIQUE' THEN 'UNI' 
+				ELSE NULL END) 
+		FROM duckdb_constraints() c  
+		WHERE c.table_oid=cols.table_oid 
+		AND list_contains(constraint_column_names, cols.column_name)) AS "key",
+		dflt_value AS "default", 
+		NULL AS "extra" 
+	FROM pragma_table_info('%func_param_table%') 
+	LEFT JOIN duckdb_columns cols 
+	ON cols.column_name = pragma_table_info.name 
+	AND cols.table_name='%table_name%'
+	AND cols.schema_name='%table_schema%';)";
+	// clang-format on
+
+	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());
+	sql = StringUtil::Replace(sql, "%table_name%", table.name);
+	sql = StringUtil::Replace(sql, "%table_schema%", table.schema.empty() ? DEFAULT_SCHEMA : table.schema);
+	return sql;
 }
 
 string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.1-dev100"
+#define DUCKDB_VERSION "0.7.1-dev107"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "1955e8bf10"
+#define DUCKDB_SOURCE_ID "8a8581e2e3"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/planner/operator/logical_execute.hpp

@@ -32,11 +32,7 @@ protected:
 		// already resolved
 	}
 	vector<ColumnBinding> GetColumnBindings() override {
-		vector<ColumnBinding> bindings;
-		for (idx_t i = 0; i < types.size(); i++) {
-			bindings.push_back(ColumnBinding(0, i));
-		}
-		return bindings;
+		return GenerateColumnBindings(0, types.size());
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_show.hpp

@@ -33,8 +33,7 @@ protected:
 		         LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
 	}
 	vector<ColumnBinding> GetColumnBindings() override {
-		return {ColumnBinding(0, 0), ColumnBinding(0, 1), ColumnBinding(0, 2),
-		        ColumnBinding(0, 3), ColumnBinding(0, 4), ColumnBinding(0, 5)};
+		return GenerateColumnBindings(0, types.size());
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -28,6 +28,9 @@ InsertStatement::InsertStatement(const InsertStatement &other)
       select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(other.select_statement->Copy())),
       columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog) {
 	cte_map = other.cte_map.Copy();
+	if (other.table_ref) {
+		table_ref = other.table_ref->Copy();
+	}
 	if (other.on_conflict_info) {
 		on_conflict_info = other.on_conflict_info->Copy();
 	}

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -301,7 +301,28 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		insert.on_conflict_condition = std::move(condition);
 	}
 
-	auto projection_index = insert.children[0]->GetTableIndex()[0];
+	auto bindings = insert.children[0]->GetColumnBindings();
+	idx_t projection_index = DConstants::INVALID_INDEX;
+	std::vector<unique_ptr<LogicalOperator>> *insert_child_operators;
+	insert_child_operators = &insert.children;
+	while (projection_index == DConstants::INVALID_INDEX) {
+		if (insert_child_operators->empty()) {
+			// No further children to visit
+			break;
+		}
+		D_ASSERT(insert_child_operators->size() >= 1);
+		auto &current_child = (*insert_child_operators)[0];
+		auto table_indices = current_child->GetTableIndex();
+		if (table_indices.empty()) {
+			// This operator does not have a table index to refer to, we have to visit its children
+			insert_child_operators = &current_child->children;
+			continue;
+		}
+		projection_index = table_indices[0];
+	}
+	if (projection_index == DConstants::INVALID_INDEX) {
+		throw InternalException("Could not locate a table_index from the children of the insert");
+	}
 
 	string unused;
 	auto original_binding = bind_context.GetBinding(table_alias, unused);

package/src/duckdb/src/planner/logical_operator.cpp

@@ -57,6 +57,7 @@ void LogicalOperator::ResolveOperatorTypes() {
 
 vector<ColumnBinding> LogicalOperator::GenerateColumnBindings(idx_t table_idx, idx_t column_count) {
 	vector<ColumnBinding> result;
+	result.reserve(column_count);
 	for (idx_t i = 0; i < column_count; i++) {
 		result.emplace_back(table_idx, i);
 	}
@@ -84,6 +85,7 @@ vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &
 		vector<ColumnBinding> result_bindings;
 		result_bindings.reserve(projection_map.size());
 		for (auto index : projection_map) {
+			D_ASSERT(index < bindings.size());
 			result_bindings.push_back(bindings[index]);
 		}
 		return result_bindings;