Merge a446ff5524 into b4504f20bf

[RFC] Hide Settings implementation

CMakeLists.txt

@@ -314,12 +314,12 @@ set (COMPILER_FLAGS "${COMPILER_FLAGS} -ffp-contract=off")
 set (DEBUG_INFO_FLAGS "-g")
 
 # Disable omit frame pointer compiler optimization using -fno-omit-frame-pointer
-option(DISABLE_OMIT_FRAME_POINTER "Disable omit frame pointer compiler optimization" OFF)
+option(DISABLE_OMIT_FRAME_POINTER "Disable omit frame pointer compiler optimization" ON)
 
 if (DISABLE_OMIT_FRAME_POINTER)
-    set (CMAKE_CXX_FLAGS_ADD "${CMAKE_CXX_FLAGS_ADD} -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer")
-    set (CMAKE_C_FLAGS_ADD "${CMAKE_C_FLAGS_ADD} -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer")
-    set (CMAKE_ASM_FLAGS_ADD "${CMAKE_ASM_FLAGS_ADD} -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer")
+    set (CMAKE_CXX_FLAGS_ADD "${CMAKE_CXX_FLAGS_ADD} -fno-omit-frame-pointer")
+    set (CMAKE_C_FLAGS_ADD "${CMAKE_C_FLAGS_ADD} -fno-omit-frame-pointer")
+    set (CMAKE_ASM_FLAGS_ADD "${CMAKE_ASM_FLAGS_ADD} -fno-omit-frame-pointer")
 endif()
 
 # Before you start hating your debugger because it refuses to show variables ('<optimized out>'), try building with -DDEBUG_O_LEVEL="0"

README.md

