duckdb 0.3.2-dev1031.0 → 0.3.2-dev1073.0

package/src/duckdb.cpp

@@ -13124,6 +13124,9 @@ extern "C" WINBASEAPI BOOL WINAPI GetPhysicallyInstalledSystemMemory(PULONGLONG)
 
 namespace duckdb {
 
+FileSystem::~FileSystem() {
+}
+
 FileSystem &FileSystem::GetFileSystem(ClientContext &context) {
 	return *context.db->config.file_system;
 }
@@ -13347,6 +13350,12 @@ bool FileSystem::OnDiskFile(FileHandle &handle) {
 }
 // LCOV_EXCL_STOP
 
+FileHandle::FileHandle(FileSystem &file_system, string path_p) : file_system(file_system), path(move(path_p)) {
+}
+
+FileHandle::~FileHandle() {
+}
+
 int64_t FileHandle::Read(void *buffer, idx_t nr_bytes) {
 	return file_system.Read(*this, buffer, nr_bytes);
 }
@@ -57349,7 +57358,7 @@ void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql
 	// update parser info, and read, generate & set col_names based on previous findings
 	if (((!first_row_consistent || first_row_nulls) && !options.has_header) || (options.has_header && options.header)) {
 		options.header = true;
-		unordered_map<string, idx_t> name_collision_count;
+		case_insensitive_map_t<idx_t> name_collision_count;
 		// get header names from CSV
 		for (idx_t col = 0; col < options.num_cols; col++) {
 			const auto &val = best_header_row.GetValue(col, 0);
@@ -74221,7 +74230,7 @@ string Function::CallToString(const string &name, const vector<LogicalType> &arg
 }
 
 string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
-                              const unordered_map<string, LogicalType> &named_parameters) {
+                              const named_parameter_type_map_t &named_parameters) {
 	vector<string> input_arguments;
 	input_arguments.reserve(arguments.size() + named_parameters.size());
 	for (auto &arg : arguments) {
@@ -78550,7 +78559,8 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 					break;
 				case 'c':
 				case 'x':
-				case 'X': {
+				case 'X':
+				case 'T': {
 					string subformat;
 					if (format_char == 'c') {
 						// %c: Locale’s appropriate date and time representation.
@@ -78560,7 +78570,7 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 						// %x - Locale’s appropriate date representation.
 						// we push the ISO date format here
 						subformat = "%Y-%m-%d";
-					} else if (format_char == 'X') {
+					} else if (format_char == 'X' || format_char == 'T') {
 						// %X - Locale’s appropriate time representation.
 						// we push the ISO time format here
 						subformat = "%H:%M:%S";
@@ -79035,7 +79045,18 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 				result_data[4] -= minute_offset;
 				break;
 			}
-
+			case StrTimeSpecifier::TZ_NAME: {
+				// skip leading spaces
+				while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
+					pos++;
+				}
+				// stop when we encounter a space or the end of the string
+				while (pos < size && !StringUtil::CharacterIsSpace(data[pos])) {
+					pos++;
+				}
+				// FIXME: actually use the timestamp...
+				break;
+			}
 			default:
 				throw NotImplementedException("Unsupported specifier for strptime");
 			}
@@ -79134,6 +79155,20 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 	return make_unique<StrpTimeBindData>(format);
 }
 
+StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, const string &text) {
+	StrpTimeFormat format;
+	format.format_specifier = format_string;
+	string error = StrTimeFormat::ParseFormatSpecifier(format_string, format);
+	if (!error.empty()) {
+		throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
+	}
+	StrpTimeFormat::ParseResult result;
+	if (!format.Parse(text, result)) {
+		throw InvalidInputException("Failed to parse string \"%s\" with format specifier \"%s\"", text, format_string);
+	}
+	return result;
+}
+
 string StrpTimeFormat::FormatStrpTimeError(const string &input, idx_t position) {
 	if (position == DConstants::INVALID_INDEX) {
 		return string();
@@ -89604,7 +89639,7 @@ public:
 private:
 	//! Binds an arrow table
 	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, vector<Value> &inputs,
-	                                              unordered_map<string, Value> &named_parameters,
+	                                              named_parameter_map_t &named_parameters,
 	                                              vector<LogicalType> &input_table_types,
 	                                              vector<string> &input_table_names, vector<LogicalType> &return_types,
 	                                              vector<string> &names);
@@ -89804,7 +89839,7 @@ LogicalType GetArrowLogicalType(ArrowSchema &schema,
 }
 
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, vector<Value> &inputs,
-                                                           unordered_map<string, Value> &named_parameters,
+                                                           named_parameter_map_t &named_parameters,
                                                            vector<LogicalType> &input_table_types,
                                                            vector<string> &input_table_names,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
@@ -90808,7 +90843,7 @@ struct UnnestTableFunction {
 namespace duckdb {
 
 static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, vector<Value> &inputs,
-                                               unordered_map<string, Value> &named_parameters,
+                                               named_parameter_map_t &named_parameters,
                                                vector<LogicalType> &input_table_types,
                                                vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                vector<string> &names) {
@@ -91460,7 +91495,7 @@ struct GlobFunctionBindData : public TableFunctionData {
 };
 
 static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -91637,7 +91672,7 @@ struct PragmaDetailedProfilingOutputData : public TableFunctionData {
 };
 
 static unique_ptr<FunctionData> PragmaDetailedProfilingOutputBind(ClientContext &context, vector<Value> &inputs,
-                                                                  unordered_map<string, Value> &named_parameters,
+                                                                  named_parameter_map_t &named_parameters,
                                                                   vector<LogicalType> &input_table_types,
                                                                   vector<string> &input_table_names,
                                                                   vector<LogicalType> &return_types,
@@ -91813,12 +91848,10 @@ struct PragmaLastProfilingOutputData : public TableFunctionData {
 	vector<LogicalType> types;
 };
 
-static unique_ptr<FunctionData> PragmaLastProfilingOutputBind(ClientContext &context, vector<Value> &inputs,
-                                                              unordered_map<string, Value> &named_parameters,
-                                                              vector<LogicalType> &input_table_types,
-                                                              vector<string> &input_table_names,
-                                                              vector<LogicalType> &return_types,
-                                                              vector<string> &names) {
+static unique_ptr<FunctionData>
+PragmaLastProfilingOutputBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
+                              vector<LogicalType> &input_table_types, vector<string> &input_table_names,
+                              vector<LogicalType> &return_types, vector<string> &names) {
 	names.emplace_back("OPERATOR_ID");
 	return_types.emplace_back(LogicalType::INTEGER);
 
@@ -91932,7 +91965,7 @@ struct RangeFunctionBindData : public TableFunctionData {
 
 template <bool GENERATE_SERIES>
 static unique_ptr<FunctionData>
-RangeFunctionBind(ClientContext &context, vector<Value> &inputs, unordered_map<string, Value> &named_parameters,
+RangeFunctionBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
                   vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                   vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_unique<RangeFunctionBindData>();
@@ -92043,7 +92076,7 @@ struct RangeDateTimeBindData : public TableFunctionData {
 
 template <bool GENERATE_SERIES>
 static unique_ptr<FunctionData>
-RangeDateTimeBind(ClientContext &context, vector<Value> &inputs, unordered_map<string, Value> &named_parameters,
+RangeDateTimeBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
                   vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                   vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_unique<RangeDateTimeBindData>();
@@ -92182,7 +92215,7 @@ void BuiltinFunctions::RegisterTableFunctions() {
 namespace duckdb {
 
 static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value> &inputs,
-                                            unordered_map<string, Value> &named_parameters,
+                                            named_parameter_map_t &named_parameters,
                                             vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                             vector<LogicalType> &return_types, vector<string> &names) {
 	auto &config = DBConfig::GetConfig(context);
@@ -92201,22 +92234,23 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 	}
 
 	for (auto &kv : named_parameters) {
-		if (kv.first == "auto_detect") {
+		auto loption = StringUtil::Lower(kv.first);
+		if (loption == "auto_detect") {
 			options.auto_detect = BooleanValue::Get(kv.second);
-		} else if (kv.first == "sep" || kv.first == "delim") {
+		} else if (loption == "sep" || loption == "delim") {
 			options.SetDelimiter(StringValue::Get(kv.second));
-		} else if (kv.first == "header") {
+		} else if (loption == "header") {
 			options.header = BooleanValue::Get(kv.second);
 			options.has_header = true;
-		} else if (kv.first == "quote") {
+		} else if (loption == "quote") {
 			options.quote = StringValue::Get(kv.second);
 			options.has_quote = true;
-		} else if (kv.first == "escape") {
+		} else if (loption == "escape") {
 			options.escape = StringValue::Get(kv.second);
 			options.has_escape = true;
-		} else if (kv.first == "nullstr") {
+		} else if (loption == "nullstr") {
 			options.null_str = StringValue::Get(kv.second);
-		} else if (kv.first == "sample_size") {
+		} else if (loption == "sample_size") {
 			int64_t sample_size = kv.second.GetValue<int64_t>();
 			if (sample_size < 1 && sample_size != -1) {
 				throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
@@ -92231,7 +92265,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
 				options.sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
 			}
-		} else if (kv.first == "sample_chunk_size") {
+		} else if (loption == "sample_chunk_size") {
 			options.sample_chunk_size = kv.second.GetValue<int64_t>();
 			if (options.sample_chunk_size > STANDARD_VECTOR_SIZE) {
 				throw BinderException(
@@ -92240,14 +92274,14 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			} else if (options.sample_chunk_size < 1) {
 				throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
 			}
-		} else if (kv.first == "sample_chunks") {
+		} else if (loption == "sample_chunks") {
 			options.sample_chunks = kv.second.GetValue<int64_t>();
 			if (options.sample_chunks < 1) {
 				throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
 			}
-		} else if (kv.first == "all_varchar") {
+		} else if (loption == "all_varchar") {
 			options.all_varchar = BooleanValue::Get(kv.second);
-		} else if (kv.first == "dateformat") {
+		} else if (loption == "dateformat") {
 			options.has_format[LogicalTypeId::DATE] = true;
 			auto &date_format = options.date_format[LogicalTypeId::DATE];
 			date_format.format_specifier = StringValue::Get(kv.second);
@@ -92255,7 +92289,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
 			}
-		} else if (kv.first == "timestampformat") {
+		} else if (loption == "timestampformat") {
 			options.has_format[LogicalTypeId::TIMESTAMP] = true;
 			auto &timestamp_format = options.date_format[LogicalTypeId::TIMESTAMP];
 			timestamp_format.format_specifier = StringValue::Get(kv.second);
@@ -92263,9 +92297,9 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
 			}
-		} else if (kv.first == "normalize_names") {
+		} else if (loption == "normalize_names") {
 			options.normalize_names = BooleanValue::Get(kv.second);
-		} else if (kv.first == "columns") {
+		} else if (loption == "columns") {
 			auto &child_type = kv.second.type();
 			if (child_type.id() != LogicalTypeId::STRUCT) {
 				throw BinderException("read_csv columns requires a a struct as input");
@@ -92284,12 +92318,14 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
-		} else if (kv.first == "compression") {
+		} else if (loption == "compression") {
 			options.compression = FileCompressionTypeFromString(StringValue::Get(kv.second));
-		} else if (kv.first == "filename") {
+		} else if (loption == "filename") {
 			result->include_file_name = BooleanValue::Get(kv.second);
-		} else if (kv.first == "skip") {
+		} else if (loption == "skip") {
 			options.skip_rows = kv.second.GetValue<int64_t>();
+		} else {
+			throw InternalException("Unrecognized parameter %s", kv.first);
 		}
 	}
 	if (!options.auto_detect && return_types.empty()) {
@@ -92343,7 +92379,7 @@ static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, cons
 }
 
 static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -92468,7 +92504,7 @@ struct RepeatOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> RepeatBind(ClientContext &context, vector<Value> &inputs,
-                                           unordered_map<string, Value> &named_parameters,
+                                           named_parameter_map_t &named_parameters,
                                            vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                            vector<LogicalType> &return_types, vector<string> &names) {
 	// the repeat function returns the type of the first argument
@@ -92515,7 +92551,7 @@ void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {
 namespace duckdb {
 
 static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -92583,7 +92619,7 @@ struct DuckDBColumnsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -92918,7 +92954,7 @@ struct DuckDBConstraintsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, vector<Value> &inputs,
-                                                      unordered_map<string, Value> &named_parameters,
+                                                      named_parameter_map_t &named_parameters,
                                                       vector<LogicalType> &input_table_types,
                                                       vector<string> &input_table_names,
                                                       vector<LogicalType> &return_types, vector<string> &names) {
@@ -93122,7 +93158,7 @@ struct DuckDBDependenciesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -93245,7 +93281,7 @@ struct DuckDBFunctionsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -93656,7 +93692,7 @@ struct DuckDBIndexesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -93776,7 +93812,7 @@ struct DuckDBKeywordsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, vector<Value> &inputs,
-                                                   unordered_map<string, Value> &named_parameters,
+                                                   named_parameter_map_t &named_parameters,
                                                    vector<LogicalType> &input_table_types,
                                                    vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                    vector<string> &names) {
@@ -93861,7 +93897,7 @@ struct DuckDBSchemasData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -93946,7 +93982,7 @@ struct DuckDBSequencesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -94081,7 +94117,7 @@ struct DuckDBSettingsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, vector<Value> &inputs,
-                                                   unordered_map<string, Value> &named_parameters,
+                                                   named_parameter_map_t &named_parameters,
                                                    vector<LogicalType> &input_table_types,
                                                    vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                    vector<string> &names) {
@@ -94190,7 +94226,7 @@ struct DuckDBTablesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -94343,7 +94379,7 @@ struct DuckDBTypesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -94482,7 +94518,7 @@ struct DuckDBViewsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -94593,7 +94629,7 @@ struct PragmaCollateData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -94653,7 +94689,7 @@ struct PragmaDatabaseListData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -94714,7 +94750,7 @@ struct PragmaDatabaseSizeData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -94818,7 +94854,7 @@ struct PragmaFunctionsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaFunctionsBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -94954,7 +94990,7 @@ struct PragmaStorageOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, vector<Value> &inputs,
-                                                      unordered_map<string, Value> &named_parameters,
+                                                      named_parameter_map_t &named_parameters,
                                                       vector<LogicalType> &input_table_types,
                                                       vector<string> &input_table_names,
                                                       vector<LogicalType> &return_types, vector<string> &names) {
@@ -95081,7 +95117,7 @@ struct PragmaTableOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -95401,7 +95437,7 @@ static vector<TestType> GetTestTypes() {
 }
 
 static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -95961,7 +95997,7 @@ struct UnnestOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> UnnestBind(ClientContext &context, vector<Value> &inputs,
-                                           unordered_map<string, Value> &named_parameters,
+                                           named_parameter_map_t &named_parameters,
                                            vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                            vector<LogicalType> &return_types, vector<string> &names) {
 	return_types.push_back(ListType::GetChildType(inputs[0].type()));
@@ -96006,7 +96042,7 @@ struct PragmaVersionData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaVersionBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -98748,7 +98784,7 @@ vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(const string &qu
 }
 
 vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientContextLock &lock, const string &query) {
-	Parser parser;
+	Parser parser(GetParserOptions());
 	parser.ParseQuery(query);
 
 	PragmaHandler handler(*this);
@@ -99485,6 +99521,12 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result)
 	return true;
 }
 
+ParserOptions ClientContext::GetParserOptions() {
+	ParserOptions options;
+	options.preserve_identifier_case = ClientConfig::GetConfig(*this).preserve_identifier_case;
+	return options;
+}
+
 } // namespace duckdb
 
 
@@ -99678,6 +99720,15 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PreserveIdentifierCase {
+	static constexpr const char *Name = "preserve_identifier_case";
+	static constexpr const char *Description =
+	    "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ProfilerHistorySize {
 	static constexpr const char *Name = "profiler_history_size";
 	static constexpr const char *Description = "Sets the profiler history size";
@@ -99789,6 +99840,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
                                                  DUCKDB_LOCAL(PerfectHashThresholdSetting),
+                                                 DUCKDB_LOCAL(PreserveIdentifierCase),
                                                  DUCKDB_LOCAL(ProfilerHistorySize),
                                                  DUCKDB_LOCAL(ProfileOutputSetting),
                                                  DUCKDB_LOCAL(ProfilingModeSetting),
@@ -99828,8 +99880,10 @@ ConfigurationOption *DBConfig::GetOptionByIndex(idx_t target_index) {
 }
 
 ConfigurationOption *DBConfig::GetOptionByName(const string &name) {
+	auto lname = StringUtil::Lower(name);
 	for (idx_t index = 0; internal_options[index].name; index++) {
-		if (internal_options[index].name == name) {
+		D_ASSERT(StringUtil::Lower(internal_options[index].name) == string(internal_options[index].name));
+		if (internal_options[index].name == lname) {
 			return internal_options + index;
 		}
 	}
@@ -100032,15 +100086,14 @@ namespace duckdb {
 class TableFunctionRelation : public Relation {
 public:
 	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
-	                      unordered_map<string, Value> named_parameters,
-	                      shared_ptr<Relation> input_relation_p = nullptr);
+	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr);
 
 	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr);
 
 	string name;
 	vector<Value> parameters;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> input_relation;
 
@@ -100317,12 +100370,12 @@ shared_ptr<Relation> Connection::View(const string &schema_name, const string &t
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 	vector<Value> values;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	return TableFunction(fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
-                                               const unordered_map<string, Value> &named_parameters) {
+                                               const named_parameter_map_t &named_parameters) {
 	return make_shared<TableFunctionRelation>(*context, fname, values, named_parameters);
 }
 
@@ -100365,7 +100418,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 	// parse columns
 	vector<ColumnDefinition> column_list;
 	for (auto &column : columns) {
-		auto col_list = Parser::ParseColumnList(column);
+		auto col_list = Parser::ParseColumnList(column, context->GetParserOptions());
 		if (col_list.size() != 1) {
 			throw ParserException("Expected a single column definition");
 		}
@@ -110909,7 +110962,7 @@ QueryRelation::QueryRelation(ClientContext &context, string query, string alias)
 }
 
 unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
-	Parser parser;
+	Parser parser(context.GetParserOptions());
 	parser.ParseQuery(query);
 	if (parser.statements.size() != 1) {
 		throw ParserException("Expected a single SELECT statement");
@@ -111174,7 +111227,7 @@ string SubqueryRelation::ToString(idx_t depth) {
 namespace duckdb {
 
 TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
-                                             unordered_map<string, Value> named_parameters,
+                                             named_parameter_map_t named_parameters,
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
@@ -111291,6 +111344,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 TableRelation::TableRelation(ClientContext &context, unique_ptr<TableDescription> description)
@@ -111323,9 +111377,9 @@ string TableRelation::ToString(idx_t depth) {
 	return RenderWhitespace(depth) + "Scan Table [" + description->table + "]";
 }
 
-static unique_ptr<ParsedExpression> ParseCondition(const string &condition) {
+static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const string &condition) {
 	if (!condition.empty()) {
-		auto expression_list = Parser::ParseExpressionList(condition);
+		auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
 		if (expression_list.size() != 1) {
 			throw ParserException("Expected a single expression as filter condition");
 		}
@@ -111338,15 +111392,15 @@ static unique_ptr<ParsedExpression> ParseCondition(const string &condition) {
 void TableRelation::Update(const string &update_list, const string &condition) {
 	vector<string> update_columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions);
+	auto cond = ParseCondition(context, condition);
+	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetParserOptions());
 	auto update = make_shared<UpdateRelation>(context, move(cond), description->schema, description->table,
 	                                          move(update_columns), move(expressions));
 	update->Execute();
 }
 
 void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(condition);
+	auto cond = ParseCondition(context, condition);
 	auto del = make_shared<DeleteRelation>(context, move(cond), description->schema, description->table);
 	del->Execute();
 }
@@ -111459,7 +111513,7 @@ ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>>
 
 ValueRelation::ValueRelation(ClientContext &context, const string &values_list, vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list);
+	this->expressions = Parser::ParseValuesList(values_list, context.GetParserOptions());
 	context.TryBindRelation(*this, this->columns);
 }
 
@@ -111694,7 +111748,7 @@ shared_ptr<Relation> Relation::Project(const string &expression, const string &a
 }
 
 shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list);
+	auto expressions = Parser::ParseExpressionList(select_list, context.GetParserOptions());
 	return make_shared<ProjectionRelation>(shared_from_this(), move(expressions), aliases);
 }
 
@@ -111703,13 +111757,14 @@ shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
 	return Project(expressions, aliases);
 }
 
-static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(const vector<string> &expressions) {
+static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
+                                                                       const vector<string> &expressions) {
 	if (expressions.empty()) {
 		throw ParserException("Zero expressions provided");
 	}
 	vector<unique_ptr<ParsedExpression>> result_list;
 	for (auto &expr : expressions) {
-		auto expression_list = Parser::ParseExpressionList(expr);
+		auto expression_list = Parser::ParseExpressionList(expr, context.GetParserOptions());
 		if (expression_list.size() != 1) {
 			throw ParserException("Expected a single expression in the expression list");
 		}
@@ -111719,12 +111774,12 @@ static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(const vec
 }
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(expressions);
+	auto result_list = StringListToExpressionList(context, expressions);
 	return make_shared<ProjectionRelation>(shared_from_this(), move(result_list), aliases);
 }
 
 shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression);
+	auto expression_list = Parser::ParseExpressionList(expression, context.GetParserOptions());
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
@@ -111733,7 +111788,7 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(expressions);
+	auto expression_list = StringListToExpressionList(context, expressions);
 	D_ASSERT(!expression_list.empty());
 
 	auto expr = move(expression_list[0]);
@@ -111749,7 +111804,7 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 }
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression);
+	auto order_list = Parser::ParseOrderList(expression, context.GetParserOptions());
 	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
 }
 
@@ -111759,7 +111814,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 	}
 	vector<OrderByNode> order_list;
 	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression);
+		auto inner_list = Parser::ParseOrderList(expression, context.GetParserOptions());
 		if (inner_list.size() != 1) {
 			throw ParserException("Expected a single ORDER BY expression in the expression list");
 		}
@@ -111769,7 +111824,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
-	auto expression_list = Parser::ParseExpressionList(condition);
+	auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
 	D_ASSERT(!expression_list.empty());
 
 	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
@@ -111813,24 +111868,24 @@ shared_ptr<Relation> Relation::Alias(const string &alias) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list);
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list);
-	auto groups = Parser::ParseExpressionList(group_list);
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
+	auto groups = Parser::ParseExpressionList(group_list, context.GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list), move(groups));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(aggregates);
+	auto aggregate_list = StringListToExpressionList(context, aggregates);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(aggregates);
-	auto group_list = StringListToExpressionList(groups);
+	auto aggregate_list = StringListToExpressionList(context, aggregates);
+	auto group_list = StringListToExpressionList(context, groups);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list), move(group_list));
 }
 
@@ -111924,7 +111979,7 @@ void Relation::Delete(const string &condition) {
 }
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
-                                             const unordered_map<string, Value> &named_parameters) {
+                                             const named_parameter_map_t &named_parameters) {
 	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters, shared_from_this());
 }
 
@@ -111980,6 +112035,7 @@ string Relation::RenderWhitespace(idx_t depth) {
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -112377,6 +112433,17 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
 }
 
+//===--------------------------------------------------------------------===//
+// PreserveIdentifierCase
+//===--------------------------------------------------------------------===//
+void PreserveIdentifierCase::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).preserve_identifier_case = input.GetValue<bool>();
+}
+
+Value PreserveIdentifierCase::GetSetting(ClientContext &context) {
+	return Value::BOOLEAN(ClientConfig::GetConfig(context).preserve_identifier_case);
+}
+
 //===--------------------------------------------------------------------===//
 // Profiler History Size
 //===--------------------------------------------------------------------===//
@@ -127776,6 +127843,7 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 
 
 
+
 namespace duckdb {
 
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
@@ -127825,13 +127893,24 @@ string ColumnRefExpression::ToString() const {
 }
 
 bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
-	return a->column_names == b->column_names;
+	if (a->column_names.size() != b->column_names.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < a->column_names.size(); i++) {
+		auto lcase_a = StringUtil::Lower(a->column_names[i]);
+		auto lcase_b = StringUtil::Lower(b->column_names[i]);
+		if (lcase_a != lcase_b) {
+			return false;
+		}
+	}
+	return true;
 }
 
 hash_t ColumnRefExpression::Hash() const {
 	hash_t result = ParsedExpression::Hash();
 	for (auto &column_name : column_names) {
-		result = CombineHash(result, duckdb::Hash<const char *>(column_name.c_str()));
+		auto lcase = StringUtil::Lower(column_name);
+		result = CombineHash(result, duckdb::Hash<const char *>(lcase.c_str()));
 	}
 	return result;
 }
@@ -135054,7 +135133,10 @@ public:
 
 	static bool IsKeyword(const std::string &text);
 	static std::vector<duckdb_libpgquery::PGKeyword> KeywordList();
+
+	static void SetPreserveIdentifierCase(bool downcase);
 };
