duckdb 0.3.2-dev121.0 → 0.3.2-dev149.0

package/package.json

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

package/src/duckdb.cpp

@@ -20607,6 +20607,36 @@ private:
 #include <sys/types.h>
 #include <unistd.h>
 #else
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/windows_util.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+#ifdef DUCKDB_WINDOWS
+class WindowsUtil {
+public:
+	//! Windows helper functions
+	static std::wstring UTF8ToUnicode(const char *input);
+	static string UnicodeToUTF8(LPCWSTR input);
+	static string UTF8ToMBCS(const char *input, bool use_ansi = false);
+};
+#endif
+
+} // namespace duckdb
+
 #include <string>
 
 #ifdef __MINGW32__
@@ -21077,8 +21107,9 @@ unique_ptr<FileHandle> LocalFileSystem::OpenFile(const string &path, uint8_t fla
 	if (flags & FileFlags::FILE_FLAGS_DIRECT_IO) {
 		flags_and_attributes |= FILE_FLAG_NO_BUFFERING;
 	}
-	HANDLE hFile =
-	    CreateFileA(path.c_str(), desired_access, share_mode, NULL, creation_disposition, flags_and_attributes, NULL);
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str());
+	HANDLE hFile = CreateFileW(unicode_path.c_str(), desired_access, share_mode, NULL, creation_disposition,
+	                           flags_and_attributes, NULL);
 	if (hFile == INVALID_HANDLE_VALUE) {
 		auto error = GetLastErrorAsString();
 		throw IOException("Cannot open file \"%s\": %s", path.c_str(), error);
@@ -21228,13 +21259,18 @@ void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) {
 	}
 }
 
+static DWORD WindowsGetFileAttributes(const string &filename) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	return GetFileAttributesW(unicode_path.c_str());
+}
+
 bool LocalFileSystem::DirectoryExists(const string &directory) {
-	DWORD attrs = GetFileAttributesA(directory.c_str());
+	DWORD attrs = WindowsGetFileAttributes(directory);
 	return (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY));
 }
 
 bool LocalFileSystem::FileExists(const string &filename) {
-	DWORD attrs = GetFileAttributesA(filename.c_str());
+	DWORD attrs = WindowsGetFileAttributes(filename);
 	return (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY));
 }
 