@@ -40,17 +40,8 @@ Every month we get together with the community (users, contributors, customers,
 
 Keep an eye out for upcoming meetups and events around the world. Somewhere else you want us to be? Please feel free to reach out to tyler `<at>` clickhouse `<dot>` com. You can also peruse [ClickHouse Events](https://clickhouse.com/company/news-events) for a list of all upcoming trainings, meetups, speaking engagements, etc.
 
-The following upcoming meetups are featuring creator of ClickHouse & CTO, Alexey Milovidov:
+Upcoming meetups
 
-* [Raleigh Meetup (Deutsche Bank)](https://www.meetup.com/triangletechtalks/events/302723486/) - September 9
-* [New York Meetup (Rokt)](https://www.meetup.com/clickhouse-new-york-user-group/events/302575342) - September 10
-* [Chicago Meetup (Jump Capital)](https://lu.ma/43tvmrfw) - September 12
-
-Other upcoming meetups
-
-* [Toronto Meetup (Shopify)](https://www.meetup.com/clickhouse-toronto-user-group/events/301490855/) - September 10
-* [Austin Meetup](https://www.meetup.com/clickhouse-austin-user-group/events/302558689/) - September 17
-* [London Meetup](https://www.meetup.com/clickhouse-london-user-group/events/302977267) - September 17
 * [Bangalore Meetup](https://www.meetup.com/clickhouse-bangalore-user-group/events/303208274/) - September 18
 * [Tel Aviv Meetup](https://www.meetup.com/clickhouse-meetup-israel/events/303095121) - September 22
 * [Jakarta Meetup](https://www.meetup.com/clickhouse-indonesia-user-group/events/303191359/) - October 1
@@ -62,13 +53,20 @@ Other upcoming meetups
 * [Dubai Meetup](https://www.meetup.com/clickhouse-dubai-meetup-group/events/303096989/) - November 21
 * [Paris Meetup](https://www.meetup.com/clickhouse-france-user-group/events/303096434) - November 26
 
-Recently completed events
+Recently completed meetups
+
 * [ClickHouse Guangzhou User Group Meetup](https://mp.weixin.qq.com/s/GSvo-7xUoVzCsuUvlLTpCw) - August 25
 * [Seattle Meetup (Statsig)](https://www.meetup.com/clickhouse-seattle-user-group/events/302518075/) - August 27
 * [Melbourne Meetup](https://www.meetup.com/clickhouse-australia-user-group/events/302732666/) - August 27
 * [Sydney Meetup](https://www.meetup.com/clickhouse-australia-user-group/events/302862966/) - September 5
 * [Zurich Meetup](https://www.meetup.com/clickhouse-switzerland-meetup-group/events/302267429/) - September 5
 * [San Francisco Meetup (Cloudflare)](https://www.meetup.com/clickhouse-silicon-valley-meetup-group/events/302540575) - September 5
+* [Raleigh Meetup (Deutsche Bank)](https://www.meetup.com/triangletechtalks/events/302723486/) - September 9
+* [New York Meetup (Rokt)](https://www.meetup.com/clickhouse-new-york-user-group/events/302575342) - September 10
+* [Toronto Meetup (Shopify)](https://www.meetup.com/clickhouse-toronto-user-group/events/301490855/) - September 10
+* [Chicago Meetup (Jump Capital)](https://lu.ma/43tvmrfw) - September 12
+* [London Meetup](https://www.meetup.com/clickhouse-london-user-group/events/302977267) - September 17
+* [Austin Meetup](https://www.meetup.com/clickhouse-austin-user-group/events/302558689/) - September 17
 
 ## Recent Recordings
 * **Recent Meetup Videos**: [Meetup Playlist](https://www.youtube.com/playlist?list=PL0Z2YDlm0b3iNDUzpY1S3L_iV4nARda_U) Whenever possible recordings of the ClickHouse Community Meetups are edited and presented as individual talks. Current featuring "Modern SQL in 2023", "Fast, Concurrent, and Consistent Asynchronous INSERTS in ClickHouse", and "Full-Text Indices: Design and Experiments"

contrib/libpqxx

@@ -1 +1 @@
-Subproject commit c995193a3a14d71f4711f1f421f65a1a1db64640
+Subproject commit 41e4c331564167cca97ad6eccbd5b8879c2ca044

contrib/libpqxx-cmake/CMakeLists.txt

@@ -1,9 +1,9 @@
 set (LIBRARY_DIR "${ClickHouse_SOURCE_DIR}/contrib/libpqxx")
 
 set (SRCS
-    "${LIBRARY_DIR}/src/strconv.cxx"
     "${LIBRARY_DIR}/src/array.cxx"
     "${LIBRARY_DIR}/src/binarystring.cxx"
+    "${LIBRARY_DIR}/src/blob.cxx"
     "${LIBRARY_DIR}/src/connection.cxx"
     "${LIBRARY_DIR}/src/cursor.cxx"
     "${LIBRARY_DIR}/src/encodings.cxx"
@@ -12,59 +12,25 @@ set (SRCS
     "${LIBRARY_DIR}/src/field.cxx"
     "${LIBRARY_DIR}/src/largeobject.cxx"
     "${LIBRARY_DIR}/src/notification.cxx"
+    "${LIBRARY_DIR}/src/params.cxx"
     "${LIBRARY_DIR}/src/pipeline.cxx"
     "${LIBRARY_DIR}/src/result.cxx"
     "${LIBRARY_DIR}/src/robusttransaction.cxx"
+    "${LIBRARY_DIR}/src/row.cxx"
     "${LIBRARY_DIR}/src/sql_cursor.cxx"
+    "${LIBRARY_DIR}/src/strconv.cxx"
     "${LIBRARY_DIR}/src/stream_from.cxx"
     "${LIBRARY_DIR}/src/stream_to.cxx"
     "${LIBRARY_DIR}/src/subtransaction.cxx"
+    "${LIBRARY_DIR}/src/time.cxx"
     "${LIBRARY_DIR}/src/transaction.cxx"
     "${LIBRARY_DIR}/src/transaction_base.cxx"
-    "${LIBRARY_DIR}/src/row.cxx"
-    "${LIBRARY_DIR}/src/params.cxx"
     "${LIBRARY_DIR}/src/util.cxx"
     "${LIBRARY_DIR}/src/version.cxx"
+    "${LIBRARY_DIR}/src/wait.cxx"
 )
 
-# Need to explicitly include each header file, because in the directory include/pqxx there are also files
-# like just 'array'. So if including the whole directory with `target_include_directories`, it will make
-# conflicts with all includes of <array>.
-set (HDRS
-    "${LIBRARY_DIR}/include/pqxx/array.hxx"
-    "${LIBRARY_DIR}/include/pqxx/params.hxx"
-    "${LIBRARY_DIR}/include/pqxx/binarystring.hxx"
-    "${LIBRARY_DIR}/include/pqxx/composite.hxx"
-    "${LIBRARY_DIR}/include/pqxx/connection.hxx"
-    "${LIBRARY_DIR}/include/pqxx/cursor.hxx"
-    "${LIBRARY_DIR}/include/pqxx/dbtransaction.hxx"
-    "${LIBRARY_DIR}/include/pqxx/errorhandler.hxx"
-    "${LIBRARY_DIR}/include/pqxx/except.hxx"
-    "${LIBRARY_DIR}/include/pqxx/field.hxx"
-    "${LIBRARY_DIR}/include/pqxx/isolation.hxx"
-    "${LIBRARY_DIR}/include/pqxx/largeobject.hxx"
-    "${LIBRARY_DIR}/include/pqxx/nontransaction.hxx"
-    "${LIBRARY_DIR}/include/pqxx/notification.hxx"
-    "${LIBRARY_DIR}/include/pqxx/pipeline.hxx"
-    "${LIBRARY_DIR}/include/pqxx/prepared_statement.hxx"
-    "${LIBRARY_DIR}/include/pqxx/result.hxx"
-    "${LIBRARY_DIR}/include/pqxx/robusttransaction.hxx"
-    "${LIBRARY_DIR}/include/pqxx/row.hxx"
-    "${LIBRARY_DIR}/include/pqxx/separated_list.hxx"
-    "${LIBRARY_DIR}/include/pqxx/strconv.hxx"
-    "${LIBRARY_DIR}/include/pqxx/stream_from.hxx"
-    "${LIBRARY_DIR}/include/pqxx/stream_to.hxx"
-    "${LIBRARY_DIR}/include/pqxx/subtransaction.hxx"
-    "${LIBRARY_DIR}/include/pqxx/transaction.hxx"
-    "${LIBRARY_DIR}/include/pqxx/transaction_base.hxx"
-    "${LIBRARY_DIR}/include/pqxx/types.hxx"
-    "${LIBRARY_DIR}/include/pqxx/util.hxx"
-    "${LIBRARY_DIR}/include/pqxx/version.hxx"
-    "${LIBRARY_DIR}/include/pqxx/zview.hxx"
-)
-
-add_library(_libpqxx ${SRCS} ${HDRS})
-
+add_library(_libpqxx ${SRCS})
 target_link_libraries(_libpqxx PUBLIC ch_contrib::libpq)
 target_include_directories (_libpqxx SYSTEM BEFORE PUBLIC "${LIBRARY_DIR}/include")
 

contrib/postgres

@@ -1 +1 @@
-Subproject commit 665ff8c164d56d012e359735efe4d400c0564b44
+Subproject commit 2e51f82e27f4be389cc239d1b8784bbf2f01d33a

contrib/postgres-cmake/CMakeLists.txt

@@ -38,12 +38,14 @@ set(SRCS
     "${POSTGRES_SOURCE_DIR}/src/common/fe_memutils.c"
     "${POSTGRES_SOURCE_DIR}/src/common/string.c"
     "${POSTGRES_SOURCE_DIR}/src/common/pg_get_line.c"
+    "${POSTGRES_SOURCE_DIR}/src/common/pg_prng.c"
     "${POSTGRES_SOURCE_DIR}/src/common/stringinfo.c"
     "${POSTGRES_SOURCE_DIR}/src/common/psprintf.c"
     "${POSTGRES_SOURCE_DIR}/src/common/encnames.c"
     "${POSTGRES_SOURCE_DIR}/src/common/logging.c"
 
     "${POSTGRES_SOURCE_DIR}/src/port/snprintf.c"
+    "${POSTGRES_SOURCE_DIR}/src/port/strlcat.c"
     "${POSTGRES_SOURCE_DIR}/src/port/strlcpy.c"
     "${POSTGRES_SOURCE_DIR}/src/port/strerror.c"
     "${POSTGRES_SOURCE_DIR}/src/port/inet_net_ntop.c"
@@ -52,6 +54,7 @@ set(SRCS
     "${POSTGRES_SOURCE_DIR}/src/port/noblock.c"
     "${POSTGRES_SOURCE_DIR}/src/port/pg_strong_random.c"
     "${POSTGRES_SOURCE_DIR}/src/port/pgstrcasecmp.c"
+    "${POSTGRES_SOURCE_DIR}/src/port/pg_bitutils.c"
     "${POSTGRES_SOURCE_DIR}/src/port/thread.c"
     "${POSTGRES_SOURCE_DIR}/src/port/path.c"
 )

contrib/postgres-cmake/nodes/nodetags.h

@@ -0,0 +1,471 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodetags.h
+ *    Generated node infrastructure code
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * NOTES
+ *  ******************************
+ *  *** DO NOT EDIT THIS FILE! ***
+ *  ******************************
+ *
+ *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
+ *
+ *-------------------------------------------------------------------------
+ */
+	T_List = 1,
+	T_Alias = 2,
+	T_RangeVar = 3,
+	T_TableFunc = 4,
+	T_IntoClause = 5,
+	T_Var = 6,
+	T_Const = 7,
+	T_Param = 8,
+	T_Aggref = 9,
+	T_GroupingFunc = 10,
+	T_WindowFunc = 11,
+	T_SubscriptingRef = 12,
+	T_FuncExpr = 13,
+	T_NamedArgExpr = 14,
+	T_OpExpr = 15,
+	T_DistinctExpr = 16,
+	T_NullIfExpr = 17,
+	T_ScalarArrayOpExpr = 18,
+	T_BoolExpr = 19,
+	T_SubLink = 20,
+	T_SubPlan = 21,
+	T_AlternativeSubPlan = 22,
+	T_FieldSelect = 23,
+	T_FieldStore = 24,
+	T_RelabelType = 25,
+	T_CoerceViaIO = 26,
+	T_ArrayCoerceExpr = 27,
+	T_ConvertRowtypeExpr = 28,
+	T_CollateExpr = 29,
+	T_CaseExpr = 30,
+	T_CaseWhen = 31,
+	T_CaseTestExpr = 32,
+	T_ArrayExpr = 33,
+	T_RowExpr = 34,
+	T_RowCompareExpr = 35,
+	T_CoalesceExpr = 36,
+	T_MinMaxExpr = 37,
+	T_SQLValueFunction = 38,
+	T_XmlExpr = 39,
+	T_JsonFormat = 40,
+	T_JsonReturning = 41,
+	T_JsonValueExpr = 42,
+	T_JsonConstructorExpr = 43,
+	T_JsonIsPredicate = 44,
+	T_NullTest = 45,
+	T_BooleanTest = 46,
+	T_CoerceToDomain = 47,
+	T_CoerceToDomainValue = 48,
+	T_SetToDefault = 49,
+	T_CurrentOfExpr = 50,
+	T_NextValueExpr = 51,
+	T_InferenceElem = 52,
+	T_TargetEntry = 53,
+	T_RangeTblRef = 54,
+	T_JoinExpr = 55,
+	T_FromExpr = 56,
+	T_OnConflictExpr = 57,
+	T_Query = 58,
+	T_TypeName = 59,
+	T_ColumnRef = 60,
+	T_ParamRef = 61,
+	T_A_Expr = 62,
+	T_A_Const = 63,
+	T_TypeCast = 64,
+	T_CollateClause = 65,
+	T_RoleSpec = 66,
+	T_FuncCall = 67,
+	T_A_Star = 68,
+	T_A_Indices = 69,
+	T_A_Indirection = 70,
+	T_A_ArrayExpr = 71,
+	T_ResTarget = 72,
+	T_MultiAssignRef = 73,
+	T_SortBy = 74,
+	T_WindowDef = 75,
+	T_RangeSubselect = 76,
+	T_RangeFunction = 77,
+	T_RangeTableFunc = 78,
+	T_RangeTableFuncCol = 79,
+	T_RangeTableSample = 80,
+	T_ColumnDef = 81,
+	T_TableLikeClause = 82,
+	T_IndexElem = 83,
+	T_DefElem = 84,
+	T_LockingClause = 85,
+	T_XmlSerialize = 86,
+	T_PartitionElem = 87,
+	T_PartitionSpec = 88,
+	T_PartitionBoundSpec = 89,
+	T_PartitionRangeDatum = 90,
+	T_PartitionCmd = 91,
+	T_RangeTblEntry = 92,
+	T_RTEPermissionInfo = 93,
+	T_RangeTblFunction = 94,
+	T_TableSampleClause = 95,
+	T_WithCheckOption = 96,
+	T_SortGroupClause = 97,
+	T_GroupingSet = 98,
+	T_WindowClause = 99,
+	T_RowMarkClause = 100,
+	T_WithClause = 101,
+	T_InferClause = 102,
+	T_OnConflictClause = 103,
+	T_CTESearchClause = 104,
+	T_CTECycleClause = 105,
+	T_CommonTableExpr = 106,
+	T_MergeWhenClause = 107,
+	T_MergeAction = 108,
+	T_TriggerTransition = 109,
+	T_JsonOutput = 110,
+	T_JsonKeyValue = 111,
+	T_JsonObjectConstructor = 112,
+	T_JsonArrayConstructor = 113,
+	T_JsonArrayQueryConstructor = 114,
+	T_JsonAggConstructor = 115,
+	T_JsonObjectAgg = 116,
+	T_JsonArrayAgg = 117,
+	T_RawStmt = 118,
+	T_InsertStmt = 119,
+	T_DeleteStmt = 120,
+	T_UpdateStmt = 121,
+	T_MergeStmt = 122,
+	T_SelectStmt = 123,
+	T_SetOperationStmt = 124,
+	T_ReturnStmt = 125,
+	T_PLAssignStmt = 126,
+	T_CreateSchemaStmt = 127,
+	T_AlterTableStmt = 128,
+	T_ReplicaIdentityStmt = 129,
+	T_AlterTableCmd = 130,
+	T_AlterCollationStmt = 131,
+	T_AlterDomainStmt = 132,
+	T_GrantStmt = 133,
+	T_ObjectWithArgs = 134,
+	T_AccessPriv = 135,
+	T_GrantRoleStmt = 136,
+	T_AlterDefaultPrivilegesStmt = 137,
+	T_CopyStmt = 138,
+	T_VariableSetStmt = 139,
+	T_VariableShowStmt = 140,
+	T_CreateStmt = 141,
+	T_Constraint = 142,
+	T_CreateTableSpaceStmt = 143,
+	T_DropTableSpaceStmt = 144,
+	T_AlterTableSpaceOptionsStmt = 145,
+	T_AlterTableMoveAllStmt = 146,
+	T_CreateExtensionStmt = 147,
+	T_AlterExtensionStmt = 148,
+	T_AlterExtensionContentsStmt = 149,
+	T_CreateFdwStmt = 150,
+	T_AlterFdwStmt = 151,
+	T_CreateForeignServerStmt = 152,
+	T_AlterForeignServerStmt = 153,
+	T_CreateForeignTableStmt = 154,
+	T_CreateUserMappingStmt = 155,
+	T_AlterUserMappingStmt = 156,
+	T_DropUserMappingStmt = 157,
+	T_ImportForeignSchemaStmt = 158,
+	T_CreatePolicyStmt = 159,
+	T_AlterPolicyStmt = 160,
+	T_CreateAmStmt = 161,
+	T_CreateTrigStmt = 162,
+	T_CreateEventTrigStmt = 163,
+	T_AlterEventTrigStmt = 164,
+	T_CreatePLangStmt = 165,
+	T_CreateRoleStmt = 166,
+	T_AlterRoleStmt = 167,
+	T_AlterRoleSetStmt = 168,
+	T_DropRoleStmt = 169,
+	T_CreateSeqStmt = 170,
+	T_AlterSeqStmt = 171,
+	T_DefineStmt = 172,
+	T_CreateDomainStmt = 173,
+	T_CreateOpClassStmt = 174,
+	T_CreateOpClassItem = 175,
+	T_CreateOpFamilyStmt = 176,
+	T_AlterOpFamilyStmt = 177,
+	T_DropStmt = 178,
+	T_TruncateStmt = 179,
+	T_CommentStmt = 180,
+	T_SecLabelStmt = 181,
+	T_DeclareCursorStmt = 182,
+	T_ClosePortalStmt = 183,
+	T_FetchStmt = 184,
+	T_IndexStmt = 185,
+	T_CreateStatsStmt = 186,
+	T_StatsElem = 187,
+	T_AlterStatsStmt = 188,
+	T_CreateFunctionStmt = 189,
+	T_FunctionParameter = 190,
+	T_AlterFunctionStmt = 191,
+	T_DoStmt = 192,
+	T_InlineCodeBlock = 193,
+	T_CallStmt = 194,
+	T_CallContext = 195,
+	T_RenameStmt = 196,
+	T_AlterObjectDependsStmt = 197,
+	T_AlterObjectSchemaStmt = 198,
+	T_AlterOwnerStmt = 199,
+	T_AlterOperatorStmt = 200,
+	T_AlterTypeStmt = 201,
+	T_RuleStmt = 202,
+	T_NotifyStmt = 203,
+	T_ListenStmt = 204,
+	T_UnlistenStmt = 205,
+	T_TransactionStmt = 206,
+	T_CompositeTypeStmt = 207,
+	T_CreateEnumStmt = 208,
+	T_CreateRangeStmt = 209,
+	T_AlterEnumStmt = 210,
+	T_ViewStmt = 211,
+	T_LoadStmt = 212,
+	T_CreatedbStmt = 213,
+	T_AlterDatabaseStmt = 214,
+	T_AlterDatabaseRefreshCollStmt = 215,
+	T_AlterDatabaseSetStmt = 216,
+	T_DropdbStmt = 217,
+	T_AlterSystemStmt = 218,
+	T_ClusterStmt = 219,
+	T_VacuumStmt = 220,
+	T_VacuumRelation = 221,
+	T_ExplainStmt = 222,
+	T_CreateTableAsStmt = 223,
+	T_RefreshMatViewStmt = 224,
+	T_CheckPointStmt = 225,
+	T_DiscardStmt = 226,
+	T_LockStmt = 227,
+	T_ConstraintsSetStmt = 228,
+	T_ReindexStmt = 229,
+	T_CreateConversionStmt = 230,
+	T_CreateCastStmt = 231,
+	T_CreateTransformStmt = 232,
+	T_PrepareStmt = 233,
+	T_ExecuteStmt = 234,
+	T_DeallocateStmt = 235,
+	T_DropOwnedStmt = 236,
+	T_ReassignOwnedStmt = 237,
+	T_AlterTSDictionaryStmt = 238,
+	T_AlterTSConfigurationStmt = 239,
+	T_PublicationTable = 240,
+	T_PublicationObjSpec = 241,
+	T_CreatePublicationStmt = 242,
+	T_AlterPublicationStmt = 243,
+	T_CreateSubscriptionStmt = 244,
+	T_AlterSubscriptionStmt = 245,
+	T_DropSubscriptionStmt = 246,
+	T_PlannerGlobal = 247,
+	T_PlannerInfo = 248,
+	T_RelOptInfo = 249,
+	T_IndexOptInfo = 250,
+	T_ForeignKeyOptInfo = 251,
+	T_StatisticExtInfo = 252,
+	T_JoinDomain = 253,
+	T_EquivalenceClass = 254,
+	T_EquivalenceMember = 255,
+	T_PathKey = 256,
+	T_PathTarget = 257,
+	T_ParamPathInfo = 258,
+	T_Path = 259,
+	T_IndexPath = 260,
+	T_IndexClause = 261,
+	T_BitmapHeapPath = 262,
+	T_BitmapAndPath = 263,
+	T_BitmapOrPath = 264,
+	T_TidPath = 265,
+	T_TidRangePath = 266,
+	T_SubqueryScanPath = 267,
+	T_ForeignPath = 268,
+	T_CustomPath = 269,
+	T_AppendPath = 270,
+	T_MergeAppendPath = 271,
+	T_GroupResultPath = 272,
+	T_MaterialPath = 273,
+	T_MemoizePath = 274,
+	T_UniquePath = 275,
+	T_GatherPath = 276,
+	T_GatherMergePath = 277,
+	T_NestPath = 278,
+	T_MergePath = 279,
+	T_HashPath = 280,
+	T_ProjectionPath = 281,
+	T_ProjectSetPath = 282,
+	T_SortPath = 283,
+	T_IncrementalSortPath = 284,
+	T_GroupPath = 285,
+	T_UpperUniquePath = 286,
+	T_AggPath = 287,
+	T_GroupingSetData = 288,
+	T_RollupData = 289,
+	T_GroupingSetsPath = 290,
+	T_MinMaxAggPath = 291,
+	T_WindowAggPath = 292,
+	T_SetOpPath = 293,
+	T_RecursiveUnionPath = 294,
+	T_LockRowsPath = 295,
+	T_ModifyTablePath = 296,
+	T_LimitPath = 297,
+	T_RestrictInfo = 298,
+	T_PlaceHolderVar = 299,
+	T_SpecialJoinInfo = 300,
+	T_OuterJoinClauseInfo = 301,
+	T_AppendRelInfo = 302,
+	T_RowIdentityVarInfo = 303,
+	T_PlaceHolderInfo = 304,
+	T_MinMaxAggInfo = 305,
+	T_PlannerParamItem = 306,
+	T_AggInfo = 307,
+	T_AggTransInfo = 308,
+	T_PlannedStmt = 309,
+	T_Result = 310,
+	T_ProjectSet = 311,
+	T_ModifyTable = 312,
+	T_Append = 313,
+	T_MergeAppend = 314,
+	T_RecursiveUnion = 315,
+	T_BitmapAnd = 316,
+	T_BitmapOr = 317,
+	T_SeqScan = 318,
+	T_SampleScan = 319,
+	T_IndexScan = 320,
+	T_IndexOnlyScan = 321,
+	T_BitmapIndexScan = 322,
+	T_BitmapHeapScan = 323,
+	T_TidScan = 324,
+	T_TidRangeScan = 325,
+	T_SubqueryScan = 326,
+	T_FunctionScan = 327,
+	T_ValuesScan = 328,
+	T_TableFuncScan = 329,
+	T_CteScan = 330,
+	T_NamedTuplestoreScan = 331,
+	T_WorkTableScan = 332,
+	T_ForeignScan = 333,
+	T_CustomScan = 334,
+	T_NestLoop = 335,
+	T_NestLoopParam = 336,
+	T_MergeJoin = 337,
+	T_HashJoin = 338,
+	T_Material = 339,
+	T_Memoize = 340,
+	T_Sort = 341,
+	T_IncrementalSort = 342,
+	T_Group = 343,
+	T_Agg = 344,
+	T_WindowAgg = 345,
+	T_Unique = 346,
+	T_Gather = 347,
+	T_GatherMerge = 348,
+	T_Hash = 349,
+	T_SetOp = 350,
+	T_LockRows = 351,
+	T_Limit = 352,
+	T_PlanRowMark = 353,
+	T_PartitionPruneInfo = 354,
+	T_PartitionedRelPruneInfo = 355,
+	T_PartitionPruneStepOp = 356,
+	T_PartitionPruneStepCombine = 357,
+	T_PlanInvalItem = 358,
+	T_ExprState = 359,
+	T_IndexInfo = 360,
+	T_ExprContext = 361,
+	T_ReturnSetInfo = 362,
+	T_ProjectionInfo = 363,
+	T_JunkFilter = 364,
+	T_OnConflictSetState = 365,
+	T_MergeActionState = 366,
+	T_ResultRelInfo = 367,
+	T_EState = 368,
+	T_WindowFuncExprState = 369,
+	T_SetExprState = 370,
+	T_SubPlanState = 371,
+	T_DomainConstraintState = 372,
+	T_ResultState = 373,
+	T_ProjectSetState = 374,
+	T_ModifyTableState = 375,
+	T_AppendState = 376,
+	T_MergeAppendState = 377,
+	T_RecursiveUnionState = 378,
+	T_BitmapAndState = 379,
+	T_BitmapOrState = 380,
+	T_ScanState = 381,
+	T_SeqScanState = 382,
+	T_SampleScanState = 383,
+	T_IndexScanState = 384,
+	T_IndexOnlyScanState = 385,
+	T_BitmapIndexScanState = 386,
+	T_BitmapHeapScanState = 387,
+	T_TidScanState = 388,
+	T_TidRangeScanState = 389,
+	T_SubqueryScanState = 390,
+	T_FunctionScanState = 391,
+	T_ValuesScanState = 392,
+	T_TableFuncScanState = 393,
+	T_CteScanState = 394,
+	T_NamedTuplestoreScanState = 395,
+	T_WorkTableScanState = 396,
+	T_ForeignScanState = 397,
+	T_CustomScanState = 398,
+	T_JoinState = 399,
+	T_NestLoopState = 400,
+	T_MergeJoinState = 401,
+	T_HashJoinState = 402,
+	T_MaterialState = 403,
+	T_MemoizeState = 404,
+	T_SortState = 405,
+	T_IncrementalSortState = 406,
+	T_GroupState = 407,
+	T_AggState = 408,
+	T_WindowAggState = 409,
+	T_UniqueState = 410,
+	T_GatherState = 411,
+	T_GatherMergeState = 412,
+	T_HashState = 413,
+	T_SetOpState = 414,
+	T_LockRowsState = 415,
+	T_LimitState = 416,
+	T_IndexAmRoutine = 417,
+	T_TableAmRoutine = 418,
+	T_TsmRoutine = 419,
+	T_EventTriggerData = 420,
+	T_TriggerData = 421,
+	T_TupleTableSlot = 422,
+	T_FdwRoutine = 423,
+	T_Bitmapset = 424,
+	T_ExtensibleNode = 425,
+	T_ErrorSaveContext = 426,
+	T_IdentifySystemCmd = 427,
+	T_BaseBackupCmd = 428,
+	T_CreateReplicationSlotCmd = 429,
+	T_DropReplicationSlotCmd = 430,
+	T_StartReplicationCmd = 431,
+	T_ReadReplicationSlotCmd = 432,
+	T_TimeLineHistoryCmd = 433,
+	T_SupportRequestSimplify = 434,
+	T_SupportRequestSelectivity = 435,
+	T_SupportRequestCost = 436,
+	T_SupportRequestRows = 437,
+	T_SupportRequestIndexCondition = 438,
+	T_SupportRequestWFuncMonotonic = 439,
+	T_SupportRequestOptimizeWindowClause = 440,
+	T_Integer = 441,
+	T_Float = 442,
+	T_Boolean = 443,
+	T_String = 444,
+	T_BitString = 445,
+	T_ForeignKeyCacheInfo = 446,
+	T_IntList = 447,
+	T_OidList = 448,
+	T_XidList = 449,
+	T_AllocSetContext = 450,
+	T_GenerationContext = 451,
+	T_SlabContext = 452,
+	T_TIDBitmap = 453,
+	T_WindowObjectData = 454,

contrib/postgres-cmake/pg_config.h

@@ -1,18 +1,6 @@
 /* src/include/pg_config.h.  Generated from pg_config.h.in by configure.  */
 /* src/include/pg_config.h.in.  Generated from configure.in by autoheader.  */
 
-/* Define to the type of arg 1 of 'accept' */
-#define ACCEPT_TYPE_ARG1 int
-
-/* Define to the type of arg 2 of 'accept' */
-#define ACCEPT_TYPE_ARG2 struct sockaddr *
-
-/* Define to the type of arg 3 of 'accept' */
-#define ACCEPT_TYPE_ARG3 size_t
-
-/* Define to the return type of 'accept' */
-#define ACCEPT_TYPE_RETURN int
-
 /* Define if building universal (internal helper macro) */
 /* #undef AC_APPLE_UNIVERSAL_BUILD */
 
@@ -49,6 +37,9 @@
 /* Define to the default TCP port number as a string constant. */
 #define DEF_PGPORT_STR "5432"
 
+/* Define to the file name extension of dynamically-loadable modules. */
+#define DLSUFFIX ".so"
+
 /* Define to build with GSSAPI support. (--with-gssapi) */
 //#define ENABLE_GSS 0
 
@@ -75,13 +66,6 @@
    reference if 'false' */
 #define FLOAT8PASSBYVAL false
 
-/* Define to 1 if gettimeofday() takes only 1 argument. */
-/* #undef GETTIMEOFDAY_1ARG */
-
-#ifdef GETTIMEOFDAY_1ARG
-# define gettimeofday(a,b) gettimeofday(a)
-#endif
-
 /* Define to 1 if you have the `append_history' function. */
 /* #undef HAVE_APPEND_HISTORY */
 
@@ -145,21 +129,12 @@
 /* Define to 1 if you have the <dld.h> header file. */
 /* #undef HAVE_DLD_H */
 
-/* Define to 1 if you have the `dlopen' function. */
-#define HAVE_DLOPEN 1
-
 /* Define to 1 if you have the <editline/history.h> header file. */
 /* #undef HAVE_EDITLINE_HISTORY_H */
 
 /* Define to 1 if you have the <editline/readline.h> header file. */
 #define HAVE_EDITLINE_READLINE_H 1
 
-/* Define to 1 if you have the `fdatasync' function. */
-#define HAVE_FDATASYNC 1
-
-/* Define to 1 if you have the `fls' function. */
-/* #undef HAVE_FLS */
-
 /* Define to 1 if you have the `fpclass' function. */
 /* #undef HAVE_FPCLASS */
 
@@ -175,12 +150,6 @@
 /* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
 #define HAVE_FSEEKO 1
 
-/* Define to 1 if your compiler understands __func__. */
-#define HAVE_FUNCNAME__FUNC 1
-
-/* Define to 1 if your compiler understands __FUNCTION__. */
-/* #undef HAVE_FUNCNAME__FUNCTION */
-
 /* Define to 1 if you have __atomic_compare_exchange_n(int *, int *, int). */
 /* #undef HAVE_GCC__ATOMIC_INT32_CAS */
 
@@ -200,12 +169,6 @@
 /* Define to 1 if you have __sync_compare_and_swap(int64 *, int64, int64). */
 /* #undef HAVE_GCC__SYNC_INT64_CAS */
 
-/* Define to 1 if you have the `getaddrinfo' function. */
-#define HAVE_GETADDRINFO 1
-
-/* Define to 1 if you have the `gethostbyname_r' function. */
-#define HAVE_GETHOSTBYNAME_R 1
-
 /* Define to 1 if you have the `getifaddrs' function. */
 #define HAVE_GETIFADDRS 1
 
@@ -224,17 +187,11 @@
 /* Define to 1 if you have the `getpeerucred' function. */
 /* #undef HAVE_GETPEERUCRED */
 
-/* Define to 1 if you have the `getpwuid_r' function. */
-#define HAVE_GETPWUID_R 1
+/* Define to 1 if you have the <gssapi_ext.h> header file. */
+/* #undef HAVE_GSSAPI_EXT_H */
 
-/* Define to 1 if you have the `getrlimit' function. */
-#define HAVE_GETRLIMIT 1
-
-/* Define to 1 if you have the `getrusage' function. */
-#define HAVE_GETRUSAGE 1
-
-/* Define to 1 if you have the `gettimeofday' function. */
-/* #undef HAVE_GETTIMEOFDAY */
+/* Define to 1 if you have the <gssapi/gssapi_ext.h> header file. */
+/* #undef HAVE_GSSAPI_GSSAPI_EXT_H */
 
 /* Define to 1 if you have the <gssapi/gssapi.h> header file. */
 //#define HAVE_GSSAPI_GSSAPI_H 0
@@ -257,6 +214,9 @@
 /* Define to 1 if you have the `inet_aton' function. */
 #define HAVE_INET_ATON 1
 
+/* Define to 1 if you have the `inet_pton' function. */
+#define HAVE_INET_PTON 1
+
 /* Define to 1 if the system has the type `int64'. */
 /* #undef HAVE_INT64 */
 
@@ -278,18 +238,12 @@
 /* Define to 1 if you have the global variable 'int timezone'. */
 #define HAVE_INT_TIMEZONE 1
 
-/* Define to 1 if you have support for IPv6. */
-#define HAVE_IPV6 1
-
 /* Define to 1 if you have isinf(). */
 #define HAVE_ISINF 1
 
 /* Define to 1 if you have the <langinfo.h> header file. */
 #define HAVE_LANGINFO_H 1
 
-/* Define to 1 if you have the <ldap.h> header file. */
-//#define HAVE_LDAP_H 0
-
 /* Define to 1 if you have the `crypto' library (-lcrypto). */
 #define HAVE_LIBCRYPTO 1
 
@@ -323,6 +277,9 @@
 /* Define to 1 if you have the `z' library (-lz). */
 #define HAVE_LIBZ 1
 
+/* Define to 1 if you have the `zstd' library (-lzstd). */
+/* #undef HAVE_LIBZSTD */
+
 /* Define to 1 if constants of type 'long long int' should have the suffix LL.
    */
 #define HAVE_LL_CONSTANTS 1
@@ -351,18 +308,9 @@
 /* Define to 1 if you have the <memory.h> header file. */
 #define HAVE_MEMORY_H 1
 
-/* Define to 1 if the system has the type `MINIDUMP_TYPE'. */
-/* #undef HAVE_MINIDUMP_TYPE */
-
 /* Define to 1 if you have the `mkdtemp' function. */
 #define HAVE_MKDTEMP 1
 
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#define HAVE_NETINET_IN_H 1
-
-/* Define to 1 if you have the <netinet/tcp.h> header file. */
-#define HAVE_NETINET_TCP_H 1
-
 /* Define to 1 if you have the <net/if.h> header file. */
 #define HAVE_NET_IF_H 1
 
@@ -372,12 +320,6 @@
 /* Define to 1 if you have the <pam/pam_appl.h> header file. */
 /* #undef HAVE_PAM_PAM_APPL_H */
 
-/* Define to 1 if you have the `poll' function. */
-#define HAVE_POLL 1
-
-/* Define to 1 if you have the <poll.h> header file. */
-#define HAVE_POLL_H 1
-
 /* Define to 1 if you have the `posix_fadvise' function. */
 #define HAVE_POSIX_FADVISE 1
 
@@ -396,21 +338,12 @@
 /* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */
 /* #undef HAVE_PPC_LWARX_MUTEX_HINT */
 
-/* Define to 1 if you have the `pstat' function. */
-/* #undef HAVE_PSTAT */
-
-/* Define to 1 if the PS_STRINGS thing exists. */
-/* #undef HAVE_PS_STRINGS */
-
 /* Define to 1 if you have the `pthread_is_threaded_np' function. */
 /* #undef HAVE_PTHREAD_IS_THREADED_NP */
 
 /* Define to 1 if you have the <pwd.h> header file. */
 #define HAVE_PWD_H 1
 
-/* Define to 1 if you have the `random' function. */
-#define HAVE_RANDOM 1
-
 /* Define to 1 if you have the <readline.h> header file. */
 /* #undef HAVE_READLINE_H */
 
@@ -420,16 +353,9 @@
 /* Define to 1 if you have the <readline/readline.h> header file. */
 /* #undef HAVE_READLINE_READLINE_H */
 
-/* Define to 1 if you have the `readlink' function. */
-#define HAVE_READLINK 1
-
 /* Define to 1 if you have the `rint' function. */
 #define HAVE_RINT 1
 
-/* Define to 1 if you have the global variable
-   'rl_completion_append_character'. */
-/* #undef HAVE_RL_COMPLETION_APPEND_CHARACTER */
-
 /* Define to 1 if you have the `rl_completion_matches' function. */
 #define HAVE_RL_COMPLETION_MATCHES 1
 
@@ -439,17 +365,17 @@
 /* Define to 1 if you have the `rl_reset_screen_size' function. */
 /* #undef HAVE_RL_RESET_SCREEN_SIZE */
 
+/* Define to 1 if you have the `rl_variable_bind' function. */
+#define HAVE_RL_VARIABLE_BIND 1
+
 /* Define to 1 if you have the <security/pam_appl.h> header file. */
 #define HAVE_SECURITY_PAM_APPL_H 1
 
 /* Define to 1 if you have the `setproctitle' function. */
 /* #undef HAVE_SETPROCTITLE */
 
-/* Define to 1 if you have the `setsid' function. */
-#define HAVE_SETSID 1
-
-/* Define to 1 if you have the `shm_open' function. */
-#define HAVE_SHM_OPEN 1
+/* Define to 1 if the system has the type `socklen_t'. */
+#define HAVE_SOCKLEN_T 1
 
 /* Define to 1 if you have the `sigprocmask' function. */
 #define HAVE_SIGPROCMASK 1
@@ -466,8 +392,8 @@
 /* Define to 1 if you have spinlocks. */
 #define HAVE_SPINLOCKS 1
 
-/* Define to 1 if you have the `srandom' function. */
-#define HAVE_SRANDOM 1
+/* Define to 1 if you have the `SSL_CTX_set_cert_cb' function. */
+#define HAVE_SSL_CTX_SET_CERT_CB 1
 
 /* Define to 1 if you have the `SSL_CTX_set_num_tickets' function. */
 /* #define HAVE_SSL_CTX_SET_NUM_TICKETS */
@@ -499,55 +425,19 @@
 /* Define to 1 if you have the `strlcpy' function. */
 /* #undef HAVE_STRLCPY */
 
-/* Define to 1 if you have the `strtoll' function. */
-#define HAVE_STRTOLL 1
-
 #if (!OS_DARWIN)
 #define HAVE_STRCHRNUL 1
 #endif
 
-/* Define to 1 if you have the `strtoq' function. */
-/* #undef HAVE_STRTOQ */
-
-/* Define to 1 if you have the `strtoull' function. */
-#define HAVE_STRTOULL 1
-
-/* Define to 1 if you have the `strtouq' function. */
-/* #undef HAVE_STRTOUQ */
-
-/* Define to 1 if the system has the type `struct addrinfo'. */
-#define HAVE_STRUCT_ADDRINFO 1
-
-/* Define to 1 if the system has the type `struct cmsgcred'. */
-/* #undef HAVE_STRUCT_CMSGCRED */
-
 /* Define to 1 if the system has the type `struct option'. */
 #define HAVE_STRUCT_OPTION 1
 
 /* Define to 1 if `sa_len' is a member of `struct sockaddr'. */
 /* #undef HAVE_STRUCT_SOCKADDR_SA_LEN */
 
-/* Define to 1 if the system has the type `struct sockaddr_storage'. */
-#define HAVE_STRUCT_SOCKADDR_STORAGE 1
-
-/* Define to 1 if `ss_family' is a member of `struct sockaddr_storage'. */
-#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY 1
-
-/* Define to 1 if `ss_len' is a member of `struct sockaddr_storage'. */
-/* #undef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN */
-
-/* Define to 1 if `__ss_family' is a member of `struct sockaddr_storage'. */
-/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_FAMILY */
-
-/* Define to 1 if `__ss_len' is a member of `struct sockaddr_storage'. */
-/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_LEN */
-
 /* Define to 1 if `tm_zone' is a member of `struct tm'. */
 #define HAVE_STRUCT_TM_TM_ZONE 1
 
-/* Define to 1 if you have the `symlink' function. */
-#define HAVE_SYMLINK 1
-
 /* Define to 1 if you have the `sync_file_range' function. */
 /* #undef HAVE_SYNC_FILE_RANGE */
 
@@ -557,45 +447,21 @@
 /* Define to 1 if you have the <sys/ioctl.h> header file. */
 #define HAVE_SYS_IOCTL_H 1
 
-/* Define to 1 if you have the <sys/ipc.h> header file. */
-#define HAVE_SYS_IPC_H 1
-
 /* Define to 1 if you have the <sys/personality.h> header file. */
 /* #undef HAVE_SYS_PERSONALITY_H */
 
 /* Define to 1 if you have the <sys/poll.h> header file. */
 #define HAVE_SYS_POLL_H 1
 
-/* Define to 1 if you have the <sys/pstat.h> header file. */
-/* #undef HAVE_SYS_PSTAT_H */
-
-/* Define to 1 if you have the <sys/resource.h> header file. */
-#define HAVE_SYS_RESOURCE_H 1
-
-/* Define to 1 if you have the <sys/select.h> header file. */
-#define HAVE_SYS_SELECT_H 1
-
-/* Define to 1 if you have the <sys/sem.h> header file. */
-#define HAVE_SYS_SEM_H 1
-
-/* Define to 1 if you have the <sys/shm.h> header file. */
-#define HAVE_SYS_SHM_H 1
-
 /* Define to 1 if you have the <sys/signalfd.h> header file. */
 /* #undef HAVE_SYS_SIGNALFD_H */
 
 /* Define to 1 if you have the <sys/socket.h> header file. */
 #define HAVE_SYS_SOCKET_H 1
 
-/* Define to 1 if you have the <sys/sockio.h> header file. */
-/* #undef HAVE_SYS_SOCKIO_H */
-
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #define HAVE_SYS_STAT_H 1
 
-/* Define to 1 if you have the <sys/tas.h> header file. */
-/* #undef HAVE_SYS_TAS_H */
-
 /* Define to 1 if you have the <sys/time.h> header file. */
 #define HAVE_SYS_TIME_H 1
 
@@ -608,7 +474,6 @@
 #endif
 
 /* Define to 1 if you have the <sys/un.h> header file. */
-#define HAVE_SYS_UN_H 1
 #define _GNU_SOURCE 1 /* Needed for glibc struct ucred */
 
 /* Define to 1 if you have the <termios.h> header file. */
@@ -645,9 +510,6 @@
 /* Define to 1 if you have unix sockets. */
 #define HAVE_UNIX_SOCKETS 1
 
-/* Define to 1 if you have the `unsetenv' function. */
-#define HAVE_UNSETENV 1
-
 /* Define to 1 if the system has the type `unsigned long long int'. */
 #define HAVE_UNSIGNED_LONG_LONG_INT 1
 
@@ -675,6 +537,9 @@
 /* Define to 1 if you have the <uuid/uuid.h> header file. */
 /* #undef HAVE_UUID_UUID_H */
 
+/* Define to 1 if your compiler knows the visibility("hidden") attribute. */
+/* #undef HAVE_VISIBILITY_ATTRIBUTE */
+
 /* Define to 1 if you have the `vsnprintf' function. */
 #define HAVE_VSNPRINTF 1
 
@@ -687,12 +552,6 @@
 /* Define to 1 if you have the `wcstombs_l' function. */
 /* #undef HAVE_WCSTOMBS_L */
 
-/* Define to 1 if you have the <wctype.h> header file. */
-#define HAVE_WCTYPE_H 1
-
-/* Define to 1 if you have the <winldap.h> header file. */
-/* #undef HAVE_WINLDAP_H */
-
 /* Define to 1 if your compiler understands __builtin_bswap32. */
 /* #undef HAVE__BUILTIN_BSWAP32 */
 
@@ -885,6 +744,9 @@
 /* Define to select Win32-style shared memory. */
 /* #undef USE_WIN32_SHARED_MEMORY */
 
+/* Define to 1 to build with ZSTD support. (--with-zstd) */
+/* #undef USE_ZSTD */
+
 /* Define to 1 if `wcstombs_l' requires <xlocale.h>. */
 /* #undef WCSTOMBS_L_IN_XLOCALE */
 

contrib/sparse-checkout/setup-sparse-checkout.sh

@@ -14,5 +14,6 @@ git config submodule."contrib/icu".update '!../sparse-checkout/update-icu.sh'
 git config submodule."contrib/boost".update '!../sparse-checkout/update-boost.sh'
 git config submodule."contrib/aws-s2n-tls".update '!../sparse-checkout/update-aws-s2n-tls.sh'
 git config submodule."contrib/protobuf".update '!../sparse-checkout/update-protobuf.sh'
+git config submodule."contrib/postgres".update '!../sparse-checkout/update-postgres.sh'
 git config submodule."contrib/libxml2".update '!../sparse-checkout/update-libxml2.sh'
 git config submodule."contrib/brotli".update '!../sparse-checkout/update-brotli.sh'

contrib/sparse-checkout/update-postgres.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+echo "Using sparse checkout for postgres"
+
+FILES_TO_CHECKOUT=$(git rev-parse --git-dir)/info/sparse-checkout
+echo '!/*' > $FILES_TO_CHECKOUT
+echo '/src/interfaces/libpq/*' >> $FILES_TO_CHECKOUT
+echo '!/src/interfaces/libpq/*/*' >> $FILES_TO_CHECKOUT
+echo '/src/common/*' >> $FILES_TO_CHECKOUT
+echo '!/src/port/*/*' >> $FILES_TO_CHECKOUT
+echo '/src/port/*' >> $FILES_TO_CHECKOUT
+echo '/src/include/*' >> $FILES_TO_CHECKOUT
+
+git config core.sparsecheckout true
+git checkout $1
+git read-tree -mu HEAD

docs/en/sql-reference/aggregate-functions/reference/quantileddsketch.md

@@ -9,7 +9,7 @@ Computes an approximate [quantile](https://en.wikipedia.org/wiki/Quantile) of a
 **Syntax**
 
 ``` sql
-quantileDDsketch[relative_accuracy, (level)](expr)
+quantileDD(relative_accuracy, [level])(expr)
 ```
 
 **Arguments**

docs/en/sql-reference/functions/array-functions.md

@@ -2088,13 +2088,14 @@ Calculate AUC (Area Under the Curve, which is a concept in machine learning, see
 **Syntax**
 
 ``` sql
-arrayAUC(arr_scores, arr_labels)
+arrayAUC(arr_scores, arr_labels[, scale])
 ```
 
 **Arguments**
 
 - `arr_scores` — scores prediction model gives.
 - `arr_labels` — labels of samples, usually 1 for positive sample and 0 for negative sample.
+- `scale` - Optional. Wether to return the normalized area. Default value: true. [Bool]
 
 **Returned value**
 

programs/benchmark/Benchmark.cpp

@@ -19,6 +19,7 @@
 #include <Common/Exception.h>
 #include <Common/randomSeed.h>
 #include <Common/clearPasswordFromCommandLine.h>
+#include <Core/Settings.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFile.h>
 #include <IO/ReadHelpers.h>
@@ -36,7 +37,6 @@
 #include <Common/StudentTTest.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/ErrorCodes.h>
-#include <Core/BaseSettingsProgramOptions.h>
 
 
 /** A tool for evaluating ClickHouse performance.
@@ -58,8 +58,9 @@ static constexpr std::string_view DEFAULT_CLIENT_NAME = "benchmark";
 
 namespace ErrorCodes
 {
-    extern const int CANNOT_BLOCK_SIGNAL;
-    extern const int EMPTY_DATA_PASSED;
+extern const int BAD_ARGUMENTS;
+extern const int CANNOT_BLOCK_SIGNAL;
+extern const int EMPTY_DATA_PASSED;
 }
 
 class Benchmark : public Poco::Util::Application
@@ -637,7 +638,7 @@ int mainEntryClickHouseBenchmark(int argc, char ** argv)
         ;
 
         Settings settings;
-        addProgramOptions(settings, desc);
+        settings.addToProgramOptions(desc);
 
         boost::program_options::variables_map options;
         boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), options);

programs/client/Client.cpp

@@ -56,6 +56,12 @@ using namespace std::literals;
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsDialect dialect;
+    extern const SettingsBool use_client_time_zone;
+}
+
 namespace ErrorCodes
 {
     extern const int BAD_ARGUMENTS;
@@ -307,9 +313,9 @@ void Client::initialize(Poco::Util::Application & self)
         config().setString("password", env_password);
 
     /// settings and limits could be specified in config file, but passed settings has higher priority
-    for (const auto & setting : global_context->getSettingsRef().allUnchanged())
+    for (const auto & setting : global_context->getSettingsRef().getUnchangedNames())
     {
-        const auto & name = setting.getName();
+        String name{setting};
         if (config().has(name))
             global_context->setSetting(name, config().getString(name));
     }
@@ -525,7 +531,7 @@ void Client::connect()
         }
     }
 
-    if (!client_context->getSettingsRef().use_client_time_zone)
+    if (!client_context->getSettingsRef()[Setting::use_client_time_zone])
     {
         const auto & time_zone = connection->getServerTimezone(connection_parameters.timeouts);
         if (!time_zone.empty())
@@ -730,7 +736,7 @@ bool Client::processWithFuzzing(const String & full_query)
     }
 
     // Kusto is not a subject for fuzzing (yet)
-    if (client_context->getSettingsRef().dialect == DB::Dialect::kusto)
+    if (client_context->getSettingsRef()[Setting::dialect] == DB::Dialect::kusto)
     {
         return true;
     }
@@ -1073,17 +1079,7 @@ void Client::processOptions(const OptionsDescription & options_description,
 
     /// Copy settings-related program options to config.
     /// TODO: Is this code necessary?
-    for (const auto & setting : global_context->getSettingsRef().all())
-    {
-        const auto & name = setting.getName();
-        if (options.count(name))
-        {
-            if (allow_repeated_settings)
-                config().setString(name, options[name].as<Strings>().back());
-            else
-                config().setString(name, options[name].as<String>());
-        }
-    }
+    global_context->getSettingsRef().addToClientOptions(config(), options, allow_repeated_settings);
 
     if (options.count("config-file") && options.count("config"))
         throw Exception(ErrorCodes::BAD_ARGUMENTS, "Two or more configuration files referenced in arguments");

programs/format/Format.cpp

@@ -3,11 +3,12 @@
 #include <string_view>
 #include <boost/program_options.hpp>
 
-#include <IO/copyData.h>
+#include <Core/Settings.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromOStream.h>
+#include <IO/copyData.h>
 #include <Interpreters/registerInterpreters.h>
 #include <Parsers/ASTInsertQuery.h>
 #include <Parsers/ParserQuery.h>
@@ -17,7 +18,6 @@
 #include <Common/ErrorCodes.h>
 #include <Common/StringUtils.h>
 #include <Common/TerminalSize.h>
-#include <Core/BaseSettingsProgramOptions.h>
 
 #include <Interpreters/Context.h>
 #include <Functions/FunctionFactory.h>
@@ -35,6 +35,15 @@
 #include <Formats/registerFormats.h>
 #include <Processors/Transforms/getSourceFromASTInsertQuery.h>
 
+namespace DB
+{
+namespace Setting
+{
+    extern const SettingsUInt64 max_parser_backtracks;
+    extern const SettingsUInt64 max_parser_depth;
+    extern const SettingsUInt64 max_query_size;
+}
+}
 
 namespace DB::ErrorCodes
 {
@@ -99,12 +108,8 @@ int mainEntryClickHouseFormat(int argc, char ** argv)
         ;
 
         Settings cmd_settings;
-        for (const auto & field : cmd_settings.all())
-        {
-            std::string_view name = field.getName();
-            if (name == "max_parser_depth" || name == "max_query_size")
-                addProgramOption(cmd_settings, desc, name, field);
-        }
+        cmd_settings.addToProgramOptions("max_parser_depth", desc);
+        cmd_settings.addToProgramOptions("max_query_size", desc);
 
         boost::program_options::variables_map options;
         boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), options);
@@ -240,7 +245,14 @@ int mainEntryClickHouseFormat(int argc, char ** argv)
                 size_t approx_query_length = multiple ? find_first_symbols<';'>(pos, end) - pos : end - pos;
 
                 ASTPtr res = parseQueryAndMovePosition(
-                    parser, pos, end, "query", multiple, cmd_settings.max_query_size, cmd_settings.max_parser_depth, cmd_settings.max_parser_backtracks);
+                    parser,
+                    pos,
+                    end,
+                    "query",
+                    multiple,
+                    cmd_settings[Setting::max_query_size],
+                    cmd_settings[Setting::max_parser_depth],
+                    cmd_settings[Setting::max_parser_backtracks]);
 
                 std::unique_ptr<ReadBuffer> insert_query_payload;
                 /// If the query is INSERT ... VALUES, then we will try to parse the data.

programs/local/LocalServer.cpp

@@ -71,6 +71,11 @@ namespace CurrentMetrics
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_introspection_functions;
+    extern const SettingsLocalFSReadMethod storage_file_read_method;
+}
 
 namespace ErrorCodes
 {
@@ -83,8 +88,8 @@ void applySettingsOverridesForLocal(ContextMutablePtr context)
 {
     Settings settings = context->getSettingsCopy();
 
-    settings.allow_introspection_functions = true;
-    settings.storage_file_read_method = LocalFSReadMethod::mmap;
+    settings[Setting::allow_introspection_functions] = true;
+    settings[Setting::storage_file_read_method] = LocalFSReadMethod::mmap;
 
     context->setSettings(settings);
 }

programs/local/LocalServer.h

@@ -4,7 +4,6 @@
 #include <Client/LocalConnection.h>
 
 #include <Core/ServerSettings.h>
-#include <Core/Settings.h>
 #include <Interpreters/Context.h>
 #include <Loggers/Loggers.h>
 #include <Common/InterruptListener.h>

programs/odbc-bridge/ColumnInfoHandler.cpp

@@ -2,6 +2,7 @@
 
 #if USE_ODBC
 
+#include <Core/NamesAndTypes.h>
 #include <Core/Settings.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <DataTypes/DataTypeNullable.h>
@@ -27,6 +28,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 odbc_bridge_connection_pool_size;
+}
 
 namespace ErrorCodes
 {
@@ -129,8 +134,7 @@ void ODBCColumnsInfoHandler::handleRequest(HTTPServerRequest & request, HTTPServ
         const bool external_table_functions_use_nulls = Poco::NumberParser::parseBool(params.get("external_table_functions_use_nulls", "false"));
 
         auto connection_holder = ODBCPooledConnectionFactory::instance().get(
-                validateODBCConnectionString(connection_string),
-                getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+            validateODBCConnectionString(connection_string), getContext()->getSettingsRef()[Setting::odbc_bridge_connection_pool_size]);
 
         /// In XDBC tables it is allowed to pass either database_name or schema_name in table definion, but not both of them.
         /// They both are passed as 'schema' parameter in request URL, so it is not clear whether it is database_name or schema_name passed.

programs/odbc-bridge/IdentifierQuoteHandler.cpp

@@ -19,6 +19,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 odbc_bridge_connection_pool_size;
+}
+
 void IdentifierQuoteHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & /*write_event*/)
 {
     HTMLForm params(getContext()->getSettingsRef(), request, request.getStream());
@@ -68,7 +73,7 @@ void IdentifierQuoteHandler::handleRequest(HTTPServerRequest & request, HTTPServ
         nanodbc::ConnectionHolderPtr connection;
         if (use_connection_pooling)
             connection = ODBCPooledConnectionFactory::instance().get(
-                validateODBCConnectionString(connection_string), getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+                validateODBCConnectionString(connection_string), getContext()->getSettingsRef()[Setting::odbc_bridge_connection_pool_size]);
         else
             connection = std::make_shared<nanodbc::ConnectionHolder>(validateODBCConnectionString(connection_string));
 

programs/odbc-bridge/MainHandler.cpp

@@ -1,27 +1,28 @@
 #include "MainHandler.h"
 
-#include "validateODBCConnectionString.h"
-#include "ODBCSource.h"
-#include "ODBCSink.h"
-#include "getIdentifierQuote.h"
+#include <Core/Settings.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <Formats/FormatFactory.h>
-#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
-#include <IO/WriteHelpers.h>
-#include <IO/ReadHelpers.h>
-#include <Core/Settings.h>
+#include <IO/Operators.h>
 #include <IO/ReadBufferFromIStream.h>
-#include <Poco/Net/HTTPServerRequest.h>
-#include <Poco/Net/HTTPServerResponse.h>
-#include <Poco/Net/HTMLForm.h>
-#include <Poco/ThreadPool.h>
-#include <QueryPipeline/QueryPipeline.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteHelpers.h>
 #include <Processors/Executors/CompletedPipelineExecutor.h>
 #include <Processors/Formats/IInputFormat.h>
+#include <QueryPipeline/QueryPipeline.h>
+#include <Server/HTTP/HTMLForm.h>
+#include <Server/HTTP/WriteBufferFromHTTPServerResponse.h>
+#include <Poco/Net/HTMLForm.h>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
+#include <Poco/ThreadPool.h>
 #include <Common/BridgeProtocolVersion.h>
 #include <Common/logger_useful.h>
-#include <Server/HTTP/HTMLForm.h>
+#include "ODBCSink.h"
+#include "ODBCSource.h"
 #include "config.h"
+#include "getIdentifierQuote.h"
+#include "validateODBCConnectionString.h"
 
 #include <mutex>
 #include <memory>
@@ -29,6 +30,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 odbc_bridge_connection_pool_size;
+}
 
 namespace
 {
@@ -139,7 +144,7 @@ void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
         nanodbc::ConnectionHolderPtr connection_handler;
         if (use_connection_pooling)
             connection_handler = ODBCPooledConnectionFactory::instance().get(
-                validateODBCConnectionString(connection_string), getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+                validateODBCConnectionString(connection_string), getContext()->getSettingsRef()[Setting::odbc_bridge_connection_pool_size]);
         else
             connection_handler = std::make_shared<nanodbc::ConnectionHolder>(validateODBCConnectionString(connection_string));
 

programs/odbc-bridge/SchemaAllowedHandler.cpp

@@ -20,6 +20,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 odbc_bridge_connection_pool_size;
+}
+
 namespace
 {
     bool isSchemaAllowed(nanodbc::ConnectionHolderPtr connection_holder)
@@ -82,7 +87,7 @@ void SchemaAllowedHandler::handleRequest(HTTPServerRequest & request, HTTPServer
 
         if (use_connection_pooling)
             connection = ODBCPooledConnectionFactory::instance().get(
-                validateODBCConnectionString(connection_string), getContext()->getSettingsRef().odbc_bridge_connection_pool_size);
+                validateODBCConnectionString(connection_string), getContext()->getSettingsRef()[Setting::odbc_bridge_connection_pool_size]);
         else
             connection = std::make_shared<nanodbc::ConnectionHolder>(validateODBCConnectionString(connection_string));
 

programs/server/Server.cpp

@@ -148,6 +148,18 @@
 /// A minimal file used when the server is run without installation
 INCBIN(resource_embedded_xml, SOURCE_DIR "/programs/server/embedded.xml");
 
+namespace DB
+{
+namespace Setting
+{
+    extern const SettingsSeconds http_receive_timeout;
+    extern const SettingsSeconds http_send_timeout;
+    extern const SettingsSeconds receive_timeout;
+    extern const SettingsSeconds send_timeout;
+}
+
+}
+
 namespace CurrentMetrics
 {
     extern const Metric Revision;
@@ -1831,10 +1843,13 @@ try
                         "Keeper (tcp): " + address.toString(),
                         std::make_unique<TCPServer>(
                             new KeeperTCPHandlerFactory(
-                                config_getter, global_context->getKeeperDispatcher(),
-                                global_context->getSettingsRef().receive_timeout.totalSeconds(),
-                                global_context->getSettingsRef().send_timeout.totalSeconds(),
-                                false), server_pool, socket));
+                                config_getter,
+                                global_context->getKeeperDispatcher(),
+                                global_context->getSettingsRef()[Setting::receive_timeout].totalSeconds(),
+                                global_context->getSettingsRef()[Setting::send_timeout].totalSeconds(),
+                                false),
+                            server_pool,
+                            socket));
                 });
 
             const char * secure_port_name = "keeper_server.tcp_port_secure";
@@ -1854,9 +1869,13 @@ try
                         "Keeper with secure protocol (tcp_secure): " + address.toString(),
                         std::make_unique<TCPServer>(
                             new KeeperTCPHandlerFactory(
-                                config_getter, global_context->getKeeperDispatcher(),
-                                global_context->getSettingsRef().receive_timeout.totalSeconds(),
-                                global_context->getSettingsRef().send_timeout.totalSeconds(), true), server_pool, socket));
+                                config_getter,
+                                global_context->getKeeperDispatcher(),
+                                global_context->getSettingsRef()[Setting::receive_timeout].totalSeconds(),
+                                global_context->getSettingsRef()[Setting::send_timeout].totalSeconds(),
+                                true),
+                            server_pool,
+                            socket));
 #else
                     UNUSED(port);
                     throw Exception(ErrorCodes::SUPPORT_IS_DISABLED, "SSL support for TCP protocol is disabled because Poco library was built without NetSSL support.");
@@ -2430,7 +2449,7 @@ void Server::createServers(
     const Settings & settings = global_context->getSettingsRef();
 
     Poco::Net::HTTPServerParams::Ptr http_params = new Poco::Net::HTTPServerParams;
-    http_params->setTimeout(settings.http_receive_timeout);
+    http_params->setTimeout(settings[Setting::http_receive_timeout]);
     http_params->setKeepAliveTimeout(global_context->getServerSettings().keep_alive_timeout);
     http_params->setMaxKeepAliveRequests(static_cast<int>(global_context->getServerSettings().max_keep_alive_requests));
 
@@ -2469,8 +2488,8 @@ void Server::createServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, host, port, is_secure);
-                socket.setReceiveTimeout(settings.receive_timeout);
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setReceiveTimeout(settings[Setting::receive_timeout]);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
 
                 return ProtocolServerAdapter(
                     host,
@@ -2497,8 +2516,8 @@ void Server::createServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port);
-                socket.setReceiveTimeout(settings.http_receive_timeout);
-                socket.setSendTimeout(settings.http_send_timeout);
+                socket.setReceiveTimeout(settings[Setting::http_receive_timeout]);
+                socket.setSendTimeout(settings[Setting::http_send_timeout]);
 
                 return ProtocolServerAdapter(
                     listen_host,
@@ -2518,8 +2537,8 @@ void Server::createServers(
 #if USE_SSL
                 Poco::Net::SecureServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port, /* secure = */ true);
-                socket.setReceiveTimeout(settings.http_receive_timeout);
-                socket.setSendTimeout(settings.http_send_timeout);
+                socket.setReceiveTimeout(settings[Setting::http_receive_timeout]);
+                socket.setSendTimeout(settings[Setting::http_send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2541,8 +2560,8 @@ void Server::createServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port);
-                socket.setReceiveTimeout(settings.receive_timeout);
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setReceiveTimeout(settings[Setting::receive_timeout]);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2563,8 +2582,8 @@ void Server::createServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port);
-                socket.setReceiveTimeout(settings.receive_timeout);
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setReceiveTimeout(settings[Setting::receive_timeout]);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2586,8 +2605,8 @@ void Server::createServers(
     #if USE_SSL
                 Poco::Net::SecureServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port, /* secure = */ true);
-                socket.setReceiveTimeout(settings.receive_timeout);
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setReceiveTimeout(settings[Setting::receive_timeout]);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2612,7 +2631,7 @@ void Server::createServers(
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port, /* secure = */ true);
                 socket.setReceiveTimeout(Poco::Timespan());
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2629,7 +2648,7 @@ void Server::createServers(
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port, /* secure = */ true);
                 socket.setReceiveTimeout(Poco::Timespan());
-                socket.setSendTimeout(settings.send_timeout);
+                socket.setSendTimeout(settings[Setting::send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2661,8 +2680,8 @@ void Server::createServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, listen_host, port);
-                socket.setReceiveTimeout(settings.http_receive_timeout);
-                socket.setSendTimeout(settings.http_send_timeout);
+                socket.setReceiveTimeout(settings[Setting::http_receive_timeout]);
+                socket.setSendTimeout(settings[Setting::http_send_timeout]);
                 return ProtocolServerAdapter(
                     listen_host,
                     port_name,
@@ -2687,7 +2706,7 @@ void Server::createInterserverServers(
     const Settings & settings = global_context->getSettingsRef();
 
     Poco::Net::HTTPServerParams::Ptr http_params = new Poco::Net::HTTPServerParams;
-    http_params->setTimeout(settings.http_receive_timeout);
+    http_params->setTimeout(settings[Setting::http_receive_timeout]);
     http_params->setKeepAliveTimeout(global_context->getServerSettings().keep_alive_timeout);
 
     /// Now iterate over interserver_listen_hosts
@@ -2703,8 +2722,8 @@ void Server::createInterserverServers(
             {
                 Poco::Net::ServerSocket socket;
                 auto address = socketBindListen(config, socket, interserver_listen_host, port);
-                socket.setReceiveTimeout(settings.http_receive_timeout);
-                socket.setSendTimeout(settings.http_send_timeout);
+                socket.setReceiveTimeout(settings[Setting::http_receive_timeout]);
+                socket.setSendTimeout(settings[Setting::http_send_timeout]);
                 return ProtocolServerAdapter(
                     interserver_listen_host,
                     port_name,
@@ -2728,8 +2747,8 @@ void Server::createInterserverServers(
 #if USE_SSL
                 Poco::Net::SecureServerSocket socket;
                 auto address = socketBindListen(config, socket, interserver_listen_host, port, /* secure = */ true);
-                socket.setReceiveTimeout(settings.http_receive_timeout);
-                socket.setSendTimeout(settings.http_send_timeout);
+                socket.setReceiveTimeout(settings[Setting::http_receive_timeout]);
+                socket.setSendTimeout(settings[Setting::http_send_timeout]);
                 return ProtocolServerAdapter(
                     interserver_listen_host,
                     port_name,

src/Access/AccessBackup.cpp

@@ -29,6 +29,7 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int CANNOT_RESTORE_TABLE;
+    extern const int ACCESS_ENTITY_ALREADY_EXISTS;
     extern const int LOGICAL_ERROR;
 }
 
@@ -175,9 +176,46 @@ namespace
         return res;
     }
 
-    std::unordered_map<UUID, UUID> resolveDependencies(const std::unordered_map<UUID, std::pair<String, AccessEntityType>> & dependencies, const AccessControl & access_control, bool allow_unresolved_dependencies)
+    /// Checks if new entities (which we're going to restore) already exist,
+    /// and either skips them or throws an exception depending on the restore settings.
+    void checkExistingEntities(std::vector<std::pair<UUID, AccessEntityPtr>> & entities,
+                               std::unordered_map<UUID, UUID> & old_to_new_id,
+                               const AccessControl & access_control,
+                               RestoreAccessCreationMode creation_mode)
+    {
+        if (creation_mode == RestoreAccessCreationMode::kReplace)
+            return;
+
+        auto should_skip = [&](const std::pair<UUID, AccessEntityPtr> & id_and_entity)
+        {
+            const auto & id = id_and_entity.first;
+            const auto & entity = *id_and_entity.second;
+            auto existing_id = access_control.find(entity.getType(), entity.getName());
+            if (!existing_id)
+            {
+                return false;
+            }
+            else if (creation_mode == RestoreAccessCreationMode::kCreateIfNotExists)
+            {
+                old_to_new_id[id] = *existing_id;
+                return true;
+            }
+            else
+            {
+                throw Exception(ErrorCodes::ACCESS_ENTITY_ALREADY_EXISTS, "Cannot restore {} because it already exists", entity.formatTypeWithName());
+            }
+        };
+
+        std::erase_if(entities, should_skip);
+    }
+
+    /// If new entities (which we're going to restore) depend on other entities which are not going to be restored or not present in the backup
+    /// then we should try to replace those dependencies with already existing entities.
+    void resolveDependencies(const std::unordered_map<UUID, std::pair<String, AccessEntityType>> & dependencies,
+                             std::unordered_map<UUID, UUID> & old_to_new_ids,
+                             const AccessControl & access_control,
+                             bool allow_unresolved_dependencies)
     {
-        std::unordered_map<UUID, UUID> old_to_new_ids;
         for (const auto & [id, name_and_type] : dependencies)
         {
             std::optional<UUID> new_id;
@@ -188,9 +226,9 @@ namespace
             if (new_id)
                 old_to_new_ids.emplace(id, *new_id);
         }
-        return old_to_new_ids;
     }
 
+    /// Generates random IDs for the new entities.
     void generateRandomIDs(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, std::unordered_map<UUID, UUID> & old_to_new_ids)
     {
         Poco::UUIDGenerator generator;
@@ -203,27 +241,12 @@ namespace
         }
     }
 
-    void replaceDependencies(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, const std::unordered_map<UUID, UUID> & old_to_new_ids)
+    /// Updates dependencies of the new entities using a specified map.
+    void replaceDependencies(std::vector<std::pair<UUID, AccessEntityPtr>> & entities,
+                             const std::unordered_map<UUID, UUID> & old_to_new_ids)
     {
         for (auto & entity : entities | boost::adaptors::map_values)
-        {
-            bool need_replace = false;
-            for (const auto & dependency : entity->findDependencies())
-            {
-                if (old_to_new_ids.contains(dependency))
-                {
-                    need_replace = true;
-                    break;
-                }
-            }
-
-            if (!need_replace)
-                continue;
-
-            auto new_entity = entity->clone();
-            new_entity->replaceDependencies(old_to_new_ids);
-            entity = new_entity;
-        }
+            IAccessEntity::replaceDependencies(entity, old_to_new_ids);
     }
 
     AccessRightsElements getRequiredAccessToRestore(const std::vector<std::pair<UUID, AccessEntityPtr>> & entities)
@@ -314,7 +337,9 @@ std::pair<String, BackupEntryPtr> makeBackupEntryForAccess(
 
 AccessRestorerFromBackup::AccessRestorerFromBackup(
     const BackupPtr & backup_, const RestoreSettings & restore_settings_)
-    : backup(backup_), allow_unresolved_access_dependencies(restore_settings_.allow_unresolved_access_dependencies)
+    : backup(backup_)
+    , creation_mode(restore_settings_.create_access)
+    , allow_unresolved_dependencies(restore_settings_.allow_unresolved_access_dependencies)
 {
 }
 
@@ -362,7 +387,9 @@ std::vector<std::pair<UUID, AccessEntityPtr>> AccessRestorerFromBackup::getAcces
 {
     auto new_entities = entities;
 
-    auto old_to_new_ids = resolveDependencies(dependencies, access_control, allow_unresolved_access_dependencies);
+    std::unordered_map<UUID, UUID> old_to_new_ids;
+    checkExistingEntities(new_entities, old_to_new_ids, access_control, creation_mode);
+    resolveDependencies(dependencies, old_to_new_ids, access_control, allow_unresolved_dependencies);
     generateRandomIDs(new_entities, old_to_new_ids);
     replaceDependencies(new_entities, old_to_new_ids);
 

src/Access/AccessBackup.h

@@ -17,6 +17,7 @@ using BackupPtr = std::shared_ptr<const IBackup>;
 class IBackupEntry;
 using BackupEntryPtr = std::shared_ptr<const IBackupEntry>;
 struct RestoreSettings;
+enum class RestoreAccessCreationMode : uint8_t;
 
 
 /// Makes a backup of access entities of a specified type.
@@ -45,7 +46,8 @@ public:
 
 private:
     BackupPtr backup;
-    bool allow_unresolved_access_dependencies = false;
+    RestoreAccessCreationMode creation_mode;
+    bool allow_unresolved_dependencies = false;
     std::vector<std::pair<UUID, AccessEntityPtr>> entities;
     std::unordered_map<UUID, std::pair<String, AccessEntityType>> dependencies;
     std::unordered_set<String> data_paths;

src/Access/AccessControl.cpp

@@ -544,9 +544,9 @@ scope_guard AccessControl::subscribeForChanges(const std::vector<UUID> & ids, co
     return changes_notifier->subscribeForChanges(ids, handler);
 }
 
-bool AccessControl::insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists)
+bool AccessControl::insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
-    if (MultipleAccessStorage::insertImpl(id, entity, replace_if_exists, throw_if_exists))
+    if (MultipleAccessStorage::insertImpl(id, entity, replace_if_exists, throw_if_exists, conflicting_id))
     {
         changes_notifier->sendNotifications();
         return true;

src/Access/AccessControl.h

@@ -243,7 +243,7 @@ private:
     class CustomSettingsPrefixes;
     class PasswordComplexityRules;
 
-    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists) override;
+    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id) override;
     bool removeImpl(const UUID & id, bool throw_if_not_exists) override;
     bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists) override;
 

src/Access/ContextAccessParams.cpp

@@ -1,10 +1,17 @@
 #include <Access/ContextAccessParams.h>
 #include <Core/Settings.h>
+#include <IO/Operators.h>
 #include <Common/typeid_cast.h>
 
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_ddl;
+    extern const SettingsBool allow_introspection_functions;
+    extern const SettingsUInt64 readonly;
+}
 
 ContextAccessParams::ContextAccessParams(
     std::optional<UUID> user_id_,
@@ -18,9 +25,9 @@ ContextAccessParams::ContextAccessParams(
     , full_access(full_access_)
     , use_default_roles(use_default_roles_)
     , current_roles(current_roles_)
-    , readonly(settings_.readonly)
-    , allow_ddl(settings_.allow_ddl)
-    , allow_introspection(settings_.allow_introspection_functions)
+    , readonly(settings_[Setting::readonly])
+    , allow_ddl(settings_[Setting::allow_ddl])
+    , allow_introspection(settings_[Setting::allow_introspection_functions])
     , current_database(current_database_)
     , interface(client_info_.interface)
     , http_method(client_info_.http_method)

src/Access/DiskAccessStorage.cpp

@@ -1,8 +1,6 @@
 #include <Access/DiskAccessStorage.h>
 #include <Access/AccessEntityIO.h>
 #include <Access/AccessChangesNotifier.h>
-#include <Backups/RestorerFromBackup.h>
-#include <Backups/RestoreSettings.h>
 #include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
 #include <IO/ReadBufferFromFile.h>
@@ -418,7 +416,7 @@ void DiskAccessStorage::setAllInMemory(const std::vector<std::pair<UUID, AccessE
 
     /// Insert or update entities.
     for (const auto & [id, entity] : entities_without_conflicts)
-        insertNoLock(id, entity, /* replace_if_exists = */ true, /* throw_if_exists = */ false, /* write_on_disk= */ false);
+        insertNoLock(id, entity, /* replace_if_exists = */ true, /* throw_if_exists = */ false, /* conflicting_id = */ nullptr, /* write_on_disk= */ false);
 }
 
 void DiskAccessStorage::removeAllExceptInMemory(const boost::container::flat_set<UUID> & ids_to_keep)
@@ -507,14 +505,14 @@ std::optional<std::pair<String, AccessEntityType>> DiskAccessStorage::readNameWi
 }
 
 
-bool DiskAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists)
+bool DiskAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     std::lock_guard lock{mutex};
-    return insertNoLock(id, new_entity, replace_if_exists, throw_if_exists, /* write_on_disk = */ true);
+    return insertNoLock(id, new_entity, replace_if_exists, throw_if_exists, conflicting_id, /* write_on_disk = */ true);
 }
 
 
-bool DiskAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, bool write_on_disk)
+bool DiskAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id, bool write_on_disk)
 {
     const String & name = new_entity->getName();
     AccessEntityType type = new_entity->getType();
@@ -533,9 +531,15 @@ bool DiskAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & ne
     if (name_collision && !replace_if_exists)
     {
         if (throw_if_exists)
+        {
             throwNameCollisionCannotInsert(type, name);
+        }
         else
+        {
+            if (conflicting_id)
+                *conflicting_id = id_by_name;
             return false;
+        }
     }
 
     auto it_by_id = entries_by_id.find(id);
@@ -548,7 +552,11 @@ bool DiskAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & ne
             throwIDCollisionCannotInsert(id, type, name, existing_entry.type, existing_entry.name);
         }
         else
+        {
+            if (conflicting_id)
+                *conflicting_id = id;
             return false;
+        }
     }
 
     if (write_on_disk)
@@ -727,25 +735,4 @@ void DiskAccessStorage::deleteAccessEntityOnDisk(const UUID & id) const
         throw Exception(ErrorCodes::FILE_DOESNT_EXIST, "Couldn't delete {}", file_path);
 }
 
-
-void DiskAccessStorage::restoreFromBackup(RestorerFromBackup & restorer)
-{
-    if (!isRestoreAllowed())
-        throwRestoreNotAllowed();
-
-    auto entities = restorer.getAccessEntitiesToRestore();
-    if (entities.empty())
-        return;
-
-    auto create_access = restorer.getRestoreSettings().create_access;
-    bool replace_if_exists = (create_access == RestoreAccessCreationMode::kReplace);
-    bool throw_if_exists = (create_access == RestoreAccessCreationMode::kCreate);
-
-    restorer.addDataRestoreTask([this, my_entities = std::move(entities), replace_if_exists, throw_if_exists]
-    {
-        for (const auto & [id, entity] : my_entities)
-            insert(id, entity, replace_if_exists, throw_if_exists);
-    });
-}
-
 }

src/Access/DiskAccessStorage.h

@@ -34,14 +34,13 @@ public:
     bool exists(const UUID & id) const override;
 
     bool isBackupAllowed() const override { return backup_allowed; }
-    void restoreFromBackup(RestorerFromBackup & restorer) override;
 
 private:
     std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
     std::vector<UUID> findAllImpl(AccessEntityType type) const override;
     AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
     std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
-    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists) override;
+    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id) override;
     bool removeImpl(const UUID & id, bool throw_if_not_exists) override;
     bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists) override;
 
@@ -55,7 +54,7 @@ private:
     void listsWritingThreadFunc() TSA_NO_THREAD_SAFETY_ANALYSIS;
     void stopListsWritingThread();
 
-    bool insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, bool write_on_disk) TSA_REQUIRES(mutex);
+    bool insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id, bool write_on_disk) TSA_REQUIRES(mutex);
     bool updateNoLock(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists, bool write_on_disk) TSA_REQUIRES(mutex);
     bool removeNoLock(const UUID & id, bool throw_if_not_exists, bool write_on_disk) TSA_REQUIRES(mutex);
 

src/Access/IAccessEntity.cpp

@@ -9,4 +9,28 @@ bool IAccessEntity::equal(const IAccessEntity & other) const
     return (name == other.name) && (getType() == other.getType());
 }
 
+void IAccessEntity::replaceDependencies(std::shared_ptr<const IAccessEntity> & entity, const std::unordered_map<UUID, UUID> & old_to_new_ids)
+{
+    if (old_to_new_ids.empty())
+        return;
+
+    bool need_replace_dependencies = false;
+    auto dependencies = entity->findDependencies();
+    for (const auto & dependency : dependencies)
+    {
+        if (old_to_new_ids.contains(dependency))
+        {
+            need_replace_dependencies = true;
+            break;
+        }
+    }
+
+    if (!need_replace_dependencies)
+        return;
+
+    auto new_entity = entity->clone();
+    new_entity->replaceDependencies(old_to_new_ids);
+    entity = new_entity;
+}
+
 }

src/Access/IAccessEntity.h

@@ -50,7 +50,8 @@ struct IAccessEntity
     virtual std::vector<UUID> findDependencies() const { return {}; }
 
     /// Replaces dependencies according to a specified map.
-    virtual void replaceDependencies(const std::unordered_map<UUID, UUID> & /* old_to_new_ids */) {}
+    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) { doReplaceDependencies(old_to_new_ids); }
+    static void replaceDependencies(std::shared_ptr<const IAccessEntity> & entity, const std::unordered_map<UUID, UUID> & old_to_new_ids);
 
     /// Whether this access entity should be written to a backup.
     virtual bool isBackupAllowed() const { return false; }
@@ -66,6 +67,8 @@ protected:
     {
         return std::make_shared<EntityClassT>(typeid_cast<const EntityClassT &>(*this));
     }
+
+    virtual void doReplaceDependencies(const std::unordered_map<UUID, UUID> & /* old_to_new_ids */) {}
 };
 
 using AccessEntityPtr = std::shared_ptr<const IAccessEntity>;

src/Access/IAccessStorage.cpp

@@ -4,6 +4,8 @@
 #include <Access/User.h>
 #include <Access/AccessBackup.h>
 #include <Backups/BackupEntriesCollector.h>
+#include <Backups/RestorerFromBackup.h>
+#include <Backups/RestoreSettings.h>
 #include <Common/Exception.h>
 #include <Common/quoteString.h>
 #include <Common/callOnce.h>
@@ -14,10 +16,11 @@
 #include <base/FnTraits.h>
 #include <boost/algorithm/string/join.hpp>
 #include <boost/algorithm/string/replace.hpp>
+#include <boost/range/adaptor/map.hpp>
 #include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/algorithm/copy.hpp>
 #include <boost/range/algorithm_ext/erase.hpp>
 
-
 namespace DB
 {
 namespace ErrorCodes
@@ -178,20 +181,20 @@ UUID IAccessStorage::insert(const AccessEntityPtr & entity)
     return *insert(entity, /* replace_if_exists = */ false, /* throw_if_exists = */ true);
 }
 
-std::optional<UUID> IAccessStorage::insert(const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists)
+std::optional<UUID> IAccessStorage::insert(const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     auto id = generateRandomID();
 
-    if (insert(id, entity, replace_if_exists, throw_if_exists))
+    if (insert(id, entity, replace_if_exists, throw_if_exists, conflicting_id))
         return id;
 
     return std::nullopt;
 }
 
 
-bool IAccessStorage::insert(const DB::UUID & id, const DB::AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists)
+bool IAccessStorage::insert(const DB::UUID & id, const DB::AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
-    return insertImpl(id, entity, replace_if_exists, throw_if_exists);
+    return insertImpl(id, entity, replace_if_exists, throw_if_exists, conflicting_id);
 }
 
 
@@ -285,7 +288,7 @@ std::vector<UUID> IAccessStorage::insertOrReplace(const std::vector<AccessEntity
 }
 
 
-bool IAccessStorage::insertImpl(const UUID &, const AccessEntityPtr & entity, bool, bool)
+bool IAccessStorage::insertImpl(const UUID &, const AccessEntityPtr & entity, bool, bool, UUID *)
 {
     if (isReadOnly())
         throwReadonlyCannotInsert(entity->getType(), entity->getName());
@@ -611,12 +614,51 @@ void IAccessStorage::backup(BackupEntriesCollector & backup_entries_collector, c
 }
 
 
-void IAccessStorage::restoreFromBackup(RestorerFromBackup &)
+void IAccessStorage::restoreFromBackup(RestorerFromBackup & restorer)
 {
     if (!isRestoreAllowed())
         throwRestoreNotAllowed();
 
-    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "restoreFromBackup() is not implemented in {}", getStorageType());
+    if (isReplicated() && !acquireReplicatedRestore(restorer))
+        return;
+
+    auto entities = restorer.getAccessEntitiesToRestore();
+    if (entities.empty())
+        return;
+
+    auto create_access = restorer.getRestoreSettings().create_access;
+    bool replace_if_exists = (create_access == RestoreAccessCreationMode::kReplace);
+    bool throw_if_exists = (create_access == RestoreAccessCreationMode::kCreate);
+
+    restorer.addDataRestoreTask([this, entities_to_restore = std::move(entities), replace_if_exists, throw_if_exists] mutable
+    {
+        std::unordered_map<UUID, UUID> new_to_existing_ids;
+        for (auto & [id, entity] : entities_to_restore)
+        {
+            UUID existing_entity_id;
+            if (!insert(id, entity, replace_if_exists, throw_if_exists, &existing_entity_id))
+            {
+                /// Couldn't insert `entity` because there is an existing entity with the same name.
+                new_to_existing_ids[id] = existing_entity_id;
+            }
+        }
+
+        if (!new_to_existing_ids.empty())
+        {
+            /// If new entities restored from backup have dependencies on other entities from backup which were not restored because they existed,
+            /// then we should correct those dependencies.
+            auto update_func = [&](const AccessEntityPtr & entity) -> AccessEntityPtr
+            {
+                auto res = entity;
+                IAccessEntity::replaceDependencies(res, new_to_existing_ids);
+                return res;
+            };
+            std::vector<UUID> ids;
+            ids.reserve(entities_to_restore.size());
+            boost::copy(entities_to_restore | boost::adaptors::map_keys, std::back_inserter(ids));
+            tryUpdate(ids, update_func);
+        }
+    });
 }
 
 

src/Access/IAccessStorage.h

@@ -64,6 +64,9 @@ public:
     /// Returns true if this entity is readonly.
     virtual bool isReadOnly(const UUID &) const { return isReadOnly(); }
 
+    /// Returns true if this storage is replicated.
+    virtual bool isReplicated() const { return false; }
+
     /// Starts periodic reloading and updating of entities in this storage.
     virtual void startPeriodicReloading() {}
 
@@ -153,8 +156,8 @@ public:
     /// Inserts an entity to the storage. Returns ID of a new entry in the storage.
     /// Throws an exception if the specified name already exists.
     UUID insert(const AccessEntityPtr & entity);
-    std::optional<UUID> insert(const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists);
-    bool insert(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists);
+    std::optional<UUID> insert(const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id = nullptr);
+    bool insert(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id = nullptr);
     std::vector<UUID> insert(const std::vector<AccessEntityPtr> & multiple_entities, bool replace_if_exists = false, bool throw_if_exists = true);
     std::vector<UUID> insert(const std::vector<AccessEntityPtr> & multiple_entities, const std::vector<UUID> & ids, bool replace_if_exists = false, bool throw_if_exists = true);
 
@@ -218,7 +221,7 @@ protected:
     virtual std::vector<UUID> findAllImpl(AccessEntityType type) const = 0;
     virtual AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const = 0;
     virtual std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const;
-    virtual bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists);
+    virtual bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id);
     virtual bool removeImpl(const UUID & id, bool throw_if_not_exists);
     virtual bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists);
     virtual std::optional<AuthResult> authenticateImpl(
@@ -240,6 +243,7 @@ protected:
     LoggerPtr getLogger() const;
     static String formatEntityTypeWithName(AccessEntityType type, const String & name) { return AccessEntityTypeInfo::get(type).formatEntityNameWithType(name); }
     static void clearConflictsInEntitiesList(std::vector<std::pair<UUID, AccessEntityPtr>> & entities, LoggerPtr log_);
+    virtual bool acquireReplicatedRestore(RestorerFromBackup &) const { return false; }
     [[noreturn]] void throwNotFound(const UUID & id) const;
     [[noreturn]] void throwNotFound(AccessEntityType type, const String & name) const;
     [[noreturn]] static void throwBadCast(const UUID & id, AccessEntityType type, const String & name, AccessEntityType required_type);

src/Access/MemoryAccessStorage.cpp

@@ -1,7 +1,5 @@
 #include <Access/MemoryAccessStorage.h>
 #include <Access/AccessChangesNotifier.h>
-#include <Backups/RestorerFromBackup.h>
-#include <Backups/RestoreSettings.h>
 #include <base/scope_guard.h>
 #include <boost/container/flat_set.hpp>
 #include <boost/range/adaptor/map.hpp>
@@ -63,14 +61,14 @@ AccessEntityPtr MemoryAccessStorage::readImpl(const UUID & id, bool throw_if_not
 }
 
 
-bool MemoryAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists)
+bool MemoryAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     std::lock_guard lock{mutex};
-    return insertNoLock(id, new_entity, replace_if_exists, throw_if_exists);
+    return insertNoLock(id, new_entity, replace_if_exists, throw_if_exists, conflicting_id);
 }
 
 
-bool MemoryAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists)
+bool MemoryAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     const String & name = new_entity->getName();
     AccessEntityType type = new_entity->getType();
@@ -86,9 +84,15 @@ bool MemoryAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr &
     if (name_collision && !replace_if_exists)
     {
         if (throw_if_exists)
+        {
             throwNameCollisionCannotInsert(type, name);
+        }
         else
+        {
+            if (conflicting_id)
+                *conflicting_id = id_by_name;
             return false;
+        }
     }
 
     auto it_by_id = entries_by_id.find(id);
@@ -97,9 +101,15 @@ bool MemoryAccessStorage::insertNoLock(const UUID & id, const AccessEntityPtr &
     {
         const auto & existing_entry = it_by_id->second;
         if (throw_if_exists)
+        {
             throwIDCollisionCannotInsert(id, type, name, existing_entry.entity->getType(), existing_entry.entity->getName());
+        }
         else
+        {
+            if (conflicting_id)
+                *conflicting_id = id;
             return false;
+        }
     }
 
     /// Remove collisions if necessary.
@@ -270,28 +280,7 @@ void MemoryAccessStorage::setAll(const std::vector<std::pair<UUID, AccessEntityP
 
     /// Insert or update entities.
     for (const auto & [id, entity] : entities_without_conflicts)
-        insertNoLock(id, entity, /* replace_if_exists = */ true, /* throw_if_exists = */ false);
-}
-
-
-void MemoryAccessStorage::restoreFromBackup(RestorerFromBackup & restorer)
-{
-    if (!isRestoreAllowed())
-        throwRestoreNotAllowed();
-
-    auto entities = restorer.getAccessEntitiesToRestore();
-    if (entities.empty())
-        return;
-
-    auto create_access = restorer.getRestoreSettings().create_access;
-    bool replace_if_exists = (create_access == RestoreAccessCreationMode::kReplace);
-    bool throw_if_exists = (create_access == RestoreAccessCreationMode::kCreate);
-
-    restorer.addDataRestoreTask([this, my_entities = std::move(entities), replace_if_exists, throw_if_exists]
-    {
-        for (const auto & [id, entity] : my_entities)
-            insert(id, entity, replace_if_exists, throw_if_exists);
-    });
+        insertNoLock(id, entity, /* replace_if_exists = */ true, /* throw_if_exists = */ false, /* conflicting_id = */ nullptr);
 }
 
 }

src/Access/MemoryAccessStorage.h

@@ -34,17 +34,16 @@ public:
     bool exists(const UUID & id) const override;
 
     bool isBackupAllowed() const override { return backup_allowed; }
-    void restoreFromBackup(RestorerFromBackup & restorer) override;
 
 private:
     std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
     std::vector<UUID> findAllImpl(AccessEntityType type) const override;
     AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
-    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists) override;
+    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id) override;
     bool removeImpl(const UUID & id, bool throw_if_not_exists) override;
     bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists) override;
 
-    bool insertNoLock(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists);
+    bool insertNoLock(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id);
     bool removeNoLock(const UUID & id, bool throw_if_not_exists);
     bool updateNoLock(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists);
 

src/Access/MultipleAccessStorage.cpp

@@ -353,7 +353,7 @@ void MultipleAccessStorage::reload(ReloadMode reload_mode)
 }
 
 
-bool MultipleAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists)
+bool MultipleAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     std::shared_ptr<IAccessStorage> storage_for_insertion;
 
@@ -376,7 +376,7 @@ bool MultipleAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr &
             getStorageName());
     }
 