+
 }
 
 
@@ -135115,12 +135197,13 @@ PGTypeName *SystemTypeName(const char *name);
 
 namespace duckdb {
 
-Parser::Parser() {
+Parser::Parser(ParserOptions options_p) : options(options_p) {
 }
 
 void Parser::ParseQuery(const string &query) {
 	Transformer transformer;
 	{
+		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
 		PostgresParser parser;
 		parser.Parse(query);
 
@@ -135216,11 +135299,11 @@ vector<ParserKeyword> Parser::KeywordList() {
 	return result;
 }
 
-vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list) {
+vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list, ParserOptions options) {
 	// construct a mock query prefixed with SELECT
 	string mock_query = "SELECT " + select_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135234,11 +135317,11 @@ vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &s
 	return move(select_node.select_list);
 }
 
-vector<OrderByNode> Parser::ParseOrderList(const string &select_list) {
+vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "SELECT * FROM tbl ORDER BY " + select_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135258,11 +135341,11 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list) {
 }
 
 void Parser::ParseUpdateList(const string &update_list, vector<string> &update_columns,
-                             vector<unique_ptr<ParsedExpression>> &expressions) {
+                             vector<unique_ptr<ParsedExpression>> &expressions, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "UPDATE tbl SET " + update_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
@@ -135273,11 +135356,11 @@ void Parser::ParseUpdateList(const string &update_list, vector<string> &update_c
 	expressions = move(update.expressions);
 }
 
-vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list) {
+vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "VALUES " + value_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135295,9 +135378,9 @@ vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const strin
 	return move(values_list.values);
 }
 
-vector<ColumnDefinition> Parser::ParseColumnList(const string &column_list) {
+vector<ColumnDefinition> Parser::ParseColumnList(const string &column_list, ParserOptions options) {
 	string mock_query = "CREATE TABLE blabla (" + column_list + ")";
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
 		throw ParserException("Expected a single CREATE statement");
@@ -142133,7 +142216,7 @@ class BoundSelectNode;
 
 struct BoundGroupInformation {
 	expression_map_t<idx_t> map;
-	unordered_map<string, idx_t> alias_map;
+	case_insensitive_map_t<idx_t> alias_map;
 };
 
 //! The SELECT binder is responsible for binding an expression within the SELECT clause of a SQL statement
@@ -142919,6 +143002,7 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 	} else {
 		collation = collation_p;
 	}
+	collation = StringUtil::Lower(collation);
 	// bind the collation
 	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
 		// binary collation: just skip
@@ -143997,14 +144081,14 @@ class ColumnRefExpression;
 //! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
 class ColumnAliasBinder {
 public:
-	ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map);
+	ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map);
 
 	BindResult BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
 	                     bool root_expression);
 
 private:
 	BoundSelectNode &node;
-	const unordered_map<string, idx_t> &alias_map;
+	const case_insensitive_map_t<idx_t> &alias_map;
 	bool in_alias;
 };
 
@@ -144053,7 +144137,6 @@ protected:
 
 
 
-
 namespace duckdb {
 class ConstantExpression;
 class ColumnRefExpression;
@@ -144062,7 +144145,7 @@ class ColumnRefExpression;
 class GroupBinder : public ExpressionBinder {
 public:
 	GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-	            unordered_map<string, idx_t> &alias_map, unordered_map<string, idx_t> &group_alias_map);
+	            case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map);
 
 	//! The unbound root expression
 	unique_ptr<ParsedExpression> unbound_expression;
@@ -144079,8 +144162,8 @@ protected:
 	BindResult BindConstant(ConstantExpression &expr);
 
 	SelectNode &node;
-	unordered_map<string, idx_t> &alias_map;
-	unordered_map<string, idx_t> &group_alias_map;
+	case_insensitive_map_t<idx_t> &alias_map;
+	case_insensitive_map_t<idx_t> &group_alias_map;
 	unordered_set<idx_t> used_aliases;
 
 	idx_t group_index;
@@ -144107,7 +144190,7 @@ namespace duckdb {
 class HavingBinder : public SelectBinder {
 public:
 	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             unordered_map<string, idx_t> &alias_map);
+	             case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -144140,7 +144223,7 @@ namespace duckdb {
 class QualifyBinder : public SelectBinder {
 public:
 	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	              unordered_map<string, idx_t> &alias_map);
+	              case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -144177,10 +144260,10 @@ class SelectNode;
 //! The ORDER binder is responsible for binding an expression within the ORDER BY clause of a SQL statement
 class OrderBinder {
 public:
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, unordered_map<string, idx_t> &alias_map,
+	OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
 	            expression_map_t<idx_t> &projection_map, idx_t max_count);
 	OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-	            unordered_map<string, idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
+	            case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
@@ -144197,7 +144280,7 @@ private:
 	idx_t projection_index;
 	idx_t max_count;
 	vector<unique_ptr<ParsedExpression>> *extra_list;
-	unordered_map<string, idx_t> &alias_map;
+	case_insensitive_map_t<idx_t> &alias_map;
 	expression_map_t<idx_t> &projection_map;
 };
 
@@ -144441,7 +144524,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	statement.select_list = move(new_select_list);
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
-	unordered_map<string, idx_t> alias_map;
+	case_insensitive_map_t<idx_t> alias_map;
 	expression_map_t<idx_t> projection_map;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
@@ -144635,7 +144718,7 @@ public:
 
 namespace duckdb {
 
-static void GatherAliases(BoundQueryNode &node, unordered_map<string, idx_t> &aliases,
+static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
                           expression_map_t<idx_t> &expressions) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
@@ -144705,7 +144788,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced in
 		// the ORDER BY
-		unordered_map<string, idx_t> alias_map;
+		case_insensitive_map_t<idx_t> alias_map;
 		expression_map_t<idx_t> expression_map;
 		GatherAliases(*result, alias_map, expression_map);
 
@@ -146585,7 +146668,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		// insertion statement specifies column list
 
 		// create a mapping of (list index) -> (column index)
-		unordered_map<string, idx_t> column_name_map;
+		case_insensitive_map_t<idx_t> column_name_map;
 		for (idx_t i = 0; i < stmt.columns.size(); i++) {
 			column_name_map[stmt.columns[i]] = i;
 			auto entry = table->name_map.find(stmt.columns[i]);
@@ -147896,7 +147979,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 namespace duckdb {
 
-void Binder::BindNamedParameters(unordered_map<string, LogicalType> &types, unordered_map<string, Value> &values,
+void Binder::BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
                                  QueryErrorContext &error_context, string &func_name) {
 	for (auto &kv : values) {
 		auto entry = types.find(kv.first);
@@ -147973,7 +148056,7 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 namespace duckdb {
 
 bool Binder::BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-                                    vector<Value> &parameters, unordered_map<string, Value> &named_parameters,
+                                    vector<Value> &parameters, named_parameter_map_t &named_parameters,
                                     unique_ptr<BoundSubqueryRef> &subquery, string &error) {
 	bool seen_subquery = false;
 	for (auto &child : expressions) {
@@ -148037,7 +148120,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	// evaluate the input parameters to the function
 	vector<LogicalType> arguments;
 	vector<Value> parameters;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
 	if (!BindFunctionParameters(fexpr->children, arguments, parameters, named_parameters, subquery, error)) {
@@ -150004,7 +150087,7 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 
 namespace duckdb {
 
-ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map)
+ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map)
     : node(node), alias_map(alias_map), in_alias(false) {
 }
 
@@ -150068,7 +150151,7 @@ string ConstantBinder::UnsupportedAggregateMessage() {
 namespace duckdb {
 
 GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-                         unordered_map<string, idx_t> &alias_map, unordered_map<string, idx_t> &group_alias_map)
+                         case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map)
     : ExpressionBinder(binder, context), node(node), alias_map(alias_map), group_alias_map(group_alias_map),
       group_index(group_index) {
 }
@@ -150176,7 +150259,7 @@ BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
 namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                           unordered_map<string, idx_t> &alias_map)
+                           case_insensitive_map_t<idx_t> &alias_map)
     : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
@@ -150271,13 +150354,13 @@ string InsertBinder::UnsupportedAggregateMessage() {
 
 namespace duckdb {
 
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, unordered_map<string, idx_t> &alias_map,
+OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
                          expression_map_t<idx_t> &projection_map, idx_t max_count)
     : binders(move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
       alias_map(alias_map), projection_map(projection_map) {
 }
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         unordered_map<string, idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
+                         case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
     : binders(move(binders)), projection_index(projection_index), alias_map(alias_map), projection_map(projection_map) {
 	this->max_count = node.select_list.size();
 	this->extra_list = &node.select_list;
@@ -150375,7 +150458,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 namespace duckdb {
 
 QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                             unordered_map<string, idx_t> &alias_map)
+                             case_insensitive_map_t<idx_t> &alias_map)
     : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
@@ -152412,7 +152495,7 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 			if (!new_query.empty()) {
 				// this PRAGMA statement gets replaced by a new query string
 				// push the new query string through the parser again and add it to the transformer
-				Parser parser;
+				Parser parser(context.GetParserOptions());
 				parser.ParseQuery(new_query);
 				// insert the new statements and remove the old statement
 				// FIXME: off by one here maybe?
@@ -222201,6 +222284,45 @@ PGNode *newNode(size_t size, PGNodeTag type) {
 
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
+// See the end of this file for a list
+
+/*-------------------------------------------------------------------------
+ *
+ * scansup.h
+ *	  scanner support routines.  used by both the bootstrap lexer
+ * as well as the normal lexer
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scansup.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+
+namespace duckdb_libpgquery {
+
+char *scanstr(const char *s);
+
+char *downcase_truncate_identifier(const char *ident, int len, bool warn);
+
+char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
+
+bool scanner_isspace(char ch);
+
+void set_preserve_identifier_case(bool downcase);
+bool get_preserve_identifier_case();
+
+}
+
+// LICENSE_CHANGE_END
+
+
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
 // See the end of this file for a list
@@ -222281,6 +222403,10 @@ vector<duckdb_libpgquery::PGKeyword> PostgresParser::KeywordList() {
 	return duckdb_libpgquery::keyword_list();
 }
 
+void PostgresParser::SetPreserveIdentifierCase(bool preserve) {
+	duckdb_libpgquery::set_preserve_identifier_case(preserve);
+}
+
 }
 
 
@@ -251625,41 +251751,6 @@ int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner) {
 		/* only needed for GUC variables */
 
 
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * scansup.h
- *	  scanner support routines.  used by both the bootstrap lexer
- * as well as the normal lexer
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scansup.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-namespace duckdb_libpgquery {
-
-char *scanstr(const char *s);
-
-char *downcase_truncate_identifier(const char *ident, int len, bool warn);
-
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
-
-bool scanner_isspace(char ch);
-
-}
-
-// LICENSE_CHANGE_END
-
-
 
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
@@ -255819,6 +255910,16 @@ char *downcase_truncate_identifier(const char *ident, int len, bool warn) {
 	return downcase_identifier(ident, len, warn, true);
 }
 
+static __thread bool pg_preserve_identifier_case = false;
+
+void set_preserve_identifier_case(bool preserve) {
+	pg_preserve_identifier_case = preserve;
+}
+
+bool get_preserve_identifier_case() {
+	return pg_preserve_identifier_case;
+}
+
 /*
  * a workhorse for downcase_truncate_identifier
  */
@@ -255842,10 +255943,12 @@ char *downcase_identifier(const char *ident, int len, bool warn, bool truncate)
 	for (i = 0; i < len; i++) {
 		unsigned char ch = (unsigned char)ident[i];
 
-		if (ch >= 'A' && ch <= 'Z')
-			ch += 'a' - 'A';
-		else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
-			ch = tolower(ch);
+		if (!get_preserve_identifier_case()) {
+			if (ch >= 'A' && ch <= 'Z')
+				ch += 'a' - 'A';
+			else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
+				ch = tolower(ch);
+		}
 		result[i] = (char)ch;
 	}
 	result[i] = '\0';