duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

package/src/duckdb/extension/json/json_functions/json_type.cpp

@@ -28,12 +28,11 @@ static void GetTypeFunctionsInternal(ScalarFunctionSet &set, const LogicalType &
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetTypeFunction() {
+ScalarFunctionSet JSONFunctions::GetTypeFunction() {
 	ScalarFunctionSet set("json_type");
 	GetTypeFunctionsInternal(set, LogicalType::VARCHAR);
 	GetTypeFunctionsInternal(set, JSONCommon::JSONType());
-
-	return CreateScalarFunctionInfo(std::move(set));
+	return set;
 }
 
 } // namespace duckdb

package/src/duckdb/extension/json/json_functions/json_valid.cpp

@@ -16,12 +16,12 @@ static void GetValidFunctionInternal(ScalarFunctionSet &set, const LogicalType &
 	                               nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetValidFunction() {
+ScalarFunctionSet JSONFunctions::GetValidFunction() {
 	ScalarFunctionSet set("json_valid");
 	GetValidFunctionInternal(set, LogicalType::VARCHAR);
 	GetValidFunctionInternal(set, JSONCommon::JSONType());
 
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 } // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -293,33 +293,33 @@ TableFunction JSONFunctions::GetReadJSONTableFunction(shared_ptr<JSONScanInfo> f
 	return table_function;
 }
 
-CreateTableFunctionInfo CreateJSONFunctionInfo(string name, shared_ptr<JSONScanInfo> info, bool auto_function = false) {
+TableFunctionSet CreateJSONFunctionInfo(string name, shared_ptr<JSONScanInfo> info, bool auto_function = false) {
 	auto table_function = JSONFunctions::GetReadJSONTableFunction(std::move(info));
 	table_function.name = std::move(name);
 	if (auto_function) {
 		table_function.named_parameters["maximum_depth"] = LogicalType::BIGINT;
 	}
-	return CreateTableFunctionInfo(MultiFileReader::CreateFunctionSet(table_function));
+	return MultiFileReader::CreateFunctionSet(table_function);
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadJSONFunction() {
+TableFunctionSet JSONFunctions::GetReadJSONFunction() {
 	auto info =
 	    make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::UNSTRUCTURED, JSONRecordType::RECORDS, false);
 	return CreateJSONFunctionInfo("read_json", std::move(info));
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadNDJSONFunction() {
+TableFunctionSet JSONFunctions::GetReadNDJSONFunction() {
 	auto info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::NEWLINE_DELIMITED,
 	                                      JSONRecordType::RECORDS, false);
 	return CreateJSONFunctionInfo("read_ndjson", std::move(info));
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadJSONAutoFunction() {
+TableFunctionSet JSONFunctions::GetReadJSONAutoFunction() {
 	auto info = make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::AUTO_DETECT, JSONRecordType::AUTO, true);
 	return CreateJSONFunctionInfo("read_json_auto", std::move(info), true);
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadNDJSONAutoFunction() {
+TableFunctionSet JSONFunctions::GetReadNDJSONAutoFunction() {
 	auto info =
 	    make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::NEWLINE_DELIMITED, JSONRecordType::AUTO, true);
 	return CreateJSONFunctionInfo("read_ndjson_auto", std::move(info), true);

package/src/duckdb/extension/json/json_functions/read_json_objects.cpp

@@ -46,22 +46,22 @@ TableFunction GetReadJSONObjectsTableFunction(bool list_parameter, shared_ptr<JS
 	return table_function;
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadJSONObjectsFunction() {
+TableFunctionSet JSONFunctions::GetReadJSONObjectsFunction() {
 	TableFunctionSet function_set("read_json_objects");
 	auto function_info =
 	    make_shared<JSONScanInfo>(JSONScanType::READ_JSON_OBJECTS, JSONFormat::UNSTRUCTURED, JSONRecordType::JSON);
 	function_set.AddFunction(GetReadJSONObjectsTableFunction(false, function_info));
 	function_set.AddFunction(GetReadJSONObjectsTableFunction(true, function_info));
-	return CreateTableFunctionInfo(function_set);
+	return function_set;
 }
 
-CreateTableFunctionInfo JSONFunctions::GetReadNDJSONObjectsFunction() {
+TableFunctionSet JSONFunctions::GetReadNDJSONObjectsFunction() {
 	TableFunctionSet function_set("read_ndjson_objects");
 	auto function_info =
 	    make_shared<JSONScanInfo>(JSONScanType::READ_JSON_OBJECTS, JSONFormat::NEWLINE_DELIMITED, JSONRecordType::JSON);
 	function_set.AddFunction(GetReadJSONObjectsTableFunction(false, function_info));
 	function_set.AddFunction(GetReadJSONObjectsTableFunction(true, function_info));
-	return CreateTableFunctionInfo(function_set);
+	return function_set;
 }
 
 } // namespace duckdb

package/src/duckdb/extension/json/json_functions.cpp

@@ -121,8 +121,8 @@ JSONFunctionLocalState &JSONFunctionLocalState::ResetAndGet(ExpressionState &sta
 	return lstate;
 }
 
-vector<CreateScalarFunctionInfo> JSONFunctions::GetScalarFunctions() {
-	vector<CreateScalarFunctionInfo> functions;
+vector<ScalarFunctionSet> JSONFunctions::GetScalarFunctions() {
+	vector<ScalarFunctionSet> functions;
 
 	// Extract functions
 	AddAliases({"json_extract", "json_extract_path"}, GetExtractFunction(), functions);
@@ -153,14 +153,14 @@ vector<CreateScalarFunctionInfo> JSONFunctions::GetScalarFunctions() {
 	return functions;
 }
 
-vector<CreatePragmaFunctionInfo> JSONFunctions::GetPragmaFunctions() {
-	vector<CreatePragmaFunctionInfo> functions;
+vector<PragmaFunctionSet> JSONFunctions::GetPragmaFunctions() {
+	vector<PragmaFunctionSet> functions;
 	functions.push_back(GetExecuteJsonSerializedSqlPragmaFunction());
 	return functions;
 }
 
-vector<CreateTableFunctionInfo> JSONFunctions::GetTableFunctions() {
-	vector<CreateTableFunctionInfo> functions;
+vector<TableFunctionSet> JSONFunctions::GetTableFunctions() {
+	vector<TableFunctionSet> functions;
 
 	// Reads JSON as string
 	functions.push_back(GetReadJSONObjectsFunction());

package/src/duckdb/extension/parquet/parquet-extension.cpp

@@ -34,6 +34,7 @@
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/storage/table/row_group.hpp"
+#include "duckdb/main/extension_util.hpp"
 #endif
 
 namespace duckdb {
@@ -368,7 +369,8 @@ public:
 				continue;
 			}
 			MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options, bind_data.reader_bind,
-			                                  bind_data.types, bind_data.names, input.column_ids, input.filters);
+			                                  bind_data.types, bind_data.names, input.column_ids, input.filters,
+			                                  bind_data.files[0]);
 		}
 
 		result->column_ids = input.column_ids;
@@ -560,9 +562,9 @@ public:
 				shared_ptr<ParquetReader> reader;
 				try {
 					reader = make_shared<ParquetReader>(context, file, pq_options);
-					MultiFileReader::InitializeReader(*reader, bind_data.parquet_options.file_options,
-					                                  bind_data.reader_bind, bind_data.types, bind_data.names,
-					                                  parallel_state.column_ids, parallel_state.filters);
+					MultiFileReader::InitializeReader(
+					    *reader, bind_data.parquet_options.file_options, bind_data.reader_bind, bind_data.types,
+					    bind_data.names, parallel_state.column_ids, parallel_state.filters, bind_data.files.front());
 				} catch (...) {
 					parallel_lock.lock();
 					parallel_state.error_opening_file = true;
@@ -687,20 +689,23 @@ unique_ptr<TableRef> ParquetScanReplacement(ClientContext &context, const string
 }
 
 void ParquetExtension::Load(DuckDB &db) {
+	auto &db_instance = *db.instance;
 	auto &fs = db.GetFileSystem();
 	fs.RegisterSubSystem(FileCompressionType::ZSTD, make_uniq<ZStdFileSystem>());
 
 	auto scan_fun = ParquetScanFunction::GetFunctionSet();
-	CreateTableFunctionInfo cinfo(scan_fun);
-	cinfo.name = "read_parquet";
-	CreateTableFunctionInfo pq_scan = cinfo;
-	pq_scan.name = "parquet_scan";
+	scan_fun.name = "read_parquet";
+	ExtensionUtil::RegisterFunction(db_instance, scan_fun);
+	scan_fun.name = "parquet_scan";
+	ExtensionUtil::RegisterFunction(db_instance, scan_fun);
 
+	// parquet_metadata
 	ParquetMetaDataFunction meta_fun;
-	CreateTableFunctionInfo meta_cinfo(MultiFileReader::CreateFunctionSet(meta_fun));
+	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(meta_fun));
 
+	// parquet_schema
 	ParquetSchemaFunction schema_fun;
-	CreateTableFunctionInfo schema_cinfo(MultiFileReader::CreateFunctionSet(schema_fun));
+	ExtensionUtil::RegisterFunction(db_instance, MultiFileReader::CreateFunctionSet(schema_fun));
 
 	CopyFunction function("parquet");
 	function.copy_to_bind = ParquetWriteBind;
@@ -714,24 +719,7 @@ void ParquetExtension::Load(DuckDB &db) {
 	function.copy_from_function = scan_fun.functions[0];
 
 	function.extension = "parquet";
-	CreateCopyFunctionInfo info(function);
-
-	Connection con(db);
-	con.BeginTransaction();
-	auto &context = *con.context;
-	auto &catalog = Catalog::GetSystemCatalog(context);
-
-	if (catalog.GetEntry<TableFunctionCatalogEntry>(context, DEFAULT_SCHEMA, "parquet_scan",
-	                                                OnEntryNotFound::RETURN_NULL)) {
-		throw InvalidInputException("Parquet extension is either already loaded or built-in");
-	}
-
-	catalog.CreateCopyFunction(context, info);
-	catalog.CreateTableFunction(context, cinfo);
-	catalog.CreateTableFunction(context, pq_scan);
-	catalog.CreateTableFunction(context, meta_cinfo);
-	catalog.CreateTableFunction(context, schema_cinfo);
-	con.Commit();
+	ExtensionUtil::RegisterFunction(db_instance, function);
 
 	auto &config = DBConfig::GetConfig(*db.instance);
 	config.replacement_scans.emplace_back(ParquetScanReplacement);

package/src/duckdb/src/catalog/catalog_entry/pragma_function_catalog_entry.cpp

@@ -5,8 +5,7 @@ namespace duckdb {
 
 PragmaFunctionCatalogEntry::PragmaFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
                                                        CreatePragmaFunctionInfo &info)
-    : StandardEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, schema, catalog, info.name),
-      functions(std::move(info.functions)) {
+    : FunctionEntry(CatalogType::PRAGMA_FUNCTION_ENTRY, catalog, schema, info), functions(std::move(info.functions)) {
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp

@@ -5,7 +5,7 @@ namespace duckdb {
 
 ScalarFunctionCatalogEntry::ScalarFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
                                                        CreateScalarFunctionInfo &info)
-    : StandardEntry(CatalogType::SCALAR_FUNCTION_ENTRY, schema, catalog, info.name), functions(info.functions) {
+    : FunctionEntry(CatalogType::SCALAR_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
 }
 
 unique_ptr<CatalogEntry> ScalarFunctionCatalogEntry::AlterEntry(ClientContext &context, AlterInfo &info) {

package/src/duckdb/src/catalog/catalog_entry/scalar_macro_catalog_entry.cpp

@@ -7,9 +7,9 @@
 namespace duckdb {
 
 MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
-    : StandardEntry(
+    : FunctionEntry(
           (info.function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
-          schema, catalog, info.name),
+          catalog, schema, info),
       function(std::move(info.function)) {
 	this->temporary = info.temporary;
 	this->internal = info.internal;

package/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp

@@ -5,8 +5,7 @@ namespace duckdb {
 
 TableFunctionCatalogEntry::TableFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema,
                                                      CreateTableFunctionInfo &info)
-    : StandardEntry(CatalogType::TABLE_FUNCTION_ENTRY, schema, catalog, info.name),
-      functions(std::move(info.functions)) {
+    : FunctionEntry(CatalogType::TABLE_FUNCTION_ENTRY, catalog, schema, info), functions(std::move(info.functions)) {
 	D_ASSERT(this->functions.Size() > 0);
 }
 

package/src/duckdb/src/catalog/catalog_transaction.cpp

@@ -31,4 +31,8 @@ ClientContext &CatalogTransaction::GetContext() {
 	return *context;
 }
 
+CatalogTransaction CatalogTransaction::GetSystemTransaction(DatabaseInstance &db) {
+	return CatalogTransaction(db, 1, 1);
+}
+
 } // namespace duckdb

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -7,6 +7,9 @@
 #include "duckdb/catalog/default/default_schemas.hpp"
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/main/attached_database.hpp"
+#ifndef DISABLE_CORE_FUNCTIONS_EXTENSION
+#include "duckdb/core_functions/core_functions.hpp"
+#endif
 
 namespace duckdb {
 
@@ -22,7 +25,7 @@ void DuckCatalog::Initialize(bool load_builtin) {
 	// first initialize the base system catalogs
 	// these are never written to the WAL
 	// we start these at 1 because deleted entries default to 0
-	CatalogTransaction data(GetDatabase(), 1, 1);
+	auto data = CatalogTransaction::GetSystemTransaction(GetDatabase());
 
 	// create the default schema
 	CreateSchemaInfo info;
@@ -34,6 +37,10 @@ void DuckCatalog::Initialize(bool load_builtin) {
 		// initialize default functions
 		BuiltinFunctions builtin(data, *this);
 		builtin.Initialize();
+
+#ifndef DISABLE_CORE_FUNCTIONS_EXTENSION
+		CoreFunctions::RegisterFunctions(*this, data);
+#endif
 	}
 
 	Verify();

package/src/duckdb/src/common/enums/date_part_specifier.cpp

@@ -0,0 +1,82 @@
+#include "duckdb/common/enums/date_part_specifier.hpp"
+#include "duckdb/common/string_util.hpp"
+
+namespace duckdb {
+
+bool TryGetDatePartSpecifier(const string &specifier_p, DatePartSpecifier &result) {
+	auto specifier = StringUtil::Lower(specifier_p);
+	if (specifier == "year" || specifier == "yr" || specifier == "y" || specifier == "years" || specifier == "yrs") {
+		result = DatePartSpecifier::YEAR;
+	} else if (specifier == "month" || specifier == "mon" || specifier == "months" || specifier == "mons") {
+		result = DatePartSpecifier::MONTH;
+	} else if (specifier == "day" || specifier == "days" || specifier == "d" || specifier == "dayofmonth") {
+		result = DatePartSpecifier::DAY;
+	} else if (specifier == "decade" || specifier == "dec" || specifier == "decades" || specifier == "decs") {
+		result = DatePartSpecifier::DECADE;
+	} else if (specifier == "century" || specifier == "cent" || specifier == "centuries" || specifier == "c") {
+		result = DatePartSpecifier::CENTURY;
+	} else if (specifier == "millennium" || specifier == "mil" || specifier == "millenniums" ||
+	           specifier == "millennia" || specifier == "mils" || specifier == "millenium") {
+		result = DatePartSpecifier::MILLENNIUM;
+	} else if (specifier == "microseconds" || specifier == "microsecond" || specifier == "us" || specifier == "usec" ||
+	           specifier == "usecs" || specifier == "usecond" || specifier == "useconds") {
+		result = DatePartSpecifier::MICROSECONDS;
+	} else if (specifier == "milliseconds" || specifier == "millisecond" || specifier == "ms" || specifier == "msec" ||
+	           specifier == "msecs" || specifier == "msecond" || specifier == "mseconds") {
+		result = DatePartSpecifier::MILLISECONDS;
+	} else if (specifier == "second" || specifier == "sec" || specifier == "seconds" || specifier == "secs" ||
+	           specifier == "s") {
+		result = DatePartSpecifier::SECOND;
+	} else if (specifier == "minute" || specifier == "min" || specifier == "minutes" || specifier == "mins" ||
+	           specifier == "m") {
+		result = DatePartSpecifier::MINUTE;
+	} else if (specifier == "hour" || specifier == "hr" || specifier == "hours" || specifier == "hrs" ||
+	           specifier == "h") {
+		result = DatePartSpecifier::HOUR;
+	} else if (specifier == "epoch") {
+		// seconds since 1970-01-01
+		result = DatePartSpecifier::EPOCH;
+	} else if (specifier == "dow" || specifier == "dayofweek" || specifier == "weekday") {
+		// day of the week (Sunday = 0, Saturday = 6)
+		result = DatePartSpecifier::DOW;
+	} else if (specifier == "isodow") {
+		// isodow (Monday = 1, Sunday = 7)
+		result = DatePartSpecifier::ISODOW;
+	} else if (specifier == "week" || specifier == "weeks" || specifier == "w" || specifier == "weekofyear") {
+		// ISO week number
+		result = DatePartSpecifier::WEEK;
+	} else if (specifier == "doy" || specifier == "dayofyear") {
+		// day of the year (1-365/366)
+		result = DatePartSpecifier::DOY;
+	} else if (specifier == "quarter" || specifier == "quarters") {
+		// quarter of the year (1-4)
+		result = DatePartSpecifier::QUARTER;
+	} else if (specifier == "yearweek") {
+		// Combined isoyear and isoweek YYYYWW
+		result = DatePartSpecifier::YEARWEEK;
+	} else if (specifier == "isoyear") {
+		// ISO year (first week of the year may be in previous year)
+		result = DatePartSpecifier::ISOYEAR;
+	} else if (specifier == "era") {
+		result = DatePartSpecifier::ERA;
+	} else if (specifier == "timezone") {
+		result = DatePartSpecifier::TIMEZONE;
+	} else if (specifier == "timezone_hour") {
+		result = DatePartSpecifier::TIMEZONE_HOUR;
+	} else if (specifier == "timezone_minute") {
+		result = DatePartSpecifier::TIMEZONE_MINUTE;
+	} else {
+		return false;
+	}
+	return true;
+}
+
+DatePartSpecifier GetDatePartSpecifier(const string &specifier) {
+	DatePartSpecifier result;
+	if (!TryGetDatePartSpecifier(specifier, result)) {
+		throw ConversionException("extract specifier \"%s\" not recognized", specifier);
+	}
+	return result;
+}
+
+} // namespace duckdb

package/src/duckdb/src/common/local_file_system.cpp

@@ -977,7 +977,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 		throw IOException("Cannot use multiple \'**\' in one path");
 	}
 
-	bool recursive_search = false;
 	for (idx_t i = absolute_path ? 1 : 0; i < splits.size(); i++) {
 		bool is_last_chunk = i + 1 == splits.size();
 		bool has_glob = HasGlob(splits[i]);
@@ -989,7 +988,7 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			if (previous_directories.empty()) {
 				result.push_back(splits[i]);
 			} else {
-				if (recursive_search && is_last_chunk) {
+				if (is_last_chunk) {
 					for (auto &prev_directory : previous_directories) {
 						const string filename = JoinPath(prev_directory, splits[i]);
 						if (FileExists(filename) || DirectoryExists(filename)) {
@@ -1004,7 +1003,6 @@ vector<string> LocalFileSystem::Glob(const string &path, FileOpener *opener) {
 			}
 		} else {
 			if (IsCrawl(splits[i])) {
-				recursive_search = true;
 				if (!is_last_chunk) {
 					result = previous_directories;
 				}

package/src/duckdb/src/common/multi_file_reader.cpp

@@ -192,7 +192,7 @@ void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, c
 void MultiFileReader::CreateNameMapping(const string &file_name, const vector<LogicalType> &local_types,
                                         const vector<string> &local_names, const vector<LogicalType> &global_types,
                                         const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                        MultiFileReaderData &reader_data) {
+                                        MultiFileReaderData &reader_data, const string &initial_file) {
 	D_ASSERT(global_types.size() == global_names.size());
 	D_ASSERT(local_types.size() == local_names.size());
 	// we have expected types: create a map of name -> column index
@@ -229,11 +229,12 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 				}
 				candidate_names += local_name;
 			}
-			throw IOException(StringUtil::Format(
-			    "Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
-			    "the original file, but could not be found in file \"%s\".\nCandidate names: %s\nIf you are trying to "
-			    "read files with different schemas, try setting union_by_name=True",
-			    file_name, global_name, file_name, candidate_names));
+			throw IOException(
+			    StringUtil::Format("Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from "
+			                       "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: "
+			                       "%s\nIf you are trying to "
+			                       "read files with different schemas, try setting union_by_name=True",
+			                       file_name, global_name, initial_file, file_name, candidate_names));
 		}
 		// we found the column in the local file - check if the types are the same
 		auto local_id = entry->second;
@@ -254,8 +255,10 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector<Lo
 void MultiFileReader::CreateMapping(const string &file_name, const vector<LogicalType> &local_types,
                                     const vector<string> &local_names, const vector<LogicalType> &global_types,
                                     const vector<string> &global_names, const vector<column_t> &global_column_ids,
-                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data) {
-	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data);
+                                    optional_ptr<TableFilterSet> filters, MultiFileReaderData &reader_data,
+                                    const string &initial_file) {
+	CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data,
+	                  initial_file);
 	if (filters) {
 		reader_data.filter_map.resize(global_types.size());
 		for (idx_t c = 0; c < reader_data.column_mapping.size(); c++) {