-    if (storage_for_insertion->insert(id, entity, replace_if_exists, throw_if_exists))
+    if (storage_for_insertion->insert(id, entity, replace_if_exists, throw_if_exists, conflicting_id))
     {
         std::lock_guard lock{mutex};
         ids_cache.set(id, storage_for_insertion);

src/Access/MultipleAccessStorage.h

@@ -67,7 +67,7 @@ protected:
     std::vector<UUID> findAllImpl(AccessEntityType type) const override;
     AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
     std::optional<std::pair<String, AccessEntityType>> readNameWithTypeImpl(const UUID & id, bool throw_if_not_exists) const override;
-    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists) override;
+    bool insertImpl(const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id) override;
     bool removeImpl(const UUID & id, bool throw_if_not_exists) override;
     bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists) override;
     std::optional<AuthResult> authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators, bool throw_if_user_not_exists, bool allow_no_password, bool allow_plaintext_password) const override;

src/Access/Quota.cpp

@@ -24,7 +24,7 @@ std::vector<UUID> Quota::findDependencies() const
     return to_roles.findDependencies();
 }
 
-void Quota::replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
+void Quota::doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
 {
     to_roles.replaceDependencies(old_to_new_ids);
 }

src/Access/Quota.h

@@ -47,7 +47,7 @@ struct Quota : public IAccessEntity
     AccessEntityType getType() const override { return TYPE; }
 
     std::vector<UUID> findDependencies() const override;