@@ -21242,79 +21278,58 @@ void LocalFileSystem::CreateDirectory(const string &directory) {
 	if (DirectoryExists(directory)) {
 		return;
 	}
-	if (directory.empty() || !CreateDirectoryA(directory.c_str(), NULL) || !DirectoryExists(directory)) {
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(directory.c_str());
+	if (directory.empty() || !CreateDirectoryW(unicode_path.c_str(), NULL) || !DirectoryExists(directory)) {
 		throw IOException("Could not create directory!");
 	}
 }
 
-static void delete_dir_special_snowflake_windows(FileSystem &fs, string directory) {
-	if (directory.size() + 3 > MAX_PATH) {
-		throw IOException("Pathname too long");
-	}
-	// create search pattern
-	TCHAR szDir[MAX_PATH];
-	snprintf(szDir, MAX_PATH, "%s\\*", directory.c_str());
-
-	WIN32_FIND_DATA ffd;
-	HANDLE hFind = FindFirstFile(szDir, &ffd);
-	if (hFind == INVALID_HANDLE_VALUE) {
-		return;
-	}
-
-	do {
-		if (string(ffd.cFileName) == "." || string(ffd.cFileName) == "..") {
-			continue;
-		}
-		if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-			// recurse to zap directory contents
-			delete_dir_special_snowflake_windows(fs, fs.JoinPath(directory, ffd.cFileName));
+static void DeleteDirectoryRecursive(FileSystem &fs, string directory) {
+	fs.ListFiles(directory, [&](const string &fname, bool is_directory) {
+		if (is_directory) {
+			DeleteDirectoryRecursive(fs, fs.JoinPath(directory, fname));
 		} else {
-			if (strlen(ffd.cFileName) + directory.size() + 1 > MAX_PATH) {
-				throw IOException("Pathname too long");
-			}
-			// create search pattern
-			TCHAR del_path[MAX_PATH];
-			snprintf(del_path, MAX_PATH, "%s\\%s", directory.c_str(), ffd.cFileName);
-			if (!DeleteFileA(del_path)) {
-				throw IOException("Failed to delete directory entry");
-			}
+			fs.RemoveFile(fs.JoinPath(directory, fname));
 		}
-	} while (FindNextFile(hFind, &ffd) != 0);
-
-	DWORD dwError = GetLastError();
-	if (dwError != ERROR_NO_MORE_FILES) {
-		throw IOException("Something went wrong");
-	}
-	FindClose(hFind);
-
-	if (!RemoveDirectoryA(directory.c_str())) {
+	});
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(directory.c_str());
+	if (!RemoveDirectoryW(unicode_path.c_str())) {
 		throw IOException("Failed to delete directory");
 	}
 }
 
 void LocalFileSystem::RemoveDirectory(const string &directory) {
-	delete_dir_special_snowflake_windows(*this, directory.c_str());
+	if (FileExists(directory)) {
+		throw IOException("Attempting to delete directory \"%s\", but it is a file and not a directory!", directory);
+	}
+	if (!DirectoryExists(directory)) {
+		return;
+	}
+	DeleteDirectoryRecursive(*this, directory.c_str());
 }
 
 void LocalFileSystem::RemoveFile(const string &filename) {
-	DeleteFileA(filename.c_str());
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str());
+	DeleteFileW(unicode_path.c_str());
 }
 
 bool LocalFileSystem::ListFiles(const string &directory, const std::function<void(string, bool)> &callback) {
 	string search_dir = JoinPath(directory, "*");
 
-	WIN32_FIND_DATA ffd;
-	HANDLE hFind = FindFirstFile(search_dir.c_str(), &ffd);
+	auto unicode_path = WindowsUtil::UTF8ToUnicode(search_dir.c_str());
+
+	WIN32_FIND_DATAW ffd;
+	HANDLE hFind = FindFirstFileW(unicode_path.c_str(), &ffd);
 	if (hFind == INVALID_HANDLE_VALUE) {
 		return false;
 	}
 	do {
-		string cFileName = string(ffd.cFileName);
+		string cFileName = WindowsUtil::UnicodeToUTF8(ffd.cFileName);
 		if (cFileName == "." || cFileName == "..") {
 			continue;
 		}
 		callback(cFileName, ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
-	} while (FindNextFile(hFind, &ffd) != 0);
+	} while (FindNextFileW(hFind, &ffd) != 0);
 
 	DWORD dwError = GetLastError();
 	if (dwError != ERROR_NO_MORE_FILES) {
@@ -21334,7 +21349,9 @@ void LocalFileSystem::FileSync(FileHandle &handle) {
 }
 
 void LocalFileSystem::MoveFile(const string &source, const string &target) {
-	if (!MoveFileA(source.c_str(), target.c_str())) {
+	auto source_unicode = WindowsUtil::UTF8ToUnicode(source.c_str());
+	auto target_unicode = WindowsUtil::UTF8ToUnicode(target.c_str());
+	if (!MoveFileW(source_unicode.c_str(), target_unicode.c_str())) {
 		throw IOException("Could not move file");
 	}
 }
@@ -21345,7 +21362,7 @@ FileType LocalFileSystem::GetFileType(FileHandle &handle) {
 	if (strncmp(path.c_str(), PIPE_PREFIX, strlen(PIPE_PREFIX)) == 0) {
 		return FileType::FILE_TYPE_FIFO;
 	}
-	DWORD attrs = GetFileAttributesA(path.c_str());
+	DWORD attrs = WindowsGetFileAttributes(path.c_str());
 	if (attrs != INVALID_FILE_ATTRIBUTES) {
 		if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
 			return FileType::FILE_TYPE_DIR;
@@ -26256,13 +26273,29 @@ unique_ptr<FileHandle> PipeFileSystem::OpenPipe(unique_ptr<FileHandle> handle) {
 } // namespace duckdb
 
 
+
+
 #include <stdio.h>
 
+#ifndef DUCKDB_DISABLE_PRINT
+#ifdef DUCKDB_WINDOWS
+#include <io.h>
+#endif
+#endif
+
 namespace duckdb {
 
 // LCOV_EXCL_START
 void Printer::Print(const string &str) {
 #ifndef DUCKDB_DISABLE_PRINT
+#ifdef DUCKDB_WINDOWS
+	if (IsTerminal()) {
+		// print utf8 to terminal
+		auto unicode = WindowsUtil::UTF8ToMBCS(str.c_str());
+		fprintf(stderr, "%s\n", unicode.c_str());
+		return;
+	}
+#endif
 	fprintf(stderr, "%s\n", str.c_str());
 #endif
 }
@@ -26283,6 +26316,17 @@ void Printer::FinishProgressBarPrint(const char *pbstr, int pbwidth) {
 	fflush(stdout);
 #endif
 }
+
+bool Printer::IsTerminal() {
+#ifndef DUCKDB_DISABLE_PRINT
+#ifdef DUCKDB_WINDOWS
+	return GetFileType(stderr) == FILE_TYPE_CHAR;
+#else
+	throw InternalException("IsTerminal is only implemented for Windows");
+#endif
+#endif
+	return false;
+}
 // LCOV_EXCL_STOP
 
 } // namespace duckdb
@@ -32284,19 +32328,19 @@ struct TreeRendererConfig {
 	bool detailed = false;
 
 #ifndef DUCKDB_ASCII_TREE_RENDERER
-	const char *LTCORNER = "┌";
-	const char *RTCORNER = "┐";
-	const char *LDCORNER = "└";
-	const char *RDCORNER = "┘";
-
-	const char *MIDDLE = "┼";
-	const char *TMIDDLE = "┬";
-	const char *LMIDDLE = "├";
-	const char *RMIDDLE = "┤";
-	const char *DMIDDLE = "┴";
-
-	const char *VERTICAL = "│";
-	const char *HORIZONTAL = "─";
+	const char *LTCORNER = "\342\224\214"; // "┌";
+	const char *RTCORNER = "\342\224\220"; // "┐";
+	const char *LDCORNER = "\342\224\224"; // "└";
+	const char *RDCORNER = "\342\224\230"; // "┘";
+
+	const char *MIDDLE = "\342\224\274";  // "┼";
+	const char *TMIDDLE = "\342\224\254"; // "┬";
+	const char *LMIDDLE = "\342\224\234"; // "├";
+	const char *RMIDDLE = "\342\224\244"; // "┤";
+	const char *DMIDDLE = "\342\224\264"; // "┴";
+
+	const char *VERTICAL = "\342\224\202";   // "│";
+	const char *HORIZONTAL = "\342\224\200"; // "─";
 #else
 	// ASCII version
 	const char *LTCORNER = "<";
@@ -43059,6 +43103,7 @@ struct EnumTypeInfo : public ExtraTypeInfo {
 	TypeCatalogEntry *catalog_entry = nullptr;
 
 public:
+	// Equalities are only used in enums with different catalog entries
 	bool Equals(ExtraTypeInfo *other_p) override {
 		if (!other_p) {
 			return false;
@@ -43067,9 +43112,12 @@ public:
 			return false;
 		}
 		auto &other = (EnumTypeInfo &)*other_p;
-		return other.enum_name == enum_name && other.values_insert_order == values_insert_order;
+		// We must check if all elements are equal
+		if (other.values_insert_order == values_insert_order) {
+			return true;
+		}
+		return false;
 	}
-
 	void Serialize(Serializer &serializer) const override {
 		serializer.Write<uint32_t>(values_insert_order.size());
 		serializer.WriteString(enum_name);
@@ -47350,6 +47398,59 @@ unique_ptr<FileHandle> VirtualFileSystem::OpenFile(const string &path, uint8_t f
 } // namespace duckdb
 
 
+namespace duckdb {
+
+#ifdef DUCKDB_WINDOWS
+
+std::wstring WindowsUtil::UTF8ToUnicode(const char *input) {
+	idx_t result_size;
+
+	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, nullptr, 0);
+	if (result_size == 0) {
+		throw IOException("Failure in MultiByteToWideChar");
+	}
+	auto buffer = unique_ptr<wchar_t[]>(new wchar_t[result_size]);
+	result_size = MultiByteToWideChar(CP_UTF8, 0, input, -1, buffer.get(), result_size);
+	if (result_size == 0) {
+		throw IOException("Failure in MultiByteToWideChar");
+	}
+	return std::wstring(buffer.get(), result_size);
+}
+
+static string WideCharToMultiByteWrapper(LPCWSTR input, uint32_t code_page) {
+	idx_t result_size;
+
+	result_size = WideCharToMultiByte(code_page, 0, input, -1, 0, 0, 0, 0);
+	if (result_size == 0) {
+		throw IOException("Failure in WideCharToMultiByte");
+	}
+	auto buffer = unique_ptr<char[]>(new char[result_size]);
+	result_size = WideCharToMultiByte(code_page, 0, input, -1, buffer.get(), result_size, 0, 0);
+	if (result_size == 0) {
+		throw IOException("Failure in WideCharToMultiByte");
+	}
+	return string(buffer.get(), result_size - 1);
+}
+
+string WindowsUtil::UnicodeToUTF8(LPCWSTR input) {
+	return WideCharToMultiByteWrapper(input, CP_UTF8);
+}
+
+static string WindowsUnicodeToMBCS(LPCWSTR unicode_text, int use_ansi) {
+	uint32_t code_page = use_ansi ? CP_ACP : CP_OEMCP;
+	return WideCharToMultiByteWrapper(unicode_text, code_page);
+}
+
+string WindowsUtil::UTF8ToMBCS(const char *input, bool use_ansi) {
+	auto unicode = WindowsUtil::UTF8ToUnicode(input);
+	return WindowsUnicodeToMBCS(unicode.c_str(), use_ansi);
+}
+
+#endif
+
+} // namespace duckdb
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -68241,6 +68342,8 @@ public:
 		UNORDERED,
 		//! Only some entries have to be matched, the order of the matches does not matter
 		SOME,
+		//! Not initialized
+		INVALID
 	};
 
 	/* The double {{}} in the intializer for excluded_entries is intentional, workaround for bug in gcc-4.9 */
@@ -68500,7 +68603,8 @@ public:
 
 class ComparisonExpressionMatcher : public ExpressionMatcher {
 public:
-	ComparisonExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_COMPARISON) {
+	ComparisonExpressionMatcher()
+	    : ExpressionMatcher(ExpressionClass::BOUND_COMPARISON), policy(SetMatcher::Policy::INVALID) {
 	}
 	//! The matchers for the child expressions
 	vector<unique_ptr<ExpressionMatcher>> matchers;
@@ -68534,7 +68638,8 @@ public:
 
 class ConjunctionExpressionMatcher : public ExpressionMatcher {
 public:
-	ConjunctionExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CONJUNCTION) {
+	ConjunctionExpressionMatcher()
+	    : ExpressionMatcher(ExpressionClass::BOUND_CONJUNCTION), policy(SetMatcher::Policy::INVALID) {
 	}
 	//! The matchers for the child expressions
 	vector<unique_ptr<ExpressionMatcher>> matchers;
@@ -92550,6 +92655,7 @@ public:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 
 struct StructExtractBindData : public FunctionData {
@@ -92613,12 +92719,12 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 
 	if (key_child->return_type.id() != LogicalTypeId::VARCHAR ||
 	    key_child->return_type.id() != LogicalTypeId::VARCHAR || !key_child->IsFoldable()) {
-		throw Exception("Key name for struct_extract needs to be a constant string");
+		throw BinderException("Key name for struct_extract needs to be a constant string");
 	}
 	Value key_val = ExpressionExecutor::EvaluateScalar(*key_child.get());
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
 	if (key_val.is_null || key_val.str_value.length() < 1) {
-		throw Exception("Key name for struct_extract needs to be neither NULL nor empty");
+		throw BinderException("Key name for struct_extract needs to be neither NULL nor empty");
 	}
 	string key = StringUtil::Lower(key_val.str_value);
 
@@ -92628,15 +92734,23 @@ static unique_ptr<FunctionData> StructExtractBind(ClientContext &context, Scalar
 
 	for (size_t i = 0; i < struct_children.size(); i++) {
 		auto &child = struct_children[i];
-		if (child.first == key) {
+		if (StringUtil::Lower(child.first) == key) {
 			found_key = true;
 			key_index = i;
 			return_type = child.second;
 			break;
 		}
 	}
+
 	if (!found_key) {
-		throw Exception("Could not find key in struct");
+		vector<string> candidates;
+		candidates.reserve(struct_children.size());
+		for (auto &struct_child : struct_children) {
+			candidates.push_back(struct_child.first);
+		}
+		auto closest_settings = StringUtil::TopNLevenshtein(candidates, key);
+		auto message = StringUtil::CandidatesMessage(closest_settings, "Candidate Entries");
+		throw BinderException("Could not find key \"%s\" in struct\n%s", key, message);
 	}
 
 	bound_function.return_type = return_type;
@@ -92703,7 +92817,7 @@ static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &
 
 static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
-	unordered_set<string> name_collision_set;
+	case_insensitive_set_t name_collision_set;
 
 	// collect names and deconflict, construct return type
 	if (arguments.empty()) {
@@ -145903,7 +146017,7 @@ vector<ColumnBinding> LogicalOperator::MapBindings(const vector<ColumnBinding> &
 	}
 }
 
-string LogicalOperator::ToString(idx_t depth) const {
+string LogicalOperator::ToString() const {
 	TreeRenderer renderer;
 	return renderer.ToString(*this);
 }
@@ -242572,7 +242686,7 @@ namespace duckdb_libpgquery {
 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
+ * if you want the limit (max/min) macros for int types.
  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1
@@ -242590,7 +242704,7 @@ typedef uint64_t flex_uint64_t;
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
 typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
+typedef unsigned char flex_uint8_t;
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
 
@@ -242714,10 +242828,10 @@ typedef size_t yy_size_t;
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
-    
+
     #define YY_LESS_LINENO(n)
     #define YY_LINENO_REWIND_TO(ptr)
-    
+
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
 	do \
@@ -243627,9 +243741,9 @@ static int yy_init_globals ( yyscan_t yyscanner );
     /* This must go here because YYSTYPE and YYLTYPE are included
      * from bison output in section 1.*/
     #    define yylval yyg->yylval_r
-    
+
     #    define yylloc yyg->yylloc_r
-    
+
 int yylex_init (yyscan_t* scanner);
 
 int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
@@ -243672,9 +243786,9 @@ YYSTYPE * yyget_lval ( yyscan_t yyscanner );
 void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
 
        YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
-    
+
         void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
-    
+
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
@@ -243688,7 +243802,7 @@ extern int yywrap ( yyscan_t yyscanner );
 #endif
 
 #ifndef YY_NO_UNPUT
-    
+
 #endif
 
 #ifndef yytext_ptr
@@ -245386,7 +245500,7 @@ static void yy_load_buffer_state  (yyscan_t yyscanner)
     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
-    
+
 	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
@@ -245452,7 +245566,7 @@ static void yy_load_buffer_state  (yyscan_t yyscanner)
     }
 
         b->yy_is_interactive = 0;
-    
+
 	errno = oerrno;
 }
 
@@ -245594,7 +245708,7 @@ static void yyensure_buffer_stack (yyscan_t yyscanner)
 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
 {
 	YY_BUFFER_STATE b;
-    
+
 	if ( size < 2 ||
 	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
 	     base[size-1] != YY_END_OF_BUFFER_CHAR )
@@ -245630,7 +245744,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscann
  */
 YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)
 {
-    
+
 	return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);
 }
 
@@ -245647,7 +245761,7 @@ YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, yy_size_t  _yybytes_len ,
 	char *buf;
 	yy_size_t n;
 	yy_size_t i;
-    
+
 	/* Get memory for full buffer, including space for trailing EOB's. */
 	n = (yy_size_t) (_yybytes_len + 2);
 	buf = (char *) yyalloc( n , yyscanner );
@@ -245679,7 +245793,6 @@ static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)
 {
 	struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 	(void)yyg;
-	fprintf( stderr, "%s\n", msg );
 	throw std::runtime_error(msg); // YY_EXIT_FAILURE );
 }
 
@@ -245720,7 +245833,7 @@ int yyget_lineno  (yyscan_t yyscanner)
 
         if (! YY_CURRENT_BUFFER)
             return 0;
-    
+
     return yylineno;
 }
 
@@ -245733,7 +245846,7 @@ int yyget_column  (yyscan_t yyscanner)
 
         if (! YY_CURRENT_BUFFER)
             return 0;
-    
+
     return yycolumn;
 }
 
@@ -245795,7 +245908,7 @@ void yyset_lineno (int  _line_number , yyscan_t yyscanner)
         /* lineno is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
-    
+
     yylineno = _line_number;
 }
 
@@ -245810,7 +245923,7 @@ void yyset_column (int  _column_no , yyscan_t yyscanner)
         /* column is only valid if an input buffer exists. */
         if (! YY_CURRENT_BUFFER )
            YY_FATAL_ERROR( "yyset_column called with no buffer" );
-    
+
     yycolumn = _column_no;
 }
 
@@ -245863,13 +245976,13 @@ YYLTYPE *yyget_lloc  (yyscan_t yyscanner)
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     return yylloc;
 }
-    
+
 void yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
 {
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
     yylloc = yylloc_param;
 }
-    
+
 /* User-visible API */
 
 /* yylex_init is special because it creates the scanner itself, so it is
@@ -245949,13 +246062,8 @@ static int yy_init_globals (yyscan_t yyscanner)
     yyg->yy_start_stack =  NULL;
 
 /* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
     yyin = NULL;
     yyout = NULL;
-#endif
 
     /* For future reference: Set errno on error, since we are called by
      * yylex_init()

package/src/duckdb.hpp

@@ -10,8 +10,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #pragma once
 #define DUCKDB_AMALGAMATION 1
-#define DUCKDB_SOURCE_ID "3c9727ac2"
-#define DUCKDB_VERSION "0.3.2-dev121"
+#define DUCKDB_SOURCE_ID "76dcfb8ac"
+#define DUCKDB_VERSION "0.3.2-dev149"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -198,6 +198,12 @@ enum class ProfilerPrintFormat : uint8_t { NONE, QUERY_TREE, JSON, QUERY_TREE_OP
 #define suint64_t int64_t
 #endif
 
+#if defined(_WIN32) || defined(_WIN64)
+#define DUCKDB_WINDOWS
+#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
+#define DUCKDB_POSIX
+#endif
+
 namespace duckdb {
 #if !defined(_MSC_VER) && (__cplusplus < 201402L)
 template <typename T, typename... Args>
@@ -7983,7 +7989,7 @@ public:
 
 	virtual string GetName() const;
 	virtual string ParamsToString() const;
-	virtual string ToString(idx_t depth = 0) const;
+	virtual string ToString() const;
 	void Print();
 	//! Debug method: verify that the integrity of expressions & child nodes are maintained
 	virtual void Verify();
@@ -9470,6 +9476,8 @@ public:
 	static void PrintProgress(int percentage, const char *pbstr, int pbwidth);
 	//! Prints an empty line when progress bar is done
 	static void FinishProgressBarPrint(const char *pbstr, int pbwidth);
+	//! Whether or not we are printing to a terminal
+	static bool IsTerminal();
 };
 } // namespace duckdb