-    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
+    void doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
     bool isBackupAllowed() const override { return true; }
 };
 

src/Access/ReplicatedAccessStorage.cpp

@@ -5,10 +5,9 @@
 #include <Access/AccessChangesNotifier.h>
 #include <Access/AccessBackup.h>
 #include <Backups/BackupEntriesCollector.h>
-#include <Backups/RestorerFromBackup.h>
-#include <Backups/RestoreSettings.h>
 #include <Backups/IBackupCoordination.h>
 #include <Backups/IRestoreCoordination.h>
+#include <Backups/RestorerFromBackup.h>
 #include <IO/ReadHelpers.h>
 #include <Interpreters/Context.h>
 #include <Common/ZooKeeper/KeeperException.h>
@@ -120,7 +119,7 @@ static void retryOnZooKeeperUserError(size_t attempts, Func && function)
     }
 }
 
-bool ReplicatedAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists)
+bool ReplicatedAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id)
 {
     const AccessEntityTypeInfo type_info = AccessEntityTypeInfo::get(new_entity->getType());
     const String & name = new_entity->getName();
@@ -128,7 +127,7 @@ bool ReplicatedAccessStorage::insertImpl(const UUID & id, const AccessEntityPtr
 
     auto zookeeper = getZooKeeper();
     bool ok = false;
-    retryOnZooKeeperUserError(10, [&]{ ok = insertZooKeeper(zookeeper, id, new_entity, replace_if_exists, throw_if_exists); });
+    retryOnZooKeeperUserError(10, [&]{ ok = insertZooKeeper(zookeeper, id, new_entity, replace_if_exists, throw_if_exists, conflicting_id); });
 
     if (!ok)
         return false;
@@ -143,7 +142,8 @@ bool ReplicatedAccessStorage::insertZooKeeper(
     const UUID & id,
     const AccessEntityPtr & new_entity,
     bool replace_if_exists,
-    bool throw_if_exists)
+    bool throw_if_exists,
+    UUID * conflicting_id)
 {
     const String & name = new_entity->getName();
     const AccessEntityType type = new_entity->getType();
@@ -167,27 +167,52 @@ bool ReplicatedAccessStorage::insertZooKeeper(
 
     if (res == Coordination::Error::ZNODEEXISTS)
     {
-        if (!throw_if_exists && !replace_if_exists)
-            return false; /// Couldn't insert a new entity.
-
-        if (throw_if_exists)
+        if (!replace_if_exists)
         {
             if (responses[0]->error == Coordination::Error::ZNODEEXISTS)
             {
-                /// To fail with a nice error message, we need info about what already exists.
-                /// This itself could fail if the conflicting uuid disappears in the meantime.
-                /// If that happens, then we'll just retry from the start.
-                String existing_entity_definition = zookeeper->get(entity_path);
+                /// Couldn't insert the new entity because there is an existing entity with such UUID.
+                if (throw_if_exists)
+                {
+                    /// To fail with a nice error message, we need info about what already exists.
+                    /// This itself can fail if the conflicting uuid disappears in the meantime.
+                    /// If that happens, then retryOnZooKeeperUserError() will just retry the operation from the start.
+                    String existing_entity_definition = zookeeper->get(entity_path);
 
-                AccessEntityPtr existing_entity = deserializeAccessEntity(existing_entity_definition, entity_path);
-                AccessEntityType existing_type = existing_entity->getType();
-                String existing_name = existing_entity->getName();
-                throwIDCollisionCannotInsert(id, type, name, existing_type, existing_name);
+                    AccessEntityPtr existing_entity = deserializeAccessEntity(existing_entity_definition, entity_path);
+                    AccessEntityType existing_type = existing_entity->getType();
+                    String existing_name = existing_entity->getName();
+                    throwIDCollisionCannotInsert(id, type, name, existing_type, existing_name);
+                }
+                else
+                {
+                    if (conflicting_id)
+                        *conflicting_id = id;
+                    return false;
+                }
+            }
+            else if (responses[1]->error == Coordination::Error::ZNODEEXISTS)
+            {
+                /// Couldn't insert the new entity because there is an existing entity with the same name.
+                if (throw_if_exists)
+                {
+                    throwNameCollisionCannotInsert(type, name);
+                }
+                else
+                {
+                    if (conflicting_id)
+                    {
+                        /// Get UUID of the existing entry with the same name.
+                        /// This itself can fail if the conflicting name disappears in the meantime.
+                        /// If that happens, then retryOnZooKeeperUserError() will just retry the operation from the start.
+                        *conflicting_id = parseUUID(zookeeper->get(name_path));
+                    }
+                    return false;
+                }
             }
             else
             {
-                /// Couldn't insert the new entity because there is an existing entity with such name.
-                throwNameCollisionCannotInsert(type, name);
+                zkutil::KeeperMultiException::check(res, ops, responses);
             }
         }
 
@@ -693,28 +718,10 @@ void ReplicatedAccessStorage::backup(BackupEntriesCollector & backup_entries_col
 }
 
 
-void ReplicatedAccessStorage::restoreFromBackup(RestorerFromBackup & restorer)
+bool ReplicatedAccessStorage::acquireReplicatedRestore(RestorerFromBackup & restorer) const
 {
-    if (!isRestoreAllowed())
-        throwRestoreNotAllowed();
-
     auto restore_coordination = restorer.getRestoreCoordination();
-    if (!restore_coordination->acquireReplicatedAccessStorage(zookeeper_path))
-        return;
-
-    auto entities = restorer.getAccessEntitiesToRestore();
-    if (entities.empty())
-        return;
-
-    auto create_access = restorer.getRestoreSettings().create_access;
-    bool replace_if_exists = (create_access == RestoreAccessCreationMode::kReplace);
-    bool throw_if_exists = (create_access == RestoreAccessCreationMode::kCreate);
-
-    restorer.addDataRestoreTask([this, my_entities = std::move(entities), replace_if_exists, throw_if_exists]
-    {
-        for (const auto & [id, entity] : my_entities)
-            insert(id, entity, replace_if_exists, throw_if_exists);
-    });
+    return restore_coordination->acquireReplicatedAccessStorage(zookeeper_path);
 }
 
 }

src/Access/ReplicatedAccessStorage.h

@@ -26,6 +26,7 @@ public:
     void shutdown() override;
 
     const char * getStorageType() const override { return STORAGE_TYPE; }
+    bool isReplicated() const override { return true; }
 
     void startPeriodicReloading() override { startWatchingThread(); }
     void stopPeriodicReloading() override { stopWatchingThread(); }
@@ -35,7 +36,6 @@ public:
 
     bool isBackupAllowed() const override { return backup_allowed; }
     void backup(BackupEntriesCollector & backup_entries_collector, const String & data_path_in_backup, AccessEntityType type) const override;
-    void restoreFromBackup(RestorerFromBackup & restorer) override;
 
 private:
     String zookeeper_path;
@@ -48,11 +48,11 @@ private:
     std::unique_ptr<ThreadFromGlobalPool> watching_thread;
     std::shared_ptr<ConcurrentBoundedQueue<UUID>> watched_queue;
 
-    bool insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists) override;
+    bool insertImpl(const UUID & id, const AccessEntityPtr & new_entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id) override;
     bool removeImpl(const UUID & id, bool throw_if_not_exists) override;
     bool updateImpl(const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists) override;
 
-    bool insertZooKeeper(const zkutil::ZooKeeperPtr & zookeeper, const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists);
+    bool insertZooKeeper(const zkutil::ZooKeeperPtr & zookeeper, const UUID & id, const AccessEntityPtr & entity, bool replace_if_exists, bool throw_if_exists, UUID * conflicting_id);
     bool removeZooKeeper(const zkutil::ZooKeeperPtr & zookeeper, const UUID & id, bool throw_if_not_exists);
     bool updateZooKeeper(const zkutil::ZooKeeperPtr & zookeeper, const UUID & id, const UpdateFunc & update_func, bool throw_if_not_exists);
 
@@ -80,6 +80,7 @@ private:
     std::optional<UUID> findImpl(AccessEntityType type, const String & name) const override;
     std::vector<UUID> findAllImpl(AccessEntityType type) const override;
     AccessEntityPtr readImpl(const UUID & id, bool throw_if_not_exists) const override;
+    bool acquireReplicatedRestore(RestorerFromBackup & restorer) const override;
 
     mutable std::mutex mutex;
     MemoryAccessStorage memory_storage TSA_GUARDED_BY(mutex);

src/Access/Role.cpp

@@ -21,7 +21,7 @@ std::vector<UUID> Role::findDependencies() const
     return res;
 }
 
-void Role::replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
+void Role::doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
 {
     granted_roles.replaceDependencies(old_to_new_ids);
     settings.replaceDependencies(old_to_new_ids);

src/Access/Role.h

@@ -21,7 +21,7 @@ struct Role : public IAccessEntity
     AccessEntityType getType() const override { return TYPE; }
 
     std::vector<UUID> findDependencies() const override;
-    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
+    void doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
     bool isBackupAllowed() const override { return settings.isBackupAllowed(); }
 };
 

src/Access/RowPolicy.cpp

@@ -63,7 +63,7 @@ std::vector<UUID> RowPolicy::findDependencies() const
     return to_roles.findDependencies();
 }
 
-void RowPolicy::replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
+void RowPolicy::doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
 {
     to_roles.replaceDependencies(old_to_new_ids);
 }

src/Access/RowPolicy.h

@@ -50,7 +50,7 @@ struct RowPolicy : public IAccessEntity
     AccessEntityType getType() const override { return TYPE; }
 
     std::vector<UUID> findDependencies() const override;
-    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
+    void doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
     bool isBackupAllowed() const override { return true; }
 
     /// Which roles or users should use this row policy.

src/Access/SettingsConstraints.cpp

@@ -10,10 +10,15 @@
 #include <Common/SettingSource.h>
 #include <IO/WriteHelpers.h>
 #include <Poco/Util/AbstractConfiguration.h>
-#include <boost/range/algorithm_ext/erase.hpp>
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_ddl;
+    extern const SettingsUInt64 readonly;
+}
+
 namespace ErrorCodes
 {
     extern const int READONLY;
@@ -164,7 +169,7 @@ void SettingsConstraints::check(const Settings & current_settings, const Setting
         if (element.writability)
             new_value = *element.writability;
 
-        auto setting_name = Settings::Traits::resolveName(element.setting_name);
+        auto setting_name = Settings::resolveName(element.setting_name);
         auto it = constraints.find(setting_name);
         if (it != constraints.end())
             old_value = it->second.writability;
@@ -255,7 +260,7 @@ bool SettingsConstraints::checkImpl(const Settings & current_settings,
                                     ReactionOnViolation reaction,
                                     SettingSource source) const
 {
-    std::string_view setting_name = Settings::Traits::resolveName(change.name);
+    std::string_view setting_name = Settings::resolveName(change.name);
 
     if (setting_name == "profile")
         return true;
@@ -393,7 +398,7 @@ std::string_view SettingsConstraints::resolveSettingNameWithCache(std::string_vi
 SettingsConstraints::Checker SettingsConstraints::getChecker(const Settings & current_settings, std::string_view setting_name) const
 {
     auto resolved_name = resolveSettingNameWithCache(setting_name);
-    if (!current_settings.allow_ddl && resolved_name == "allow_ddl")
+    if (!current_settings[Setting::allow_ddl] && resolved_name == "allow_ddl")
         return Checker(PreformattedMessage::create("Cannot modify 'allow_ddl' setting when DDL queries are prohibited for the user"),
                        ErrorCodes::QUERY_IS_PROHIBITED);
 
@@ -403,11 +408,11 @@ SettingsConstraints::Checker SettingsConstraints::getChecker(const Settings & cu
       * 2 - only read requests, as well as changing settings, except for the `readonly` setting.
       */
 
-    if (current_settings.readonly > 1 && resolved_name == "readonly")
+    if (current_settings[Setting::readonly] > 1 && resolved_name == "readonly")
         return Checker(PreformattedMessage::create("Cannot modify 'readonly' setting in readonly mode"), ErrorCodes::READONLY);
 
     auto it = constraints.find(resolved_name);
-    if (current_settings.readonly == 1)
+    if (current_settings[Setting::readonly] == 1)
     {
         if (it == constraints.end() || it->second.writability != SettingConstraintWritability::CHANGEABLE_IN_READONLY)
             return Checker(PreformattedMessage::create("Cannot modify '{}' setting in readonly mode", setting_name),
@@ -416,9 +421,9 @@ SettingsConstraints::Checker SettingsConstraints::getChecker(const Settings & cu
     else // For both readonly=0 and readonly=2
     {
         if (it == constraints.end())
-            return Checker(Settings::Traits::resolveName); // Allowed
+            return Checker(Settings::resolveName); // Allowed
     }
-    return Checker(it->second, Settings::Traits::resolveName);
+    return Checker(it->second, Settings::resolveName);
 }
 
 SettingsConstraints::Checker SettingsConstraints::getMergeTreeChecker(std::string_view short_name) const

src/Access/SettingsProfile.cpp

@@ -21,7 +21,7 @@ std::vector<UUID> SettingsProfile::findDependencies() const
     return res;
 }
 
-void SettingsProfile::replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
+void SettingsProfile::doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
 {
     elements.replaceDependencies(old_to_new_ids);
     to_roles.replaceDependencies(old_to_new_ids);

src/Access/SettingsProfile.h

@@ -22,7 +22,7 @@ struct SettingsProfile : public IAccessEntity
     AccessEntityType getType() const override { return TYPE; }
 
     std::vector<UUID> findDependencies() const override;
-    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
+    void doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
     bool isBackupAllowed() const override { return elements.isBackupAllowed(); }
 };
 

src/Access/SettingsProfileElement.cpp

@@ -249,7 +249,7 @@ bool SettingsProfileElements::isBackupAllowed() const
 bool SettingsProfileElements::isAllowBackupSetting(const String & setting_name)
 {
     static constexpr std::string_view ALLOW_BACKUP_SETTING_NAME = "allow_backup";
-    return Settings::Traits::resolveName(setting_name) == ALLOW_BACKUP_SETTING_NAME;
+    return Settings::resolveName(setting_name) == ALLOW_BACKUP_SETTING_NAME;
 }
 
 }

src/Access/User.cpp

@@ -49,7 +49,7 @@ std::vector<UUID> User::findDependencies() const
     return res;
 }
 
-void User::replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
+void User::doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids)
 {
     default_roles.replaceDependencies(old_to_new_ids);
     granted_roles.replaceDependencies(old_to_new_ids);

src/Access/User.h

@@ -32,7 +32,7 @@ struct User : public IAccessEntity
     void setName(const String & name_) override;
 
     std::vector<UUID> findDependencies() const override;
-    void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
+    void doReplaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
     bool isBackupAllowed() const override { return settings.isBackupAllowed(); }
 };
 

src/Access/examples/CMakeLists.txt

@@ -1,4 +1,4 @@
 if (TARGET ch_contrib::krb5)
     clickhouse_add_executable (kerberos_init kerberos_init.cpp)
-    target_link_libraries (kerberos_init PRIVATE dbms ch_contrib::krb5)
+    target_link_libraries (kerberos_init PRIVATE dbms clickhouse_functions ch_contrib::krb5)
 endif()

src/Access/resolveSetting.h

@@ -46,14 +46,6 @@ inline Field settingCastValueUtil(std::string_view full_name, const Field & valu
     });
 }
 
-inline String settingValueToStringUtil(std::string_view full_name, const Field & value)
-{
-    return resolveSetting(full_name, [&] <typename T> (std::string_view short_name, SettingsType<T>)
-    {
-        return T::valueToStringUtil(short_name, value);
-    });
-}
-
 inline Field settingStringToValueUtil(std::string_view full_name, const String & str)
 {
     return resolveSetting(full_name, [&] <typename T> (std::string_view short_name, SettingsType<T>)
@@ -89,10 +81,9 @@ inline String settingFullName<MergeTreeSettings>(std::string_view short_name)
 
 inline std::string resolveSettingName(std::string_view full_name)
 {
-    return resolveSetting(full_name, [&] <typename T> (std::string_view short_name, SettingsType<T>)
-    {
-        return settingFullName<T>(T::Traits::resolveName(short_name));
-    });
+    return resolveSetting(
+        full_name,
+        [&]<typename T>(std::string_view short_name, SettingsType<T>) { return settingFullName<T>(T::resolveName(short_name)); });
 }
 
 }

src/AggregateFunctions/AggregateFunctionFactory.cpp

@@ -14,6 +14,10 @@ static constexpr size_t MAX_AGGREGATE_FUNCTION_NAME_LENGTH = 1000;
 namespace DB
 {
 struct Settings;
+namespace Setting
+{
+    extern const SettingsBool log_queries;
+}
 
 namespace ErrorCodes
 {
@@ -199,7 +203,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
             found = *opt;
 
         out_properties = found.properties;
-        if (query_context && query_context->getSettingsRef().log_queries)
+        if (query_context && query_context->getSettingsRef()[Setting::log_queries])
             query_context->addQueryFactoriesInfo(
                 Context::QueryLogFactories::AggregateFunction, is_case_insensitive ? case_insensitive_name : name);
 
@@ -224,7 +228,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
                 "Aggregate function combinator '{}' is only for internal usage",
                 combinator_name);
 
-        if (query_context && query_context->getSettingsRef().log_queries)
+        if (query_context && query_context->getSettingsRef()[Setting::log_queries])
             query_context->addQueryFactoriesInfo(Context::QueryLogFactories::AggregateFunctionCombinator, combinator_name);
 
         String nested_name = name.substr(0, name.size() - combinator_name.size());

src/AggregateFunctions/AggregateFunctionFlameGraph.cpp

@@ -17,6 +17,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_introspection_functions;
+}
+
+
 namespace ErrorCodes
 {
     extern const int FUNCTION_NOT_ALLOWED;
@@ -628,7 +634,7 @@ static void check(const std::string & name, const DataTypes & argument_types, co
 
 AggregateFunctionPtr createAggregateFunctionFlameGraph(const std::string & name, const DataTypes & argument_types, const Array & params, const Settings * settings)
 {
-    if (!settings->allow_introspection_functions)
+    if (!(*settings)[Setting::allow_introspection_functions])
         throw Exception(ErrorCodes::FUNCTION_NOT_ALLOWED,
         "Introspection functions are disabled, because setting 'allow_introspection_functions' is set to 0");
 

src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp

@@ -18,15 +18,19 @@
 #include <Common/assert_cast.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
+#include <base/range.h>
 
 #include <bitset>
 
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_experimental_funnel_functions;
+}
 
 constexpr size_t max_events_size = 64;
-
 constexpr size_t min_required_args = 3;
 
 namespace ErrorCodes
@@ -448,7 +452,7 @@ inline AggregateFunctionPtr createAggregateFunctionSequenceNodeImpl(
 AggregateFunctionPtr
 createAggregateFunctionSequenceNode(const std::string & name, const DataTypes & argument_types, const Array & parameters, const Settings * settings)
 {
-    if (settings == nullptr || !settings->allow_experimental_funnel_functions)
+    if (settings == nullptr || !(*settings)[Setting::allow_experimental_funnel_functions])
     {
         throw Exception(ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION, "Aggregate function {} is experimental. "
             "Set `allow_experimental_funnel_functions` setting to enable it", name);

src/AggregateFunctions/AggregateFunctionUniq.cpp

@@ -15,7 +15,10 @@
 namespace DB
 {
 
-struct Settings;
+namespace Setting
+{
+    extern const SettingsMaxThreads max_threads;
+}
 
 namespace ErrorCodes
 {
@@ -149,7 +152,7 @@ void registerAggregateFunctionsUniq(AggregateFunctionFactory & factory)
     auto assign_bool_param = [](const std::string & name, const DataTypes & argument_types, const Array & params, const Settings * settings)
     {
         /// Using two level hash set if we wouldn't be able to merge in parallel can cause ~10% slowdown.
-        if (settings && settings->max_threads > 1)
+        if (settings && (*settings)[Setting::max_threads] > 1)
             return createAggregateFunctionUniq<
                 true, AggregateFunctionUniqExactData, AggregateFunctionUniqExactDataForVariadic, true /* is_able_to_parallelize_merge */>(name, argument_types, params, settings);
         else

src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp

@@ -3,6 +3,7 @@
 #include <Core/Settings.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
+#include <base/range.h>
 
 #include <unordered_set>
 #include <Columns/ColumnsNumber.h>

src/AggregateFunctions/examples/CMakeLists.txt

@@ -1,5 +1,5 @@
 clickhouse_add_executable (quantile-t-digest quantile-t-digest.cpp)
-target_link_libraries (quantile-t-digest PRIVATE dbms clickhouse_aggregate_functions)
+target_link_libraries (quantile-t-digest PRIVATE dbms clickhouse_functions clickhouse_aggregate_functions)
 
 clickhouse_add_executable (group_array_sorted group_array_sorted.cpp)
-target_link_libraries (group_array_sorted PRIVATE dbms clickhouse_aggregate_functions)
+target_link_libraries (group_array_sorted PRIVATE dbms clickhouse_functions clickhouse_aggregate_functions)

src/Analyzer/FunctionSecretArgumentsFinderTreeNode.h

@@ -3,370 +3,89 @@
 #include <Parsers/FunctionSecretArgumentsFinder.h>
 #include <Analyzer/ConstantNode.h>
 #include <Analyzer/FunctionNode.h>
-#include <Analyzer/IQueryTreeNode.h>
 #include <Analyzer/IdentifierNode.h>
-#include <Analyzer/ListNode.h>
-#include <Common/KnownObjectNames.h>
-#include <Core/QualifiedTableName.h>
-
-#include <boost/algorithm/string/predicate.hpp>
 
 
 namespace DB
 {
 
+class FunctionTreeNode : public AbstractFunction
+{
+public:
+    class ArgumentTreeNode : public Argument
+    {
+    public:
+        explicit ArgumentTreeNode(const IQueryTreeNode * argument_) : argument(argument_) {}
+        std::unique_ptr<AbstractFunction> getFunction() const override
+        {
+            if (const auto * f = argument->as<FunctionNode>())
+                return std::make_unique<FunctionTreeNode>(*f);
+            return nullptr;
+        }
+        bool isIdentifier() const override { return argument->as<IdentifierNode>(); }
+        bool tryGetString(String * res, bool allow_identifier) const override
+        {
+            if (const auto * literal = argument->as<ConstantNode>())
+            {
+                if (literal->getValue().getType() != Field::Types::String)
+                    return false;
+                if (res)
+                    *res = literal->getValue().safeGet<String>();
+                return true;
+            }
+
+            if (allow_identifier)
+            {
+                if (const auto * id = argument->as<IdentifierNode>())
+                {
+                    if (res)
+                        *res = id->getIdentifier().getFullName();
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    private:
+        const IQueryTreeNode * argument = nullptr;
+    };
+
+    class ArgumentsTreeNode : public Arguments
+    {
+    public:
+        explicit ArgumentsTreeNode(const QueryTreeNodes * arguments_) : arguments(arguments_) {}
+        size_t size() const override { return arguments ? arguments->size() : 0; }
+        std::unique_ptr<Argument> at(size_t n) const override { return std::make_unique<ArgumentTreeNode>(arguments->at(n).get()); }
+    private:
+        const QueryTreeNodes * arguments = nullptr;
+    };
+
+    explicit FunctionTreeNode(const FunctionNode & function_) : function(&function_)
+    {
+        if (const auto & nodes = function->getArguments().getNodes(); !nodes.empty())
+            arguments = std::make_unique<ArgumentsTreeNode>(&nodes);
+    }
+    String name() const override { return function->getFunctionName(); }
+private:
+    const FunctionNode * function = nullptr;
+};
+
 
 /// Finds arguments of a specified function which should not be displayed for most users for security reasons.
 /// That involves passwords and secret keys.
-class FunctionSecretArgumentsFinderTreeNode
+class FunctionSecretArgumentsFinderTreeNode : public FunctionSecretArgumentsFinder
 {
 public:
-    explicit FunctionSecretArgumentsFinderTreeNode(const FunctionNode & function_) : function(function_), arguments(function.getArguments())
+    explicit FunctionSecretArgumentsFinderTreeNode(const FunctionNode & function_)
+        : FunctionSecretArgumentsFinder(std::make_unique<FunctionTreeNode>(function_))
     {
-        if (arguments.getNodes().empty())
+        if (!function->hasArguments())
             return;
 
-        findFunctionSecretArguments();
+        findOrdinaryFunctionSecretArguments();
     }
 
-    struct Result
-    {
-        /// Result constructed by default means no arguments will be hidden.
-        size_t start = static_cast<size_t>(-1);
-        size_t count = 0; /// Mostly it's either 0 or 1. There are only a few cases where `count` can be greater than 1 (e.g. see `encrypt`).
-                            /// In all known cases secret arguments are consecutive
-        bool are_named = false; /// Arguments like `password = 'password'` are considered as named arguments.
-        /// E.g. "headers" in `url('..', headers('foo' = '[HIDDEN]'))`
-        std::vector<std::string> nested_maps;
-
-        bool hasSecrets() const
-        {
-            return count != 0 || !nested_maps.empty();
-        }
-    };
-
     FunctionSecretArgumentsFinder::Result getResult() const { return result; }
-
-private:
-    const FunctionNode & function;
-    const ListNode & arguments;
-    FunctionSecretArgumentsFinder::Result result;
-
-    void markSecretArgument(size_t index, bool argument_is_named = false)
-    {
-        if (index >= arguments.getNodes().size())
-            return;
-        if (!result.count)
-        {
-            result.start = index;
-            result.are_named = argument_is_named;
-        }
-        chassert(index >= result.start); /// We always check arguments consecutively
-        result.count = index + 1 - result.start;
-        if (!argument_is_named)
-            result.are_named = false;
-    }
-
-    void findFunctionSecretArguments()
-    {
-        const auto & name = function.getFunctionName();
-
-        if ((name == "mysql") || (name == "postgresql") || (name == "mongodb"))
-        {
-            /// mysql('host:port', 'database', 'table', 'user', 'password', ...)
-            /// postgresql('host:port', 'database', 'table', 'user', 'password', ...)
-            /// mongodb('host:port', 'database', 'collection', 'user', 'password', ...)
-            findMySQLFunctionSecretArguments();
-        }
-        else if ((name == "s3") || (name == "cosn") || (name == "oss") ||
-                    (name == "deltaLake") || (name == "hudi") || (name == "iceberg"))
-        {
-            /// s3('url', 'aws_access_key_id', 'aws_secret_access_key', ...)
-            findS3FunctionSecretArguments(/* is_cluster_function= */ false);
-        }
-        else if (name == "s3Cluster")
-        {
-            /// s3Cluster('cluster_name', 'url', 'aws_access_key_id', 'aws_secret_access_key', ...)
-            findS3FunctionSecretArguments(/* is_cluster_function= */ true);
-        }
-        else if ((name == "remote") || (name == "remoteSecure"))
-        {
-            /// remote('addresses_expr', 'db', 'table', 'user', 'password', ...)
-            findRemoteFunctionSecretArguments();
-        }
-        else if ((name == "encrypt") || (name == "decrypt") ||
-                    (name == "aes_encrypt_mysql") || (name == "aes_decrypt_mysql") ||
-                    (name == "tryDecrypt"))
-        {
-            /// encrypt('mode', 'plaintext', 'key' [, iv, aad])
-            findEncryptionFunctionSecretArguments();
-        }
-        else if (name == "url")
-        {
-            findURLSecretArguments();
-        }
-    }
-
-    void findMySQLFunctionSecretArguments()
-    {
-        if (isNamedCollectionName(0))
-        {
-            /// mysql(named_collection, ..., password = 'password', ...)
-            findSecretNamedArgument("password", 1);
-        }
-        else
-        {
-            /// mysql('host:port', 'database', 'table', 'user', 'password', ...)
-            markSecretArgument(4);
-        }
-    }
-
-    /// Returns the number of arguments excluding "headers" and "extra_credentials" (which should
-    /// always be at the end). Marks "headers" as secret, if found.
-    size_t excludeS3OrURLNestedMaps()
-    {
-        const auto & nodes = arguments.getNodes();
-        size_t count = nodes.size();
-        while (count > 0)
-        {
-            const FunctionNode * f = nodes.at(count - 1)->as<FunctionNode>();
-            if (!f)
-                break;
-            if (f->getFunctionName() == "headers")
-                result.nested_maps.push_back(f->getFunctionName());
-            else if (f->getFunctionName() != "extra_credentials")
-                break;
-            count -= 1;
-        }
-        return count;
-    }
-
-    void findS3FunctionSecretArguments(bool is_cluster_function)
-    {
-        /// s3Cluster('cluster_name', 'url', ...) has 'url' as its second argument.
-        size_t url_arg_idx = is_cluster_function ? 1 : 0;
-
-        if (!is_cluster_function && isNamedCollectionName(0))
-        {
-            /// s3(named_collection, ..., secret_access_key = 'secret_access_key', ...)
-            findSecretNamedArgument("secret_access_key", 1);
-            return;
-        }
-
-        /// We should check other arguments first because we don't need to do any replacement in case of
-        /// s3('url', NOSIGN, 'format' [, 'compression'] [, extra_credentials(..)] [, headers(..)])
-        /// s3('url', 'format', 'structure' [, 'compression'] [, extra_credentials(..)] [, headers(..)])
-        size_t count = excludeS3OrURLNestedMaps();
-        if ((url_arg_idx + 3 <= count) && (count <= url_arg_idx + 4))
-        {
-            String second_arg;
-            if (tryGetStringFromArgument(url_arg_idx + 1, &second_arg))
-            {
-                if (boost::iequals(second_arg, "NOSIGN"))
-                    return; /// The argument after 'url' is "NOSIGN".
-
-                if (second_arg == "auto" || KnownFormatNames::instance().exists(second_arg))
-                    return; /// The argument after 'url' is a format: s3('url', 'format', ...)
-            }
-        }
-
-        /// We're going to replace 'aws_secret_access_key' with '[HIDDEN]' for the following signatures:
-        /// s3('url', 'aws_access_key_id', 'aws_secret_access_key', ...)
-        /// s3Cluster('cluster_name', 'url', 'aws_access_key_id', 'aws_secret_access_key', 'format', 'compression')
-        if (url_arg_idx + 2 < count)
-            markSecretArgument(url_arg_idx + 2);
-    }
-
-    void findURLSecretArguments()
-    {
-        if (!isNamedCollectionName(0))
-            excludeS3OrURLNestedMaps();
-    }
-
-    bool tryGetStringFromArgument(size_t arg_idx, String * res, bool allow_identifier = true) const
-    {
-        if (arg_idx >= arguments.getNodes().size())
-            return false;
-
-        return tryGetStringFromArgument(arguments.getNodes()[arg_idx], res, allow_identifier);
-    }
-
-    static bool tryGetStringFromArgument(const QueryTreeNodePtr argument, String * res, bool allow_identifier = true)
-    {
-        if (const auto * literal = argument->as<ConstantNode>())
-        {
-            if (literal->getValue().getType() != Field::Types::String)
-                return false;
-            if (res)
-                *res = literal->getValue().safeGet<String>();
-            return true;
-        }
-
-        if (allow_identifier)
-        {
-            if (const auto * id = argument->as<IdentifierNode>())
-            {
-                if (res)
-                    *res = id->getIdentifier().getFullName();
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    void findRemoteFunctionSecretArguments()
-    {
-        if (isNamedCollectionName(0))
-        {
-            /// remote(named_collection, ..., password = 'password', ...)
-            findSecretNamedArgument("password", 1);
-            return;
-        }
-
-        /// We're going to replace 'password' with '[HIDDEN'] for the following signatures:
-        /// remote('addresses_expr', db.table, 'user' [, 'password'] [, sharding_key])
-        /// remote('addresses_expr', 'db', 'table', 'user' [, 'password'] [, sharding_key])
-        /// remote('addresses_expr', table_function(), 'user' [, 'password'] [, sharding_key])
-
-        /// But we should check the number of arguments first because we don't need to do any replacements in case of
-        /// remote('addresses_expr', db.table)
-        if (arguments.getNodes().size() < 3)
-            return;
-
-        size_t arg_num = 1;
-
-        /// Skip 1 or 2 arguments with table_function() or db.table or 'db', 'table'.
-        const auto * table_function = arguments.getNodes()[arg_num]->as<FunctionNode>();
-        if (table_function && KnownTableFunctionNames::instance().exists(table_function->getFunctionName()))
-        {
-            ++arg_num;
-        }
-        else
-        {
-            std::optional<String> database;
-            std::optional<QualifiedTableName> qualified_table_name;
-            if (!tryGetDatabaseNameOrQualifiedTableName(arg_num, database, qualified_table_name))
-            {
-                /// We couldn't evaluate the argument so we don't know whether it is 'db.table' or just 'db'.
-                /// Hence we can't figure out whether we should skip one argument 'user' or two arguments 'table', 'user'
-                /// before the argument 'password'. So it's safer to wipe two arguments just in case.
-                /// The last argument can be also a `sharding_key`, so we need to check that argument is a literal string
-                /// before wiping it (because the `password` argument is always a literal string).
-                if (tryGetStringFromArgument(arg_num + 2, nullptr, /* allow_identifier= */ false))
-                {
-                    /// Wipe either `password` or `user`.
-                    markSecretArgument(arg_num + 2);
-                }
-                if (tryGetStringFromArgument(arg_num + 3, nullptr, /* allow_identifier= */ false))
-                {
-                    /// Wipe either `password` or `sharding_key`.
-                    markSecretArgument(arg_num + 3);
-                }
-                return;
-            }
-
-            /// Skip the current argument (which is either a database name or a qualified table name).
-            ++arg_num;
-            if (database)
-            {
-                /// Skip the 'table' argument if the previous argument was a database name.
-                ++arg_num;
-            }
-        }
-
-        /// Skip username.
-        ++arg_num;
-
-        /// Do our replacement:
-        /// remote('addresses_expr', db.table, 'user', 'password', ...) -> remote('addresses_expr', db.table, 'user', '[HIDDEN]', ...)
-        /// The last argument can be also a `sharding_key`, so we need to check that argument is a literal string
-        /// before wiping it (because the `password` argument is always a literal string).
-        bool can_be_password = tryGetStringFromArgument(arg_num, nullptr, /* allow_identifier= */ false);
-        if (can_be_password)
-            markSecretArgument(arg_num);
-    }
-
-    /// Tries to get either a database name or a qualified table name from an argument.
-    /// Empty string is also allowed (it means the default database).
-    /// The function is used by findRemoteFunctionSecretArguments() to determine how many arguments to skip before a password.
-    bool tryGetDatabaseNameOrQualifiedTableName(
-        size_t arg_idx,
-        std::optional<String> & res_database,
-        std::optional<QualifiedTableName> & res_qualified_table_name) const
-    {
-        res_database.reset();
-        res_qualified_table_name.reset();
-
-        String str;
-        if (!tryGetStringFromArgument(arg_idx, &str, /* allow_identifier= */ true))
-            return false;
-
-        if (str.empty())
-        {
-            res_database = "";
-            return true;
-        }
-
-        auto qualified_table_name = QualifiedTableName::tryParseFromString(str);
-        if (!qualified_table_name)
-            return false;
-
-        if (qualified_table_name->database.empty())
-            res_database = std::move(qualified_table_name->table);
-        else
-            res_qualified_table_name = std::move(qualified_table_name);
-        return true;
-    }
-
-    void findEncryptionFunctionSecretArguments()
-    {
-        if (arguments.getNodes().empty())
-            return;
-
-        /// We replace all arguments after 'mode' with '[HIDDEN]':
-        /// encrypt('mode', 'plaintext', 'key' [, iv, aad]) -> encrypt('mode', '[HIDDEN]')
-        result.start = 1;
-        result.count = arguments.getNodes().size() - 1;
-    }
-
-
-    /// Whether a specified argument can be the name of a named collection?
-    bool isNamedCollectionName(size_t arg_idx) const
-    {
-        if (arguments.getNodes().size() <= arg_idx)
-            return false;
-
-        const auto * identifier = arguments.getNodes()[arg_idx]->as<IdentifierNode>();
-        return identifier != nullptr;
-    }
-
-    /// Looks for a secret argument with a specified name. This function looks for arguments in format `key=value` where the key is specified.
-    void findSecretNamedArgument(const std::string_view & key, size_t start = 0)
-    {
-        for (size_t i = start; i < arguments.getNodes().size(); ++i)
-        {
-            const auto & argument = arguments.getNodes()[i];
-            const auto * equals_func = argument->as<FunctionNode>();
-            if (!equals_func || (equals_func->getFunctionName() != "equals"))
-                continue;
-
-            const auto * expr_list = equals_func->getArguments().as<ListNode>();
-            if (!expr_list)
-                continue;
-
-            const auto & equal_args = expr_list->getNodes();
-            if (equal_args.size() != 2)
-                continue;
-
-            String found_key;
-            if (!tryGetStringFromArgument(equal_args[0], &found_key))
-                continue;
-
-            if (found_key == key)
-                markSecretArgument(i, /* argument_is_named= */ true);
-        }
-    }
 };
 
 }

src/Analyzer/Passes/AggregateFunctionOfGroupByKeysPass.cpp

@@ -14,6 +14,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_aggregators_of_group_by_keys;
+}
 
 namespace ErrorCodes
 {
@@ -34,7 +38,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_aggregators_of_group_by_keys)
+        if (!getSettings()[Setting::optimize_aggregators_of_group_by_keys])
             return;
 
         /// Collect group by keys.
@@ -79,7 +83,7 @@ public:
     /// Now we visit all nodes in QueryNode, we should remove group_by_keys from stack.
     void leaveImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_aggregators_of_group_by_keys)
+        if (!getSettings()[Setting::optimize_aggregators_of_group_by_keys])
             return;
 
         if (node->getNodeType() == QueryTreeNodeType::FUNCTION)

src/Analyzer/Passes/AggregateFunctionsArithmericOperationsPass.cpp

@@ -15,6 +15,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_arithmetic_operations_in_aggregate_functions;
+}
+
 
 namespace ErrorCodes
 {
@@ -56,7 +61,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_arithmetic_operations_in_aggregate_functions)
+        if (!getSettings()[Setting::optimize_arithmetic_operations_in_aggregate_functions])
             return;
 
         auto * aggregate_function_node = node->as<FunctionNode>();

src/Analyzer/Passes/ArrayExistsToHasPass.cpp

@@ -15,6 +15,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_rewrite_array_exists_to_has;
+}
 
 namespace
 {
@@ -27,7 +31,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_rewrite_array_exists_to_has)
+        if (!getSettings()[Setting::optimize_rewrite_array_exists_to_has])
             return;
 
         auto * array_exists_function_node = node->as<FunctionNode>();

src/Analyzer/Passes/AutoFinalOnQueryPass.cpp

@@ -12,6 +12,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool final;
+}
 
 namespace
 {
@@ -24,7 +28,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().final)
+        if (!getSettings()[Setting::final])
             return;
 
         const auto * query_node = node->as<QueryNode>();

src/Analyzer/Passes/ConvertOrLikeChainPass.cpp

@@ -26,6 +26,14 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_hyperscan;
+    extern const SettingsUInt64 max_hyperscan_regexp_length;
+    extern const SettingsUInt64 max_hyperscan_regexp_total_length;
+    extern const SettingsBool reject_expensive_hyperscan_regexps;
+    extern const SettingsBool optimize_or_like_chain;
+}
 
 namespace
 {
@@ -48,10 +56,8 @@ public:
     {
         const auto & settings = getSettings();
 
-        return settings.optimize_or_like_chain
-            && settings.allow_hyperscan
-            && settings.max_hyperscan_regexp_length == 0
-            && settings.max_hyperscan_regexp_total_length == 0;
+        return settings[Setting::optimize_or_like_chain] && settings[Setting::allow_hyperscan] && settings[Setting::max_hyperscan_regexp_length] == 0
+            && settings[Setting::max_hyperscan_regexp_total_length] == 0;
     }
 
     void enterImpl(QueryTreeNodePtr & node)
@@ -139,7 +145,11 @@ private:
 void ConvertOrLikeChainPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
     const auto & settings = context->getSettingsRef();
-    auto match_function_resolver = createInternalMultiMatchAnyOverloadResolver(settings.allow_hyperscan, settings.max_hyperscan_regexp_length, settings.max_hyperscan_regexp_total_length, settings.reject_expensive_hyperscan_regexps);
+    auto match_function_resolver = createInternalMultiMatchAnyOverloadResolver(
+        settings[Setting::allow_hyperscan],
+        settings[Setting::max_hyperscan_regexp_length],
+        settings[Setting::max_hyperscan_regexp_total_length],
+        settings[Setting::reject_expensive_hyperscan_regexps]);
     auto or_function_resolver = createInternalFunctionOrOverloadResolver();
 
     ConvertOrLikeChainVisitor visitor(std::move(or_function_resolver), std::move(match_function_resolver), std::move(context));

src/Analyzer/Passes/ConvertQueryToCNFPass.cpp

@@ -19,6 +19,13 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool convert_query_to_cnf;
+    extern const SettingsBool optimize_append_index;
+    extern const SettingsBool optimize_substitute_columns;
+    extern const SettingsBool optimize_using_constraints;
+}
 
 namespace
 {
@@ -681,7 +688,7 @@ void optimizeWithConstraints(Analyzer::CNF & cnf, const QueryTreeNodes & table_e
     cnf.pushNotIntoFunctions(context);
 
     const auto & settings = context->getSettingsRef();
-    if (settings.optimize_append_index)
+    if (settings[Setting::optimize_append_index])
         addIndexConstraint(cnf, table_expressions, context);
 }
 
@@ -693,7 +700,7 @@ void optimizeNode(QueryTreeNodePtr & node, const QueryTreeNodes & table_expressi
     if (!cnf)
         return;
 
-    if (settings.optimize_using_constraints)
+    if (settings[Setting::optimize_using_constraints])
         optimizeWithConstraints(*cnf, table_expressions, context);
 
     auto new_node = cnf->toQueryTree();
@@ -731,7 +738,7 @@ public:
         optimize_filter(query_node->getPrewhere());
         optimize_filter(query_node->getHaving());
 
-        if (has_filter && settings.optimize_substitute_columns)
+        if (has_filter && settings[Setting::optimize_substitute_columns])
             substituteColumns(*query_node, table_expressions, context);
     }
 };
@@ -741,7 +748,7 @@ public:
 void ConvertLogicalExpressionToCNFPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
     const auto & settings = context->getSettingsRef();
-    if (!settings.convert_query_to_cnf)
+    if (!settings[Setting::convert_query_to_cnf])
         return;
 
     ConvertQueryToCNFVisitor visitor(std::move(context));

src/Analyzer/Passes/CountDistinctPass.cpp

@@ -15,6 +15,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool count_distinct_optimization;
+}
 
 namespace
 {
@@ -27,7 +31,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().count_distinct_optimization)
+        if (!getSettings()[Setting::count_distinct_optimization])
             return;
 
         auto * query_node = node->as<QueryNode>();

src/Analyzer/Passes/CrossToInnerJoinPass.cpp

@@ -21,6 +21,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 cross_to_inner_join_rewrite;
+}
 
 namespace ErrorCodes
 {
@@ -193,17 +197,14 @@ public:
     }
 
 private:
-    bool isEnabled() const
-    {
-        return getSettings().cross_to_inner_join_rewrite;
-    }
+    bool isEnabled() const { return getSettings()[Setting::cross_to_inner_join_rewrite]; }
 
     bool forceRewrite(JoinKind kind) const
     {
         if (kind == JoinKind::Cross)
             return false;
         /// Comma join can be forced to rewrite
-        return getSettings().cross_to_inner_join_rewrite >= 2;
+        return getSettings()[Setting::cross_to_inner_join_rewrite] >= 2;
     }
 
     QueryTreeNodePtr makeConjunction(const QueryTreeNodes & nodes)

src/Analyzer/Passes/FunctionToSubcolumnsPass.cpp

@@ -25,6 +25,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool group_by_use_nulls;
+    extern const SettingsBool join_use_nulls;
+    extern const SettingsBool optimize_functions_to_subcolumns;
+}
 
 namespace
 {
@@ -257,7 +263,7 @@ public:
 
     void enterImpl(const QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_functions_to_subcolumns)
+        if (!getSettings()[Setting::optimize_functions_to_subcolumns])
             return;
 
         if (auto * table_node = node->as<TableNode>())
@@ -281,14 +287,14 @@ public:
 
         if (const auto * join_node = node->as<JoinNode>())
         {
-            can_wrap_result_columns_with_nullable |= getContext()->getSettingsRef().join_use_nulls;
+            can_wrap_result_columns_with_nullable |= getContext()->getSettingsRef()[Setting::join_use_nulls];
             return;
         }
 
         if (const auto * query_node = node->as<QueryNode>())
         {
             if (query_node->isGroupByWithCube() || query_node->isGroupByWithRollup() || query_node->isGroupByWithGroupingSets())
-                can_wrap_result_columns_with_nullable |= getContext()->getSettingsRef().group_by_use_nulls;
+                can_wrap_result_columns_with_nullable |= getContext()->getSettingsRef()[Setting::group_by_use_nulls];
             return;
         }
     }
@@ -419,7 +425,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node) const
     {
-        if (!getSettings().optimize_functions_to_subcolumns)
+        if (!getSettings()[Setting::optimize_functions_to_subcolumns])
             return;
 
         auto [function_node, first_argument_column_node, table_node] = getTypedNodesForOptimization(node, getContext());

src/Analyzer/Passes/FuseFunctionsPass.cpp

@@ -21,6 +21,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_syntax_fuse_functions;
+}
 
 namespace ErrorCodes
 {
@@ -44,7 +48,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_syntax_fuse_functions)
+        if (!getSettings()[Setting::optimize_syntax_fuse_functions])
             return;
 
         auto * function_node = node->as<FunctionNode>();

src/Analyzer/Passes/GroupingFunctionsResolvePass.cpp

@@ -15,6 +15,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool force_grouping_standard_compatibility;
+    extern const SettingsBool group_by_use_nulls;
+}
 
 namespace ErrorCodes
 {
@@ -72,41 +77,38 @@ public:
         FunctionOverloadResolverPtr grouping_function_resolver;
         bool add_grouping_set_column = false;
 
-        bool force_grouping_standard_compatibility = getSettings().force_grouping_standard_compatibility;
+        bool force_grouping_standard_compatibility = getSettings()[Setting::force_grouping_standard_compatibility];
         size_t aggregation_keys_size = aggregation_key_to_index.size();
 
         switch (group_by_kind)
         {
             case GroupByKind::ORDINARY:
             {
-                auto grouping_ordinary_function = std::make_shared<FunctionGroupingOrdinary>(arguments_indexes,
-                    force_grouping_standard_compatibility);
+                auto grouping_ordinary_function
+                    = std::make_shared<FunctionGroupingOrdinary>(arguments_indexes, force_grouping_standard_compatibility);
                 grouping_function_resolver = std::make_shared<FunctionToOverloadResolverAdaptor>(std::move(grouping_ordinary_function));
                 break;
             }
             case GroupByKind::ROLLUP:
             {
-                auto grouping_rollup_function = std::make_shared<FunctionGroupingForRollup>(arguments_indexes,
-                    aggregation_keys_size,
-                    force_grouping_standard_compatibility);
+                auto grouping_rollup_function = std::make_shared<FunctionGroupingForRollup>(
+                    arguments_indexes, aggregation_keys_size, force_grouping_standard_compatibility);
                 grouping_function_resolver = std::make_shared<FunctionToOverloadResolverAdaptor>(std::move(grouping_rollup_function));
                 add_grouping_set_column = true;
                 break;
             }
             case GroupByKind::CUBE:
             {
-                auto grouping_cube_function = std::make_shared<FunctionGroupingForCube>(arguments_indexes,
-                    aggregation_keys_size,
-                    force_grouping_standard_compatibility);
+                auto grouping_cube_function = std::make_shared<FunctionGroupingForCube>(
+                    arguments_indexes, aggregation_keys_size, force_grouping_standard_compatibility);
                 grouping_function_resolver = std::make_shared<FunctionToOverloadResolverAdaptor>(std::move(grouping_cube_function));
                 add_grouping_set_column = true;
                 break;
             }
             case GroupByKind::GROUPING_SETS:
             {
-                auto grouping_grouping_sets_function = std::make_shared<FunctionGroupingForGroupingSets>(arguments_indexes,
-                    grouping_sets_keys_indexes,
-                    force_grouping_standard_compatibility);
+                auto grouping_grouping_sets_function = std::make_shared<FunctionGroupingForGroupingSets>(
+                    arguments_indexes, grouping_sets_keys_indexes, force_grouping_standard_compatibility);
                 grouping_function_resolver = std::make_shared<FunctionToOverloadResolverAdaptor>(std::move(grouping_grouping_sets_function));
                 add_grouping_set_column = true;
                 break;
@@ -147,7 +149,8 @@ void resolveGroupingFunctions(QueryTreeNodePtr & query_node, ContextPtr context)
     if (query_node_typed.hasGroupBy())
     {
         /// It is expected by execution layer that if there are only 1 grouping set it will be removed
-        if (query_node_typed.isGroupByWithGroupingSets() && query_node_typed.getGroupBy().getNodes().size() == 1 && !context->getSettingsRef().group_by_use_nulls)
+        if (query_node_typed.isGroupByWithGroupingSets() && query_node_typed.getGroupBy().getNodes().size() == 1
+            && !context->getSettingsRef()[Setting::group_by_use_nulls])
         {
             auto grouping_set_list_node = query_node_typed.getGroupBy().getNodes().front();
             auto & grouping_set_list_node_typed = grouping_set_list_node->as<ListNode &>();

src/Analyzer/Passes/IfChainToMultiIfPass.cpp

@@ -10,6 +10,13 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_execute_multiif_columnar;
+    extern const SettingsBool allow_experimental_variant_type;
+    extern const SettingsBool optimize_if_chain_to_multiif;
+    extern const SettingsBool use_variant_as_common_type;
+}
 
 namespace
 {
@@ -27,7 +34,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_if_chain_to_multiif)
+        if (!getSettings()[Setting::optimize_if_chain_to_multiif])
             return;
 
         auto * function_node = node->as<FunctionNode>();
@@ -84,7 +91,8 @@ private:
 void IfChainToMultiIfPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
     const auto & settings = context->getSettingsRef();
-    auto multi_if_function_ptr = createInternalMultiIfOverloadResolver(settings.allow_execute_multiif_columnar, settings.allow_experimental_variant_type, settings.use_variant_as_common_type);
+    auto multi_if_function_ptr = createInternalMultiIfOverloadResolver(
+        settings[Setting::allow_execute_multiif_columnar], settings[Setting::allow_experimental_variant_type], settings[Setting::use_variant_as_common_type]);
     IfChainToMultiIfPassVisitor visitor(std::move(multi_if_function_ptr), std::move(context));
     visitor.visit(query_tree_node);
 }

src/Analyzer/Passes/IfTransformStringsToEnumPass.cpp

@@ -16,6 +16,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_if_transform_strings_to_enum;
+}
 
 namespace
 {
@@ -101,7 +105,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_if_transform_strings_to_enum)
+        if (!getSettings()[Setting::optimize_if_transform_strings_to_enum])
             return;
 
         auto * function_node = node->as<FunctionNode>();

src/Analyzer/Passes/LogicalExpressionOptimizerPass.cpp

@@ -16,6 +16,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 optimize_min_equality_disjunction_chain_length;
+    extern const SettingsUInt64 optimize_min_inequality_conjunction_chain_length;
+}
 
 namespace ErrorCodes
 {
@@ -531,7 +536,8 @@ private:
         for (auto & [expression, not_equals_functions] : node_to_not_equals_functions)
         {
             const auto & settings = getSettings();
-            if (not_equals_functions.size() < settings.optimize_min_inequality_conjunction_chain_length && !expression.node->getResultType()->lowCardinality())
+            if (not_equals_functions.size() < settings[Setting::optimize_min_inequality_conjunction_chain_length]
+                && !expression.node->getResultType()->lowCardinality())
             {
                 std::move(not_equals_functions.begin(), not_equals_functions.end(), std::back_inserter(and_operands));
                 continue;
@@ -653,7 +659,8 @@ private:
         for (auto & [expression, equals_functions] : node_to_equals_functions)
         {
             const auto & settings = getSettings();
-            if (equals_functions.size() < settings.optimize_min_equality_disjunction_chain_length && !expression.node->getResultType()->lowCardinality())
+            if (equals_functions.size() < settings[Setting::optimize_min_equality_disjunction_chain_length]
+                && !expression.node->getResultType()->lowCardinality())
             {
                 std::move(equals_functions.begin(), equals_functions.end(), std::back_inserter(or_operands));
                 continue;

src/Analyzer/Passes/MultiIfToIfPass.cpp

@@ -8,6 +8,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_experimental_variant_type;
+    extern const SettingsBool optimize_multiif_to_if;
+    extern const SettingsBool use_variant_as_common_type;
+}
 
 namespace
 {
@@ -25,7 +31,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_multiif_to_if)
+        if (!getSettings()[Setting::optimize_multiif_to_if])
             return;
 
         auto * function_node = node->as<FunctionNode>();
@@ -57,7 +63,8 @@ private:
 void MultiIfToIfPass::run(QueryTreeNodePtr & query_tree_node, ContextPtr context)
 {
     const auto & settings = context->getSettingsRef();
-    auto if_function_ptr = createInternalFunctionIfOverloadResolver(settings.allow_experimental_variant_type, settings.use_variant_as_common_type);
+    auto if_function_ptr
+        = createInternalFunctionIfOverloadResolver(settings[Setting::allow_experimental_variant_type], settings[Setting::use_variant_as_common_type]);
     MultiIfToIfVisitor visitor(std::move(if_function_ptr), std::move(context));
     visitor.visit(query_tree_node);
 }

src/Analyzer/Passes/NormalizeCountVariantsPass.cpp

@@ -13,6 +13,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_normalize_count_variants;
+}
 
 namespace
 {
@@ -25,7 +29,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_normalize_count_variants)
+        if (!getSettings()[Setting::optimize_normalize_count_variants])
             return;
 
         auto * function_node = node->as<FunctionNode>();

src/Analyzer/Passes/OptimizeDateOrDateTimeConverterWithPreimagePass.cpp

@@ -13,6 +13,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_time_filter_with_preimage;
+}
 
 namespace ErrorCodes
 {
@@ -58,7 +62,7 @@ public:
             {"greaterOrEquals", "lessOrEquals"},
         };
 
-        if (!getSettings().optimize_time_filter_with_preimage)
+        if (!getSettings()[Setting::optimize_time_filter_with_preimage])
             return;
 
         const auto * function = node->as<FunctionNode>();

src/Analyzer/Passes/OptimizeGroupByFunctionKeysPass.cpp

@@ -12,6 +12,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool group_by_use_nulls;
+    extern const SettingsBool optimize_group_by_function_keys;
+}
 
 class OptimizeGroupByFunctionKeysVisitor : public InDepthQueryTreeVisitorWithContext<OptimizeGroupByFunctionKeysVisitor>
 {
@@ -29,13 +34,13 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_group_by_function_keys)
+        if (!getSettings()[Setting::optimize_group_by_function_keys])
             return;
 
         /// When group_by_use_nulls = 1 removing keys from GROUP BY can lead
         /// to unexpected types in some functions.
         /// See example in https://github.com/ClickHouse/ClickHouse/pull/61567#issuecomment-2018007887
-        if (getSettings().group_by_use_nulls)
+        if (getSettings()[Setting::group_by_use_nulls])
             return;
 
         auto * query = node->as<QueryNode>();

src/Analyzer/Passes/OptimizeGroupByInjectiveFunctionsPass.cpp

@@ -9,6 +9,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool group_by_use_nulls;
+    extern const SettingsBool optimize_injective_functions_in_group_by;
+}
 
 namespace
 {
@@ -23,14 +28,14 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_injective_functions_in_group_by)
+        if (!getSettings()[Setting::optimize_injective_functions_in_group_by])
             return;
 
         /// Don't optimize injective functions when group_by_use_nulls=true,
         /// because in this case we make initial group by keys Nullable
         /// and eliminating some functions can cause issues with arguments Nullability
         /// during their execution. See examples in https://github.com/ClickHouse/ClickHouse/pull/61567#issuecomment-2008181143
-        if (getSettings().group_by_use_nulls)
+        if (getSettings()[Setting::group_by_use_nulls])
             return;
 
         auto * query = node->as<QueryNode>();

src/Analyzer/Passes/OptimizeRedundantFunctionsInOrderByPass.cpp

@@ -12,6 +12,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_redundant_functions_in_order_by;
+}
 
 namespace
 {
@@ -31,7 +35,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_redundant_functions_in_order_by)
+        if (!getSettings()[Setting::optimize_redundant_functions_in_order_by])
             return;
 
         auto * query = node->as<QueryNode>();

src/Analyzer/Passes/RewriteAggregateFunctionWithIfPass.cpp

@@ -20,6 +20,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_rewrite_aggregate_function_with_if;
+}
 
 namespace
 {
@@ -32,7 +36,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_rewrite_aggregate_function_with_if)
+        if (!getSettings()[Setting::optimize_rewrite_aggregate_function_with_if])
             return;
 
         auto * function_node = node->as<FunctionNode>();

src/Analyzer/Passes/RewriteSumFunctionWithSumAndCountPass.cpp

@@ -11,6 +11,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_arithmetic_operations_in_aggregate_functions;
+}
 
 namespace
 {
@@ -23,7 +27,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_arithmetic_operations_in_aggregate_functions)
+        if (!getSettings()[Setting::optimize_arithmetic_operations_in_aggregate_functions])
             return;
 
         static const std::unordered_set<String> func_supported = {

src/Analyzer/Passes/SumIfToCountIfPass.cpp

@@ -14,6 +14,11 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool aggregate_functions_null_for_empty;
+    extern const SettingsBool optimize_rewrite_sum_if_to_count_if;
+}
 
 namespace
 {
@@ -26,7 +31,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_rewrite_sum_if_to_count_if)
+        if (!getSettings()[Setting::optimize_rewrite_sum_if_to_count_if])
             return;
 
         auto * function_node = node->as<FunctionNode>();
@@ -56,7 +61,7 @@ public:
                 return;
 
             const auto & constant_value_literal = constant_node->getValue();
-            if (getSettings().aggregate_functions_null_for_empty)
+            if (getSettings()[Setting::aggregate_functions_null_for_empty])
                 return;
 
             /// Rewrite `sumIf(1, cond)` into `countIf(cond)`

src/Analyzer/Passes/UniqInjectiveFunctionsEliminationPass.cpp

@@ -14,6 +14,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_injective_functions_inside_uniq;
+}
 
 namespace
 {
@@ -36,7 +40,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_injective_functions_inside_uniq)
+        if (!getSettings()[Setting::optimize_injective_functions_inside_uniq])
             return;
 
         auto * function_node = node->as<FunctionNode>();

src/Analyzer/Passes/UniqToCountPass.cpp

@@ -13,6 +13,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool optimize_uniq_to_count;
+}
 
 namespace
 {
@@ -123,7 +127,7 @@ public:
 
     void enterImpl(QueryTreeNodePtr & node)
     {
-        if (!getSettings().optimize_uniq_to_count)
+        if (!getSettings()[Setting::optimize_uniq_to_count])
             return;
 
         auto * query_node = node->as<QueryNode>();

src/Analyzer/QueryTreeBuilder.cpp

@@ -50,6 +50,17 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool allow_experimental_variant_type;
+    extern const SettingsBool any_join_distinct_right_table_keys;
+    extern const SettingsJoinStrictness join_default_strictness;
+    extern const SettingsBool enable_order_by_all;
+    extern const SettingsUInt64 limit;
+    extern const SettingsUInt64 offset;
+    extern const SettingsBool use_variant_as_common_type;
+}
+
 
 namespace ErrorCodes
 {
@@ -235,13 +246,13 @@ QueryTreeNodePtr QueryTreeBuilder::buildSelectExpression(const ASTPtr & select_q
     UInt64 offset = 0;
 
     /// Remove global settings limit and offset
-    if (const auto & settings_ref = updated_context->getSettingsRef(); settings_ref.limit || settings_ref.offset)
+    if (const auto & settings_ref = updated_context->getSettingsRef(); settings_ref[Setting::limit] || settings_ref[Setting::offset])
     {
         Settings settings = updated_context->getSettingsCopy();
-        limit = settings.limit;
-        offset = settings.offset;
-        settings.limit = 0;
-        settings.offset = 0;
+        limit = settings[Setting::limit];
+        offset = settings[Setting::offset];
+        settings[Setting::limit] = 0;
+        settings[Setting::offset] = 0;
         updated_context->setSettings(settings);
     }
 
@@ -268,7 +279,7 @@ QueryTreeNodePtr QueryTreeBuilder::buildSelectExpression(const ASTPtr & select_q
         }
     }
 
-    const auto enable_order_by_all = updated_context->getSettingsRef().enable_order_by_all;
+    const auto enable_order_by_all = updated_context->getSettingsRef()[Setting::enable_order_by_all];
 
     auto current_query_tree = std::make_shared<QueryNode>(std::move(updated_context), std::move(settings_changes));
 
@@ -577,7 +588,7 @@ QueryTreeNodePtr QueryTreeBuilder::buildExpression(const ASTPtr & expression, co
     }
     else if (const auto * ast_literal = expression->as<ASTLiteral>())
     {
-        if (context->getSettingsRef().allow_experimental_variant_type && context->getSettingsRef().use_variant_as_common_type)
+        if (context->getSettingsRef()[Setting::allow_experimental_variant_type] && context->getSettingsRef()[Setting::use_variant_as_common_type])
             result = std::make_shared<ConstantNode>(ast_literal->value, applyVisitor(FieldToDataType<LeastSupertypeOnError::Variant>(), ast_literal->value));
         else
             result = std::make_shared<ConstantNode>(ast_literal->value);
@@ -908,8 +919,8 @@ QueryTreeNodePtr QueryTreeBuilder::buildJoinTree(const ASTPtr & tables_in_select
                 join_expression = buildExpression(table_join.on_expression, context);
 
             const auto & settings = context->getSettingsRef();
-            auto join_default_strictness = settings.join_default_strictness;
-            auto any_join_distinct_right_table_keys = settings.any_join_distinct_right_table_keys;
+            auto join_default_strictness = settings[Setting::join_default_strictness];
+            auto any_join_distinct_right_table_keys = settings[Setting::any_join_distinct_right_table_keys];
 
             JoinStrictness result_join_strictness = table_join.strictness;
             JoinKind result_join_kind = table_join.kind;

src/Analyzer/Resolve/IdentifierResolveScope.cpp

@@ -7,6 +7,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool group_by_use_nulls;
+    extern const SettingsBool join_use_nulls;
+}
+
 namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
@@ -32,12 +38,12 @@ IdentifierResolveScope::IdentifierResolveScope(QueryTreeNodePtr scope_node_, Ide
     else if (auto * query_node = scope_node->as<QueryNode>())
     {
         context = query_node->getContext();
-        group_by_use_nulls = context->getSettingsRef().group_by_use_nulls &&
-            (query_node->isGroupByWithGroupingSets() || query_node->isGroupByWithRollup() || query_node->isGroupByWithCube());
+        group_by_use_nulls = context->getSettingsRef()[Setting::group_by_use_nulls]
+            && (query_node->isGroupByWithGroupingSets() || query_node->isGroupByWithRollup() || query_node->isGroupByWithCube());
     }
 
     if (context)
-        join_use_nulls = context->getSettingsRef().join_use_nulls;
+        join_use_nulls = context->getSettingsRef()[Setting::join_use_nulls];
     else if (parent_scope)
         join_use_nulls = parent_scope->join_use_nulls;
 

src/Analyzer/Resolve/IdentifierResolver.cpp

@@ -30,6 +30,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsSeconds lock_acquire_timeout;
+    extern const SettingsBool single_join_prefer_left_table;
+}
+
 namespace ErrorCodes
 {
     extern const int UNKNOWN_IDENTIFIER;
@@ -420,7 +426,7 @@ QueryTreeNodePtr IdentifierResolver::tryResolveTableIdentifierFromDatabaseCatalo
     if (!storage)
         return {};
 
-    auto storage_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef().lock_acquire_timeout);
+    auto storage_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]);
     auto storage_snapshot = storage->getStorageSnapshot(storage->getInMemoryMetadataPtr(), context);
     auto result = std::make_shared<TableNode>(std::move(storage), std::move(storage_lock), std::move(storage_snapshot));
     if (is_temporary_table)
@@ -1155,7 +1161,7 @@ QueryTreeNodePtr IdentifierResolver::tryResolveIdentifierFromJoin(const Identifi
                 resolved_identifier = left_resolved_identifier;
             }
         }
-        else if (scope.joins_count == 1 && scope.context->getSettingsRef().single_join_prefer_left_table)
+        else if (scope.joins_count == 1 && scope.context->getSettingsRef()[Setting::single_join_prefer_left_table])
         {
             resolved_side = JoinTableSide::Left;
             resolved_identifier = left_resolved_identifier;

src/Analyzer/Resolve/QueryAnalyzer.cpp

@@ -77,6 +77,35 @@ namespace ProfileEvents
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool aggregate_functions_null_for_empty;
+    extern const SettingsBool analyzer_compatibility_join_using_top_level_identifier;
+    extern const SettingsBool asterisk_include_alias_columns;
+    extern const SettingsBool asterisk_include_materialized_columns;
+    extern const SettingsString count_distinct_implementation;
+    extern const SettingsBool enable_global_with_statement;
+    extern const SettingsBool enable_order_by_all;
+    extern const SettingsBool enable_positional_arguments;
+    extern const SettingsBool enable_scalar_subquery_optimization;
+    extern const SettingsBool extremes;
+    extern const SettingsBool force_grouping_standard_compatibility;
+    extern const SettingsBool format_display_secrets_in_show_and_select;
+    extern const SettingsBool joined_subquery_requires_alias;
+    extern const SettingsUInt64 max_bytes_in_set;
+    extern const SettingsUInt64 max_expanded_ast_elements;
+    extern const SettingsUInt64 max_result_rows;
+    extern const SettingsUInt64 max_rows_in_set;
+    extern const SettingsUInt64 max_subquery_depth;
+    extern const SettingsBool prefer_column_name_to_alias;
+    extern const SettingsBool rewrite_count_distinct_if_with_count_distinct_implementation;
+    extern const SettingsOverflowMode set_overflow_mode;
+    extern const SettingsBool single_join_prefer_left_table;
+    extern const SettingsBool transform_null_in;
+    extern const SettingsUInt64 use_structure_from_insertion_table_in_table_functions;
+}
+
+
 namespace ErrorCodes
 {
     extern const int UNSUPPORTED_METHOD;
@@ -506,8 +535,8 @@ void QueryAnalyzer::evaluateScalarSubqueryIfNeeded(QueryTreeNodePtr & node, Iden
         auto subquery_context = Context::createCopy(context);
 
         Settings subquery_settings = context->getSettingsCopy();
-        subquery_settings.max_result_rows = 1;
-        subquery_settings.extremes = false;
+        subquery_settings[Setting::max_result_rows] = 1;
+        subquery_settings[Setting::extremes] = false;
         subquery_context->setSettings(subquery_settings);
         /// When execute `INSERT INTO t WITH ... SELECT ...`, it may lead to `Unknown columns`
         /// exception with this settings enabled(https://github.com/ClickHouse/ClickHouse/issues/52494).
@@ -627,10 +656,8 @@ void QueryAnalyzer::evaluateScalarSubqueryIfNeeded(QueryTreeNodePtr & node, Iden
     auto * nearest_query_scope = scope.getNearestQueryScope();
 
     /// Always convert to literals when there is no query context
-    if (!context->getSettingsRef().enable_scalar_subquery_optimization ||
-        !useless_literal_types.contains(scalar_type_name) ||
-        !context->hasQueryContext() ||
-        !nearest_query_scope)
+    if (!context->getSettingsRef()[Setting::enable_scalar_subquery_optimization] || !useless_literal_types.contains(scalar_type_name)
+        || !context->hasQueryContext() || !nearest_query_scope)
     {
         auto constant_value = std::make_shared<ConstantValue>(std::move(scalar_value), scalar_type);
         auto constant_node = std::make_shared<ConstantNode>(constant_value, node);
@@ -726,7 +753,7 @@ void QueryAnalyzer::mergeWindowWithParentWindow(const QueryTreeNodePtr & window_
 void QueryAnalyzer::replaceNodesWithPositionalArguments(QueryTreeNodePtr & node_list, const QueryTreeNodes & projection_nodes, IdentifierResolveScope & scope)
 {
     const auto & settings = scope.context->getSettingsRef();
-    if (!settings.enable_positional_arguments || scope.context->getClientInfo().query_kind != ClientInfo::QueryKind::INITIAL_QUERY)
+    if (!settings[Setting::enable_positional_arguments] || scope.context->getClientInfo().query_kind != ClientInfo::QueryKind::INITIAL_QUERY)
         return;
 
     auto & node_list_typed = node_list->as<ListNode &>();
@@ -843,7 +870,7 @@ void QueryAnalyzer::validateTableExpressionModifiers(const QueryTreeNodePtr & ta
 
 void QueryAnalyzer::validateJoinTableExpressionWithoutAlias(const QueryTreeNodePtr & join_node, const QueryTreeNodePtr & table_expression_node, IdentifierResolveScope & scope)
 {
-    if (!scope.context->getSettingsRef().joined_subquery_requires_alias)
+    if (!scope.context->getSettingsRef()[Setting::joined_subquery_requires_alias])
         return;
 
     bool table_expression_has_alias = table_expression_node->hasAlias();
@@ -938,7 +965,7 @@ void QueryAnalyzer::expandGroupByAll(QueryNode & query_tree_node_typed)
 
 void QueryAnalyzer::expandOrderByAll(QueryNode & query_tree_node_typed, const Settings & settings)
 {
-    if (!settings.enable_order_by_all || !query_tree_node_typed.isOrderByAll())
+    if (!settings[Setting::enable_order_by_all] || !query_tree_node_typed.isOrderByAll())
         return;
 
     auto * all_node = query_tree_node_typed.getOrderBy().getNodes()[0]->as<SortNode>();
@@ -989,12 +1016,14 @@ std::string QueryAnalyzer::rewriteAggregateFunctionNameIfNeeded(
 
     if (aggregate_function_name_lowercase == "countdistinct")
     {
-        result_aggregate_function_name = settings.count_distinct_implementation;
+        result_aggregate_function_name = settings[Setting::count_distinct_implementation];
     }
-    else if (aggregate_function_name_lowercase == "countifdistinct" ||
-        (settings.rewrite_count_distinct_if_with_count_distinct_implementation && aggregate_function_name_lowercase == "countdistinctif"))
+    else if (
+        aggregate_function_name_lowercase == "countifdistinct"
+        || (settings[Setting::rewrite_count_distinct_if_with_count_distinct_implementation]
+            && aggregate_function_name_lowercase == "countdistinctif"))
     {
-        result_aggregate_function_name = settings.count_distinct_implementation;
+        result_aggregate_function_name = settings[Setting::count_distinct_implementation];
         result_aggregate_function_name += "If";
     }
     else if (aggregate_function_name_lowercase.ends_with("ifdistinct"))
@@ -1004,7 +1033,7 @@ std::string QueryAnalyzer::rewriteAggregateFunctionNameIfNeeded(
         result_aggregate_function_name = result_aggregate_function_name.substr(0, prefix_length) + "DistinctIf";
     }
 
-    bool need_add_or_null = settings.aggregate_functions_null_for_empty && !result_aggregate_function_name.ends_with("OrNull");
+    bool need_add_or_null = settings[Setting::aggregate_functions_null_for_empty] && !result_aggregate_function_name.ends_with("OrNull");
     if (need_add_or_null)
     {
         auto properties = AggregateFunctionFactory::instance().tryGetProperties(result_aggregate_function_name, action);
@@ -1215,7 +1244,7 @@ IdentifierResolveResult QueryAnalyzer::tryResolveIdentifierInParentScopes(const
         }
     }
 
-    if (!scope.context->getSettingsRef().enable_global_with_statement)
+    if (!scope.context->getSettingsRef()[Setting::enable_global_with_statement])
         return {};
 
     /** Nested subqueries cannot access outer subqueries table expressions from JOIN tree because
@@ -1347,7 +1376,7 @@ IdentifierResolveResult QueryAnalyzer::tryResolveIdentifier(const IdentifierLook
 
     if (!resolve_result.resolved_identifier)
     {
-        bool prefer_column_name_to_alias = scope.context->getSettingsRef().prefer_column_name_to_alias;
+        bool prefer_column_name_to_alias = scope.context->getSettingsRef()[Setting::prefer_column_name_to_alias];
 
         if (identifier_lookup.isExpressionLookup())
         {
@@ -1558,10 +1587,10 @@ GetColumnsOptions QueryAnalyzer::buildGetColumnsOptions(QueryTreeNodePtr & match
 
         const auto & settings = context->getSettingsRef();
 
-        if (settings.asterisk_include_alias_columns)
+        if (settings[Setting::asterisk_include_alias_columns])
             get_columns_options_kind |= GetColumnsOptions::Kind::Aliases;
 
-        if (settings.asterisk_include_materialized_columns)
+        if (settings[Setting::asterisk_include_materialized_columns])
             get_columns_options_kind |= GetColumnsOptions::Kind::Materialized;
     }
 
@@ -2564,8 +2593,8 @@ void checkFunctionNodeHasEmptyNullsAction(FunctionNode const & node)
     if (node.getNullsAction() != NullsAction::EMPTY)
         throw Exception(
             ErrorCodes::SYNTAX_ERROR,
-            "Function with name '{}' cannot use {} NULLS",
-            node.getFunctionName(),
+            "Function with name {} cannot use {} NULLS",
+            backQuote(node.getFunctionName()),
             node.getNullsAction() == NullsAction::IGNORE_NULLS ? "IGNORE" : "RESPECT");
 }
 }
@@ -2810,7 +2839,7 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
         allow_table_expressions /*allow_table_expression*/);
 
     /// Mask arguments if needed
-    if (!scope.context->getSettingsRef().format_display_secrets_in_show_and_select)
+    if (!scope.context->getSettingsRef()[Setting::format_display_secrets_in_show_and_select])
     {
         if (FunctionSecretArgumentsFinder::Result secret_arguments = FunctionSecretArgumentsFinderTreeNode(*function_node_ptr).getResult(); secret_arguments.count)
         {
@@ -2834,7 +2863,7 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
     if (is_special_function_in)
     {
         checkFunctionNodeHasEmptyNullsAction(function_node);
-        if (scope.context->getSettingsRef().transform_null_in)
+        if (scope.context->getSettingsRef()[Setting::transform_null_in])
         {
             static constexpr std::array<std::pair<std::string_view, std::string_view>, 4> in_function_to_replace_null_in_function_map =
             {{
@@ -3134,7 +3163,7 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
                     function_arguments_size);
             checkFunctionNodeHasEmptyNullsAction(function_node);
 
-            bool force_grouping_standard_compatibility = scope.context->getSettingsRef().force_grouping_standard_compatibility;
+            bool force_grouping_standard_compatibility = scope.context->getSettingsRef()[Setting::force_grouping_standard_compatibility];
             auto grouping_function = std::make_shared<FunctionGrouping>(force_grouping_standard_compatibility);
             auto grouping_function_adaptor = std::make_shared<FunctionToOverloadResolverAdaptor>(std::move(grouping_function));
             function_node.resolveAsFunction(grouping_function_adaptor->build(argument_columns));
@@ -3228,16 +3257,16 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
             auto hints = NamePrompter<2>::getHints(function_name, possible_function_names);
 
             throw Exception(ErrorCodes::UNKNOWN_FUNCTION,
-                "Function with name '{}' does not exist. In scope {}{}",
-                function_name,
+                "Function with name {} does not exist. In scope {}{}",
+                backQuote(function_name),
                 scope.scope_node->formatASTForErrorMessage(),
                 getHintsErrorMessageSuffix(hints));
         }
 
         if (!function_lambda_arguments_indexes.empty())
             throw Exception(ErrorCodes::UNSUPPORTED_METHOD,
-                "Aggregate function '{}' does not support lambda arguments",
-                function_name);
+                "Aggregate function {} does not support lambda arguments",
+                backQuote(function_name));
 
         auto action = function_node_ptr->getNullsAction();
         std::string aggregate_function_name = rewriteAggregateFunctionNameIfNeeded(function_name, action, scope.context);
@@ -3388,14 +3417,12 @@ ProjectionNames QueryAnalyzer::resolveFunction(QueryTreeNodePtr & node, Identifi
 
             const auto & settings = scope.context->getSettingsRef();
 
-            auto result_block = getSetElementsForConstantValue(first_argument_constant_type,
-                second_argument_constant_literal,
-                second_argument_constant_type,
-                settings.transform_null_in);
+            auto result_block = getSetElementsForConstantValue(
+                first_argument_constant_type, second_argument_constant_literal, second_argument_constant_type, settings[Setting::transform_null_in]);
 
-            SizeLimits size_limits_for_set = {settings.max_rows_in_set, settings.max_bytes_in_set, settings.set_overflow_mode};
+            SizeLimits size_limits_for_set = {settings[Setting::max_rows_in_set], settings[Setting::max_bytes_in_set], settings[Setting::set_overflow_mode]};
 
-            auto set = std::make_shared<Set>(size_limits_for_set, 0, settings.transform_null_in);
+            auto set = std::make_shared<Set>(size_limits_for_set, 0, settings[Setting::transform_null_in]);
 
             set->setHeader(result_block.cloneEmpty().getColumnsWithTypeAndName());
             set->insertFromBlock(result_block.getColumnsWithTypeAndName());
@@ -3679,10 +3706,10 @@ ProjectionNames QueryAnalyzer::resolveExpressionNode(
 
                 auto hints = IdentifierResolver::collectIdentifierTypoHints(unresolved_identifier, valid_identifiers);
 
-                throw Exception(ErrorCodes::UNKNOWN_IDENTIFIER, "Unknown {}{} identifier '{}' in scope {}{}",
+                throw Exception(ErrorCodes::UNKNOWN_IDENTIFIER, "Unknown {}{} identifier {} in scope {}{}",
                     toStringLowercase(IdentifierLookupContext::EXPRESSION),
                     message_clarification,
-                    unresolved_identifier.getFullName(),
+                    backQuote(unresolved_identifier.getFullName()),
                     scope.scope_node->formatASTForErrorMessage(),
                     getHintsErrorMessageSuffix(hints));
             }
@@ -3826,10 +3853,10 @@ ProjectionNames QueryAnalyzer::resolveExpressionNode(
         }
     }
 
-    validateTreeSize(node, scope.context->getSettingsRef().max_expanded_ast_elements, node_to_tree_size);
+    validateTreeSize(node, scope.context->getSettingsRef()[Setting::max_expanded_ast_elements], node_to_tree_size);
 
     /// Lambda can be inside the aggregate function, so we should check parent scopes.
-    /// Most likely only the root scope can have an arrgegate function, but let's check all just in case.
+    /// Most likely only the root scope can have an aggregate function, but let's check all just in case.
     bool in_aggregate_function_scope = false;
     for (const auto * scope_ptr = &scope; scope_ptr; scope_ptr = scope_ptr->parent_scope)
         in_aggregate_function_scope = in_aggregate_function_scope || scope_ptr->expressions_in_resolve_process_stack.hasAggregateFunction();
@@ -4473,9 +4500,9 @@ void QueryAnalyzer::initializeTableExpressionData(const QueryTreeNodePtr & table
     if (auto * scope_query_node = scope.scope_node->as<QueryNode>())
     {
         auto left_table_expression = extractLeftTableExpression(scope_query_node->getJoinTree());
-        if (table_expression_node.get() == left_table_expression.get() &&
-            scope.joins_count == 1 && scope.context->getSettingsRef().single_join_prefer_left_table)
-                table_expression_data.should_qualify_columns = false;
+        if (table_expression_node.get() == left_table_expression.get() && scope.joins_count == 1
+            && scope.context->getSettingsRef()[Setting::single_join_prefer_left_table])
+            table_expression_data.should_qualify_columns = false;
     }
 
     scope.table_expression_node_to_data.emplace(table_expression_node, std::move(table_expression_data));
@@ -4672,11 +4699,10 @@ void QueryAnalyzer::resolveTableFunction(QueryTreeNodePtr & table_function_node,
     table_function_ptr->parseArguments(table_function_ast, scope_context);
 
 
-    uint64_t use_structure_from_insertion_table_in_table_functions = scope_context->getSettingsRef().use_structure_from_insertion_table_in_table_functions;
-    if (!nested_table_function &&
-        use_structure_from_insertion_table_in_table_functions &&
-        scope_context->hasInsertionTable() &&
-        table_function_ptr->needStructureHint())
+    uint64_t use_structure_from_insertion_table_in_table_functions
+        = scope_context->getSettingsRef()[Setting::use_structure_from_insertion_table_in_table_functions];
+    if (!nested_table_function && use_structure_from_insertion_table_in_table_functions && scope_context->hasInsertionTable()
+        && table_function_ptr->needStructureHint())
     {
         const auto & insertion_table = scope_context->getInsertionTable();
         if (!insertion_table.empty())
@@ -4806,8 +4832,8 @@ void QueryAnalyzer::resolveTableFunction(QueryTreeNodePtr & table_function_node,
 
                     if (!structure_hint.empty())
                         table_function_ptr->setStructureHint(structure_hint);
-
-                } else if (use_structure_from_insertion_table_in_table_functions == 1)
+                }
+                else if (use_structure_from_insertion_table_in_table_functions == 1)
                     throw Exception(ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH, "Number of columns in insert table less than required by SELECT expression.");
             }
         }
@@ -4931,7 +4957,7 @@ void QueryAnalyzer::resolveArrayJoin(QueryTreeNodePtr & array_join_node, Identif
 void QueryAnalyzer::checkDuplicateTableNamesOrAlias(const QueryTreeNodePtr & join_node, QueryTreeNodePtr & left_table_expr, QueryTreeNodePtr & right_table_expr, IdentifierResolveScope & scope)
 {
     Names column_names;
-    if (!scope.context->getSettingsRef().joined_subquery_requires_alias)
+    if (!scope.context->getSettingsRef()[Setting::joined_subquery_requires_alias])
         return;
 
     if (join_node->as<JoinNode &>().getKind() != JoinKind::Paste)
@@ -5051,7 +5077,7 @@ void QueryAnalyzer::resolveJoin(QueryTreeNodePtr & join_node, IdentifierResolveS
               * despite the fact that column from USING could be resolved from left table.
               * It's compatibility with a default behavior for old analyzer.
               */
-            if (settings.analyzer_compatibility_join_using_top_level_identifier)
+            if (settings[Setting::analyzer_compatibility_join_using_top_level_identifier])
                 result_left_table_expression = try_resolve_identifier_from_query_projection(identifier_full_name, join_node_typed.getLeftTableExpression(), scope);
 
             IdentifierLookup identifier_lookup{identifier_node->getIdentifier(), IdentifierLookupContext::EXPRESSION};
@@ -5070,7 +5096,7 @@ void QueryAnalyzer::resolveJoin(QueryTreeNodePtr & join_node, IdentifierResolveS
             {
                 String extra_message;
                 const QueryNode * query_node = scope.scope_node ? scope.scope_node->as<QueryNode>() : nullptr;
-                if (settings.analyzer_compatibility_join_using_top_level_identifier && query_node)
+                if (settings[Setting::analyzer_compatibility_join_using_top_level_identifier] && query_node)
                 {
                     for (const auto & projection_node : query_node->getProjection().getNodes())
                     {
@@ -5250,11 +5276,9 @@ void QueryAnalyzer::resolveQueryJoinTreeNode(QueryTreeNodePtr & join_tree_node,
   */
 void QueryAnalyzer::resolveQuery(const QueryTreeNodePtr & query_node, IdentifierResolveScope & scope)
 {
-    size_t max_subquery_depth = scope.context->getSettingsRef().max_subquery_depth;
+    size_t max_subquery_depth = scope.context->getSettingsRef()[Setting::max_subquery_depth];
     if (max_subquery_depth && scope.subquery_depth > max_subquery_depth)
-        throw Exception(ErrorCodes::TOO_DEEP_SUBQUERIES,
-            "Too deep subqueries. Maximum: {}",
-            max_subquery_depth);
+        throw Exception(ErrorCodes::TOO_DEEP_SUBQUERIES, "Too deep subqueries. Maximum: {}", max_subquery_depth);
 
     auto & query_node_typed = query_node->as<QueryNode &>();
 
@@ -5588,7 +5612,7 @@ void QueryAnalyzer::resolveQuery(const QueryTreeNodePtr & query_node, Identifier
     expandGroupByAll(query_node_typed);
 
     validateFilters(query_node);
-    validateAggregates(query_node, { .group_by_use_nulls = scope.group_by_use_nulls });
+    validateAggregates(query_node, {.group_by_use_nulls = scope.group_by_use_nulls});
 
     for (const auto & column : projection_columns)
     {

src/Analyzer/TableNode.cpp

@@ -14,6 +14,10 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsSeconds lock_acquire_timeout;
+}
 
 TableNode::TableNode(StoragePtr storage_, StorageID storage_id_, TableLockHolder storage_lock_, StorageSnapshotPtr storage_snapshot_)
     : IQueryTreeNode(children_size)
@@ -29,9 +33,10 @@ TableNode::TableNode(StoragePtr storage_, TableLockHolder storage_lock_, Storage
 }
 
 TableNode::TableNode(StoragePtr storage_, const ContextPtr & context)
-    : TableNode(storage_,
-        storage_->lockForShare(context->getInitialQueryId(), context->getSettingsRef().lock_acquire_timeout),
-        storage_->getStorageSnapshot(storage_->getInMemoryMetadataPtr(), context))
+    : TableNode(
+          storage_,
+          storage_->lockForShare(context->getInitialQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]),
+          storage_->getStorageSnapshot(storage_->getInMemoryMetadataPtr(), context))
 {
 }
 
@@ -39,7 +44,7 @@ void TableNode::updateStorage(StoragePtr storage_value, const ContextPtr & conte
 {
     storage = std::move(storage_value);
     storage_id = storage->getStorageID();
-    storage_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef().lock_acquire_timeout);
+    storage_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]);
     storage_snapshot = storage->getStorageSnapshot(storage->getInMemoryMetadataPtr(), context);
 }
 

src/Analyzer/Utils.cpp

@@ -36,6 +36,12 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsBool extremes;
+    extern const SettingsUInt64 max_result_bytes;
+    extern const SettingsUInt64 max_result_rows;
+}
 
 namespace ErrorCodes
 {
@@ -868,10 +874,10 @@ void updateContextForSubqueryExecution(ContextMutablePtr & mutable_context)
       *  which are checked separately (in the Set, Join objects).
       */
     Settings subquery_settings = mutable_context->getSettingsCopy();
-    subquery_settings.max_result_rows = 0;
-    subquery_settings.max_result_bytes = 0;
+    subquery_settings[Setting::max_result_rows] = 0;
+    subquery_settings[Setting::max_result_bytes] = 0;
     /// The calculation of extremes does not make sense and is not necessary (if you do it, then the extremes of the subquery can be taken for whole query).
-    subquery_settings.extremes = false;
+    subquery_settings[Setting::extremes] = false;
     mutable_context->setSettings(subquery_settings);
 }
 

src/Backups/BackupEntriesCollector.cpp

@@ -35,6 +35,13 @@ namespace ProfileEvents
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 backup_restore_keeper_retry_initial_backoff_ms;
+    extern const SettingsUInt64 backup_restore_keeper_retry_max_backoff_ms;
+    extern const SettingsUInt64 backup_restore_keeper_max_retries;
+    extern const SettingsSeconds lock_acquire_timeout;
+}
 
 namespace ErrorCodes
 {
@@ -105,9 +112,9 @@ BackupEntriesCollector::BackupEntriesCollector(
     , compare_collected_metadata(context->getConfigRef().getBool("backups.compare_collected_metadata", true))
     , log(getLogger("BackupEntriesCollector"))
     , global_zookeeper_retries_info(
-          context->getSettingsRef().backup_restore_keeper_max_retries,
-          context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
-          context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms)
+          context->getSettingsRef()[Setting::backup_restore_keeper_max_retries],
+          context->getSettingsRef()[Setting::backup_restore_keeper_retry_initial_backoff_ms],
+          context->getSettingsRef()[Setting::backup_restore_keeper_retry_max_backoff_ms])
     , threadpool(threadpool_)
 {
 }
@@ -653,7 +660,7 @@ void BackupEntriesCollector::lockTablesForReading()
 
         checkIsQueryCancelled();
 
-        table_info.table_lock = storage->tryLockForShare(context->getInitialQueryId(), context->getSettingsRef().lock_acquire_timeout);
+        table_info.table_lock = storage->tryLockForShare(context->getInitialQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]);
     }
 
     std::erase_if(

src/Backups/BackupIO_S3.cpp

@@ -25,6 +25,16 @@ namespace fs = std::filesystem;
 
 namespace DB
 {
+
+namespace Setting
+{
+    extern const SettingsUInt64 backup_restore_s3_retry_attempts;
+    extern const SettingsBool enable_s3_requests_logging;
+    extern const SettingsBool s3_disable_checksum;
+    extern const SettingsUInt64 s3_max_connections;
+    extern const SettingsUInt64 s3_max_redirects;
+}
+
 namespace ErrorCodes
 {
     extern const int S3_ERROR;
@@ -55,16 +65,16 @@ namespace
         S3::PocoHTTPClientConfiguration client_configuration = S3::ClientFactory::instance().createClientConfiguration(
             settings.auth_settings.region,
             context->getRemoteHostFilter(),
-            static_cast<unsigned>(local_settings.s3_max_redirects),
-            static_cast<unsigned>(local_settings.backup_restore_s3_retry_attempts),
-            local_settings.enable_s3_requests_logging,
+            static_cast<unsigned>(local_settings[Setting::s3_max_redirects]),
+            static_cast<unsigned>(local_settings[Setting::backup_restore_s3_retry_attempts]),
+            local_settings[Setting::enable_s3_requests_logging],
             /* for_disk_s3 = */ false,
             request_settings.get_request_throttler,
             request_settings.put_request_throttler,
             s3_uri.uri.getScheme());
 
         client_configuration.endpointOverride = s3_uri.endpoint;
-        client_configuration.maxConnections = static_cast<unsigned>(global_settings.s3_max_connections);
+        client_configuration.maxConnections = static_cast<unsigned>(global_settings[Setting::s3_max_connections]);
         /// Increase connect timeout
         client_configuration.connectTimeoutMs = 10 * 1000;
         /// Requests in backups can be extremely long, set to one hour
@@ -74,7 +84,7 @@ namespace
 
         S3::ClientSettings client_settings{
             .use_virtual_addressing = s3_uri.is_virtual_hosted_style,
-            .disable_checksum = local_settings.s3_disable_checksum,
+            .disable_checksum = local_settings[Setting::s3_disable_checksum],
             .gcs_issue_compose_request = context->getConfigRef().getBool("s3.gcs_issue_compose_request", false),
             .is_s3express_bucket = S3::isS3ExpressEndpoint(s3_uri.endpoint),
         };

src/Backups/BackupsWorker.cpp

@@ -43,6 +43,15 @@ namespace CurrentMetrics
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsUInt64 backup_restore_batch_size_for_keeper_multiread;
+    extern const SettingsUInt64 backup_restore_keeper_max_retries;
+    extern const SettingsUInt64 backup_restore_keeper_retry_initial_backoff_ms;
+    extern const SettingsUInt64 backup_restore_keeper_retry_max_backoff_ms;
+    extern const SettingsUInt64 backup_restore_keeper_fault_injection_seed;
+    extern const SettingsFloat backup_restore_keeper_fault_injection_probability;
+}
 
 namespace ErrorCodes
 {
@@ -98,12 +107,12 @@ namespace
 
             RestoreCoordinationRemote::RestoreKeeperSettings keeper_settings
             {
-                .keeper_max_retries = context->getSettingsRef().backup_restore_keeper_max_retries,
-                .keeper_retry_initial_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
-                .keeper_retry_max_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms,
-                .batch_size_for_keeper_multiread = context->getSettingsRef().backup_restore_batch_size_for_keeper_multiread,
-                .keeper_fault_injection_probability = context->getSettingsRef().backup_restore_keeper_fault_injection_probability,
-                .keeper_fault_injection_seed = context->getSettingsRef().backup_restore_keeper_fault_injection_seed
+                .keeper_max_retries = context->getSettingsRef()[Setting::backup_restore_keeper_max_retries],
+                .keeper_retry_initial_backoff_ms = context->getSettingsRef()[Setting::backup_restore_keeper_retry_initial_backoff_ms],
+                .keeper_retry_max_backoff_ms = context->getSettingsRef()[Setting::backup_restore_keeper_retry_max_backoff_ms],
+                .batch_size_for_keeper_multiread = context->getSettingsRef()[Setting::backup_restore_batch_size_for_keeper_multiread],
+                .keeper_fault_injection_probability = context->getSettingsRef()[Setting::backup_restore_keeper_fault_injection_probability],
+                .keeper_fault_injection_seed = context->getSettingsRef()[Setting::backup_restore_keeper_fault_injection_seed]
             };
 
             auto all_hosts = BackupSettings::Util::filterHostIDs(

src/Backups/RestorerFromBackup.cpp

@@ -36,6 +36,11 @@ namespace fs = std::filesystem;
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsSeconds lock_acquire_timeout;
+}
+
 namespace ErrorCodes
 {
     extern const int BACKUP_ENTRY_NOT_FOUND;
@@ -949,7 +954,7 @@ void RestorerFromBackup::checkTable(const QualifiedTableName & table_name)
 
         StoragePtr storage = database->getTable(resolved_id.table_name, context);
         table_info.storage = storage;
-        table_info.table_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef().lock_acquire_timeout);
+        table_info.table_lock = storage->lockForShare(context->getInitialQueryId(), context->getSettingsRef()[Setting::lock_acquire_timeout]);
 
         if (!restore_settings.allow_different_table_def && !table_info.is_predefined_table)
         {

src/Backups/WithRetries.cpp

@@ -5,20 +5,30 @@
 
 namespace DB
 {
-
+namespace Setting
+{
+    extern const SettingsUInt64 backup_restore_keeper_max_retries;
+    extern const SettingsUInt64 backup_restore_keeper_retry_initial_backoff_ms;
+    extern const SettingsUInt64 backup_restore_keeper_retry_max_backoff_ms;
+    extern const SettingsUInt64 backup_restore_batch_size_for_keeper_multiread;
+    extern const SettingsFloat backup_restore_keeper_fault_injection_probability;
+    extern const SettingsUInt64 backup_restore_keeper_fault_injection_seed;
+    extern const SettingsUInt64 backup_restore_keeper_value_max_size;
+    extern const SettingsUInt64 backup_restore_batch_size_for_keeper_multi;
+}
 
 WithRetries::KeeperSettings WithRetries::KeeperSettings::fromContext(ContextPtr context)
 {
     return
     {
-        .keeper_max_retries = context->getSettingsRef().backup_restore_keeper_max_retries,
-        .keeper_retry_initial_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_initial_backoff_ms,
-        .keeper_retry_max_backoff_ms = context->getSettingsRef().backup_restore_keeper_retry_max_backoff_ms,
-        .batch_size_for_keeper_multiread = context->getSettingsRef().backup_restore_batch_size_for_keeper_multiread,
-        .keeper_fault_injection_probability = context->getSettingsRef().backup_restore_keeper_fault_injection_probability,
-        .keeper_fault_injection_seed = context->getSettingsRef().backup_restore_keeper_fault_injection_seed,
-        .keeper_value_max_size = context->getSettingsRef().backup_restore_keeper_value_max_size,
-        .batch_size_for_keeper_multi = context->getSettingsRef().backup_restore_batch_size_for_keeper_multi,
+        .keeper_max_retries = context->getSettingsRef()[Setting::backup_restore_keeper_max_retries],
+        .keeper_retry_initial_backoff_ms = context->getSettingsRef()[Setting::backup_restore_keeper_retry_initial_backoff_ms],
+        .keeper_retry_max_backoff_ms = context->getSettingsRef()[Setting::backup_restore_keeper_retry_max_backoff_ms],
+        .batch_size_for_keeper_multiread = context->getSettingsRef()[Setting::backup_restore_batch_size_for_keeper_multiread],
+        .keeper_fault_injection_probability = context->getSettingsRef()[Setting::backup_restore_keeper_fault_injection_probability],
+        .keeper_fault_injection_seed = context->getSettingsRef()[Setting::backup_restore_keeper_fault_injection_seed],
+        .keeper_value_max_size = context->getSettingsRef()[Setting::backup_restore_keeper_value_max_size],
+        .batch_size_for_keeper_multi = context->getSettingsRef()[Setting::backup_restore_batch_size_for_keeper_multi],
     };
 }
 

src/BridgeHelper/CatBoostLibraryBridgeHelper.h

@@ -10,6 +10,8 @@
 
 namespace DB
 {
+struct ColumnWithTypeAndName;
+using ColumnsWithTypeAndName = std::vector<ColumnWithTypeAndName>;
 
 class CatBoostLibraryBridgeHelper final : public LibraryBridgeHelper
 {

src/BridgeHelper/IBridgeHelper.h

@@ -1,11 +1,12 @@
 #pragma once
 
 #include <Interpreters/Context.h>
-#include <Poco/Logger.h>
-#include <Poco/Util/AbstractConfiguration.h>
-#include <Poco/Net/HTTPRequest.h>
 #include <Common/ShellCommand.h>
 
+#include <Poco/Logger.h>
+#include <Poco/Net/HTTPRequest.h>
+#include <Poco/URI.h>
+#include <Poco/Util/AbstractConfiguration.h>
 
 namespace DB
 {

src/BridgeHelper/LibraryBridgeHelper.cpp

@@ -6,12 +6,16 @@
 
 namespace DB
 {
+namespace Setting
+{
+    extern const SettingsSeconds http_receive_timeout;
+}
 
 LibraryBridgeHelper::LibraryBridgeHelper(ContextPtr context_)
     : IBridgeHelper(context_)
     , config(context_->getConfigRef())
     , log(getLogger("LibraryBridgeHelper"))
-    , http_timeout(context_->getGlobalContext()->getSettingsRef().http_receive_timeout.value)
+    , http_timeout(context_->getGlobalContext()->getSettingsRef()[Setting::http_receive_timeout].value)
     , bridge_host(config.getString("library_bridge.host", DEFAULT_HOST))
     , bridge_port(config.getUInt("library_bridge.port", DEFAULT_PORT))
     , http_timeouts(ConnectionTimeouts::getHTTPTimeouts(context_->getSettingsRef(), context_->getServerSettings().keep_alive_timeout))

src/Client/ClientApplicationBase.cpp

@@ -2,7 +2,6 @@
 
 #include <base/argsToConfig.h>
 #include <base/safeExit.h>
-#include <Core/BaseSettingsProgramOptions.h>
 #include <Common/clearPasswordFromCommandLine.h>
 #include <Common/TerminalSize.h>
 #include <Common/Exception.h>