Hi, Feng.
I reviewed this FLIP again and found some little places that may need to
optimize.
1. `CatalogDescriptor` may need a private constructor.
2. The method `initCatalog` in `CatalogManager` is not introduced.
Best,
Hang
Feng Jin <jinfeng1...@gmail.com> 于2023年6月6日周二 21:17写道：
> Hi Leonard,
>
> Thanks for your reply.
>
> > 1. a How to construct a CatalogDescriptor ?
>
> I think it would be helpful to add a method for constructing a
> CatalogDescriptor, as you mentioned in 1.c. I will update the documentation
> later.
>
> > 1.b How to visit the fields ? Could we use Configuration instead of
> Map<String, String> ?
>
> I believe that the use of Map<String, String> options is only intended for
> creating a catalog and not for accessing internal parameters.
>
> Since all of the relevant parameters for CREATE CATALOG are also stored in
> Map<String, String> options, my understanding is that using Map<String,
> String> options should suffice.
>
> Here is the implementation of execute CREATE CATALOG statement.
> ```java
> private TableResultInternal createCatalog(CreateCatalogOperation operation)
> {
> String exMsg = getDDLOpExecuteErrorMsg(operation.asSummaryString());
> try {
> String catalogName = operation.getCatalogName();
> Map<String, String> properties = operation.getProperties();
>
> Catalog catalog =
> FactoryUtil.createCatalog(
> catalogName,
> properties,
> tableConfig,
> resourceManager.getUserClassLoader());
> catalogManager.registerCatalog(catalogName, catalog);
>
> return TableResultImpl.TABLE_RESULT_OK;
> } catch (CatalogException e) {
> throw new ValidationException(exMsg, e);
> }
> }
> ```
>
>
> > 2. Do we have plan to offer a default CatalogStore if user didn’t config
> this?
>
> Yes, the in-memory catalogStore will be used as the default CatalogStore
> even if the user has not configured one
>
>
> Best,
> Feng
>
>
> On Tue, Jun 6, 2023 at 8:02 PM Leonard Xu <xbjt...@gmail.com> wrote:
>
> > Hi, Feng
> >
> > Sorry for reply late, but I’ve some comments about the FLIP
> >
> >
> > 1. The introduced Public class CatalogDescriptor seems missed some
> > necessary component
> > a) How to construct a CatalogDescriptor ?
> > b) How to visit the fields ? Could we use Configuration instead of
> > Map<String, String> ?
> > c) Could we offer a built-in factory method to build a
> CatalogDescriptor
> > like
> > public static CatalogDescriptor of(String catalogName, Configuration
> > configuration)
> >
> > 2. The FLIP said “By default, there are two built-in CatalogStores
> > available: the In-Memory CatalogStore and the File CatalogStore” ,
> > Do we have plan to offer a default CatalogStore if user didn’t config
> > this? IIUC, users can obtains the benefits from lazy catalog
> > initialization If
> > we have a default catalogstore even it is in-memory.
> >
> > Best,
> > Leonard
> >
> >
> >
> > > On Jun 6, 2023, at 7:08 PM, Feng Jin <jinfeng1...@gmail.com> wrote:
> > >
> > > Hi everyone,
> > >
> > > Thank you everyone for your valuable input. If there are no further
> > > questions or concerns about the FLIP[1], I would like to start voting
> > > tomorrow (6/7).
> > >
> > >
> > > [1]
> > >
> >
> https://cwiki.apache.org/confluence/display/FLINK/FLIP-295%3A+Support+lazy+initialization+of+catalogs+and+persistence+of+catalog+configurations
> > >
> > >
> > > Best,
> > > Feng
> > >
> > >
> > > On Sun, Jun 4, 2023 at 3:33 PM Feng Jin <jinfeng1...@gmail.com> wrote:
> > >
> > >> Hi Samrat,
> > >>
> > >> Thanks for your advice.
> > >>
> > >>> 1. The createCatalog method does not mention any exceptions being
> > >> thrown.
> > >>
> > >> CreateCatalog will throw CatalogException like registerCatalog. As
> > >> CatalogException is a RuntimeException,
> > >> there is no explicit declaration of throwing Exceptions in
> > CatalogManager
> > >> and TableEnvironment.
> > >> To avoid misunderstandings, I have added the "throw CatalogException"
> > flag
> > >> to the createCatalog method definition of CatalogStore.
> > >>
> > >>> 2. Could you please provide an exhaustive list of the supported
> kinds?
> > >>
> > >> Sure, the documentation now includes the configuration of the
> built-in
> > >> CatalogStore as well as how to configure a custom CatalogStore.
> > >>
> > >>
> > >> Best,
> > >> Feng
> > >>
> > >>
> > >> On Sun, Jun 4, 2023 at 4:23 AM Samrat Deb <decordea...@gmail.com>
> > wrote:
> > >>
> > >>> Hi Feng,
> > >>>
> > >>> Thank you for providing the proposal. I believe this feature will be
> > >>> highly
> > >>> valuable.
> > >>>
> > >>> I have a couple of inquiries:
> > >>>
> > >>> 1. According to the documentation [1], the createCatalog method does
> > not
> > >>> mention any exceptions being thrown. However, I would like to confirm
> > if
> > >>> it
> > >>> is always true that there will be no failures in all scenarios.
> Please
> > let
> > >>> me know if there is any additional information I may have missed.
> > >>>
> > >>> 2. Regarding the registration process using the
> > `table.catalog-store.kind`
> > >>> configuration, could you please provide an exhaustive list of the
> > >>> supported
> > >>> kinds?
> > >>> It would be great to have a comprehensive understanding of the
> > options
> > >>> available.
> > >>>
> > >>> Bests,
> > >>> Samrat
> > >>>
> > >>> [1]
> > >>>
> > >>>
> >
> https://cwiki.apache.org/confluence/display/FLINK/FLIP-295%3A+Support+lazy+initialization+of+catalogs+and+persistence+of+catalog+configurations
> > >>>
> > >>> On Sat, Jun 3, 2023 at 5:54 PM Feng Jin <jinfeng1...@gmail.com>
> wrote:
> > >>>
> > >>>> Hi Hang and Jark
> > >>>>
> > >>>> Thank you very much for your reply.
> > >>>>
> > >>>> @Jark
> > >>>>> 1. Could you move the CatalogStore registration API to the "Public
> > >>>> Interface" section?
> > >>>>
> > >>>> Indeed, it is more reasonable.
> > >>>>
> > >>>>> 2. We should prefix "table." for the CatalogStore configuration.
> > >>>>
> > >>>> Sure, the names that you provided are indeed more logical and
> easier
> > >>> to
> > >>>> understand.
> > >>>>
> > >>>>> 3. About the open/close method in CatalogStoreFactory.
> > >>>>
> > >>>> I also agree with the proposed requirement scenario and design. I
> have
> > >>>> already made modifications to the interface.
> > >>>>
> > >>>> @Hang
> > >>>>
> > >>>>> 1. The `CatalogStore` need the `open`/`close` methods to init or
> > close
> > >>>> the resource.
> > >>>>
> > >>>> I have already added the missing method.
> > >>>>
> > >>>>> 2. The `getCatalog` is misspelled as `optionalDescriptor`.
> > >>>>
> > >>>> Sorry for the misspelling, I updated this part.
> > >>>>
> > >>>>> 3. Then the `CatalogStoreFactory` may need the `open`/`close`
> > methods
> > >>>> to init or close its resource
> > >>>>
> > >>>> This is indeed a scenario that needs to be considered, and I have
> > added
> > >>>> relevant methods accordingly.
> > >>>> Additionally, I have included some relevant description information
> in
> > >>> the
> > >>>> documentation to help others understand
> > >>>> why the open/close methods need to be added.
> > >>>>
> > >>>>
> > >>>> Best,
> > >>>> Feng
> > >>>>
> > >>>> On Sat, Jun 3, 2023 at 12:35 PM Jark Wu <imj...@gmail.com> wrote:
> > >>>>
> > >>>>> Hi Jing,
> > >>>>>
> > >>>>> Thank you for the update.
> > >>>>>
> > >>>>> 1. Could you move the CatalogStore registration API to the "Public
> > >>>>> Interface" section?
> > >>>>> "Proposed Changes" is more like a place to describe the
> > implementation
> > >>>>> details.
> > >>>>>
> > >>>>> 2. We should prefix "table." for the CatalogStore configuration.
> > >>> Besides,
> > >>>>> the config key
> > >>>>> name should be hierarchical[1]. Therefore, it may be better to use:
> > >>>>> "table.catalog-store.kind"
> > >>>>> "table.catalog-store.file.path"
> > >>>>>
> > >>>>> 3. I think Hang's suggestions make sense.
> > >>>>>
> > >>>>> Others look good to me.
> > >>>>>
> > >>>>> Best,
> > >>>>> Jark
> > >>>>>
> > >>>>> On Fri, 2 Jun 2023 at 17:28, Hang Ruan <ruanhang1...@gmail.com>
> > >>> wrote:
> > >>>>>
> > >>>>>> Hi, Feng.
> > >>>>>>
> > >>>>>> Thanks for the update.
> > >>>>>> The current design looks good to me. I have some minor comments.
> > >>>>>>
> > >>>>>> 1. The `CatalogStore` need the `open`/`close` methods to init or
> > >>> close
> > >>>>> the
> > >>>>>> resource. For example, when storing the information in MySQL, the
> > >>> store
> > >>>>>> needs to open and close the connections.
> > >>>>>>
> > >>>>>> 2. The `getCatalog` is misspelled as `optionalDescriptor`.
> > >>>>>>
> > >>>>>> 3. About the usage in the sql gateway.
> > >>>>>> Considering the usage in sql gateway, the sql gateway may create a
> > >>>>>> CatalogStore for each session.
> > >>>>>> If we are using the MySqlCatalogStore, there would be so many
> > >>>>> connections.
> > >>>>>> How can we reuse the connection among these sessions?
> > >>>>>> I think sql gateway need to maintain a connection pool in
> > >>>>>> the CatalogStoreFactory and each session get its own connection
> from
> > >>>> the
> > >>>>>> pool when it is created.
> > >>>>>> Then the `CatalogStoreFactory` may need the `open`/`close` methods
> > >>> to
> > >>>>> init
> > >>>>>> or close its resource.
> > >>>>>> Or is there a better way?
> > >>>>>>
> > >>>>>> Best,
> > >>>>>> Hang
> > >>>>>>
> > >>>>>> Feng Jin <jinfeng1...@gmail.com> 于2023年6月2日周五 14:45写道：
> > >>>>>>
> > >>>>>>> Thanks Jingsong.
> > >>>>>>>
> > >>>>>>>> Just naming, maybe `createCatalog` in TableEnv
> > >>>>>>>
> > >>>>>>> +1 For this, I have already updated FLIP.
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> Best,
> > >>>>>>> Feng
> > >>>>>>>
> > >>>>>>>
> > >>>>>>> On Fri, Jun 2, 2023 at 11:32 AM Jingsong Li <
> > >>> jingsongl...@gmail.com>
> > >>>>>>> wrote:
> > >>>>>>>
> > >>>>>>>> Thanks Feng,
> > >>>>>>>>
> > >>>>>>>> Just naming, maybe `createCatalog` in TableEnv, I can see many
> > >>>>>>>> functions are converted to createxxx from registerxxx.
> > >>>>>>>>
> > >>>>>>>> On Fri, Jun 2, 2023 at 11:04 AM Feng Jin <jinfeng1...@gmail.com
> > >>>>
> > >>>>>> wrote:
> > >>>>>>>>>
> > >>>>>>>>> Hi jark, thanks for your suggestion.
> > >>>>>>>>>
> > >>>>>>>>>> 1. How to register the CatalogStore for Table API? I think
> > >>> the
> > >>>>>>>>> CatalogStore should be immutable once TableEnv is created.
> > >>>>> Otherwise,
> > >>>>>>>> there
> > >>>>>>>>> might be some data inconsistencies when CatalogStore is
> > >>> changed.
> > >>>>>>>>>
> > >>>>>>>>> Yes, We should initialize the CatalogStore when creating the
> > >>>>>> TableEnv.
> > >>>>>>>>> Therefore, my current proposal is to add a method to configure
> > >>>> the
> > >>>>>>>>> CatalogStore in EnvironmentSettings.
> > >>>>>>>>>
> > >>>>>>>>> // Initialize a catalog Store
> > >>>>>>>>> CatalogStore catalogStore = new FileCatalogStore("");
> > >>>>>>>>>
> > >>>>>>>>> // set up the Table API
> > >>>>>>>>> final EnvironmentSettings settings =
> > >>>>>>>>>
> > >>> EnvironmentSettings.newInstance().inBatchMode()
> > >>>>>>>>> .withCatalogStore(catalogStore)
> > >>>>>>>>> .build();
> > >>>>>>>>>
> > >>>>>>>>> final TableEnvironment tableEnv =
> > >>>>>>>> TableEnvironment.create(settings);
> > >>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>>> 2. Why does the CatalogStoreFactory interface only have a
> > >>>> default
> > >>>>>>>> method,
> > >>>>>>>>> not an interface method?
> > >>>>>>>>>
> > >>>>>>>>> Sorry, While I did refer to the Catalog interface, I agree
> > >>> that
> > >>>> as
> > >>>>> a
> > >>>>>>> new
> > >>>>>>>>> interface, the CatalogStoreFactory should not have a default
> > >>>> method
> > >>>>>> but
> > >>>>>>>> an
> > >>>>>>>>> interface method. I have already modified the interface.
> > >>>>>>>>>
> > >>>>>>>>>> 3. Please mention the alternative API in Javadoc for the
> > >>>>>>>>> deprecated`registerCatalog`.
> > >>>>>>>>>> 4. In the "Compatibility" section, would be better to
> > >>> mention
> > >>>> the
> > >>>>>>>> changed
> > >>>>>>>>> behavior of CREATE CATALOG statement if FileCatalogStore (or
> > >>>> other
> > >>>>>>>>> persisted catalog store) is used.
> > >>>>>>>>>
> > >>>>>>>>> Thanks for the suggestion, I have updated the FLIP [1].
> > >>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>> [1].
> > >>>>>>>>>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>
> > >>>>
> > >>>
> >
> https://cwiki.apache.org/confluence/display/FLINK/FLIP-295%3A+Support+lazy+initialization+of+catalogs+and+persistence+of+catalog+configurations
> > >>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>> Best,
> > >>>>>>>>> Feng
> > >>>>>>>>>
> > >>>>>>>>> On Thu, Jun 1, 2023 at 9:22 PM Jark Wu <imj...@gmail.com>
> > >>> wrote:
> > >>>>>>>>>
> > >>>>>>>>>> Hi Feng,
> > >>>>>>>>>>
> > >>>>>>>>>> This is a useful FLIP. Thanks for starting this discussion.
> > >>>>>>>>>> The current design looks pretty good to me. I just have some
> > >>>>> minor
> > >>>>>>>>>> comments.
> > >>>>>>>>>>
> > >>>>>>>>>> 1. How to register the CatalogStore for Table API? I think
> > >>> the
> > >>>>>>>> CatalogStore
> > >>>>>>>>>> should be immutable once TableEnv is created. Otherwise,
> > >>> there
> > >>>>>> might
> > >>>>>>> be
> > >>>>>>>>>> some data inconsistencies when CatalogStore is changed.
> > >>>>>>>>>>
> > >>>>>>>>>> 2. Why does the CatalogStoreFactory interface only have a
> > >>>> default
> > >>>>>>>> method,
> > >>>>>>>>>> not an interface method?
> > >>>>>>>>>>
> > >>>>>>>>>> 3. Please mention the alternative API in Javadoc for the
> > >>>>> deprecated
> > >>>>>>>>>> `registerCatalog`.
> > >>>>>>>>>>
> > >>>>>>>>>> 4. In the "Compatibility" section, would be better to
> > >>> mention
> > >>>> the
> > >>>>>>>> changed
> > >>>>>>>>>> behavior of CREATE CATALOG statement if FileCatalogStore (or
> > >>>>> other
> > >>>>>>>>>> persisted catalog store) is used.
> > >>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Best,
> > >>>>>>>>>> Jark
> > >>>>>>>>>>
> > >>>>>>>>>> On Thu, 1 Jun 2023 at 11:26, Feng Jin <
> > >>> jinfeng1...@gmail.com>
> > >>>>>> wrote:
> > >>>>>>>>>>
> > >>>>>>>>>>> Hi ， thanks all for reviewing the flip.
> > >>>>>>>>>>>
> > >>>>>>>>>>> @Ron
> > >>>>>>>>>>>
> > >>>>>>>>>>>> Regarding the CatalogStoreFactory#createCatalogStore
> > >>>> method,
> > >>>>>> do
> > >>>>>>> we
> > >>>>>>>>>> need
> > >>>>>>>>>>> to provide a default implementation?
> > >>>>>>>>>>>
> > >>>>>>>>>>> Yes, we will provide a default
> > >>> InMemoryCatalogStoreFactory to
> > >>>>>>> create
> > >>>>>>>> an
> > >>>>>>>>>>> InMemoryCatalogStore.
> > >>>>>>>>>>>
> > >>>>>>>>>>>> If we get a Catalog from CatalogStore, after
> > >>> initializing
> > >>>>> it,
> > >>>>>>>> whether
> > >>>>>>>>>> we
> > >>>>>>>>>>> put it in Map<String, Catalog> catalogs again?
> > >>>>>>>>>>>
> > >>>>>>>>>>> Yes, in the current design, catalogs are stored as
> > >>> snapshots,
> > >>>>> and
> > >>>>>>>> once
> > >>>>>>>>>>> initialized, the Catalog will be placed in the Map<String,
> > >>>>>> Catalog>
> > >>>>>>>>>>> catalogs.
> > >>>>>>>>>>> Subsequently, the Map<String, Catalog> catalogs will be
> > >>> the
> > >>>>>> primary
> > >>>>>>>>>> source
> > >>>>>>>>>>> for obtaining the corresponding Catalog.
> > >>>>>>>>>>>
> > >>>>>>>>>>>> how about renaming them to `catalog.store.type` and
> > >>>>>>>>>>> `catalog.store.path`?
> > >>>>>>>>>>>
> > >>>>>>>>>>> I think it is okay. Adding "sql" at the beginning may
> > >>> seem a
> > >>>>> bit
> > >>>>>>>>>> strange. I
> > >>>>>>>>>>> will update the FLIP.
> > >>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> @Shammon
> > >>>>>>>>>>>
> > >>>>>>>>>>> Thank you for the review. I have made the necessary
> > >>>>> corrections.
> > >>>>>>>>>>> Regarding the modifications made to the Public Interface,
> > >>> I
> > >>>>> have
> > >>>>>>> also
> > >>>>>>>>>>> included the relevant changes to the `TableEnvironment`.
> > >>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> Best,
> > >>>>>>>>>>> Feng
> > >>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> On Wed, May 31, 2023 at 5:02 PM Shammon FY <
> > >>>> zjur...@gmail.com>
> > >>>>>>>> wrote:
> > >>>>>>>>>>>
> > >>>>>>>>>>>> Hi feng,
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> Thanks for updating, I have some minor comments
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> 1. The modification of `CatalogManager` should not be in
> > >>>>>> `Public
> > >>>>>>>>>>>> Interfaces`, it is not a public interface.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> 2. `@PublicEvolving` should be added for `CatalogStore`
> > >>> and
> > >>>>>>>>>>>> `CatalogStoreFactory`
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> 3. The code `Optional<Catalog> optionalDescriptor =
> > >>>>>>>>>>>> catalogStore.get(catalogName);` in the `CatalogManager`
> > >>>>> should
> > >>>>>> be
> > >>>>>>>>>>>> `Optional<CatalogDescriptor> optionalDescriptor =
> > >>>>>>>>>>>> catalogStore.get(catalogName);`
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> Best,
> > >>>>>>>>>>>> Shammon FY
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> On Wed, May 31, 2023 at 2:24 PM liu ron <
> > >>>> ron9....@gmail.com>
> > >>>>>>>> wrote:
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>> Hi, Feng
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Thanks for driving this FLIP, this proposal is very
> > >>>> useful
> > >>>>>> for
> > >>>>>>>>>> catalog
> > >>>>>>>>>>>>> management.
> > >>>>>>>>>>>>> I have some small questions:
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> 1. Regarding the
> > >>> CatalogStoreFactory#createCatalogStore
> > >>>>>> method,
> > >>>>>>>> do we
> > >>>>>>>>>>>> need
> > >>>>>>>>>>>>> to provide a default implementation?
> > >>>>>>>>>>>>> 2. If we get Catalog from CatalogStore, after
> > >>>> initializing
> > >>>>>> it,
> > >>>>>>>>>> whether
> > >>>>>>>>>>> we
> > >>>>>>>>>>>>> put it to Map<String, Catalog> catalogs again?
> > >>>>>>>>>>>>> 3. Regarding the options `sql.catalog.store.type` and
> > >>>>>>>>>>>>> `sql.catalog.store.file.path`, how about renaming
> > >>> them to
> > >>>>>>>>>>>>> `catalog.store.type` and `catalog.store.path`?
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>> Ron
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> Feng Jin <jinfeng1...@gmail.com> 于2023年5月29日周一
> > >>> 21:19写道：
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Hi yuxia
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> But from the code in Proposed Changes, once we
> > >>>>> register
> > >>>>>>> the
> > >>>>>>>>>>> Catalog,
> > >>>>>>>>>>>>> we
> > >>>>>>>>>>>>>> initialize it and open it. right?
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Yes, In order to avoid inconsistent semantics of the
> > >>>>>> original
> > >>>>>>>>>> CREATE
> > >>>>>>>>>>>>>> CATALOG DDL, Catalog will be directly initialized in
> > >>>>>>>>>> registerCatalog
> > >>>>>>>>>>> so
> > >>>>>>>>>>>>>> that parameter validation can be performed.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> In the current design, lazy initialization is mainly
> > >>>>>>> reflected
> > >>>>>>>> in
> > >>>>>>>>>>>>>> getCatalog. If CatalogStore has already saved some
> > >>>>> catalog
> > >>>>>>>>>>>>> configurations,
> > >>>>>>>>>>>>>> only initialization is required in getCatalog.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> On Mon, May 29, 2023 at 8:27 PM yuxia <
> > >>>>>>>> luoyu...@alumni.sjtu.edu.cn
> > >>>>>>>>>>>
> > >>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Hi, Feng.
> > >>>>>>>>>>>>>>> I'm trying to understanding the meaning of *lazy
> > >>>>>>>> initialization*.
> > >>>>>>>>>>> If
> > >>>>>>>>>>>>> i'm
> > >>>>>>>>>>>>>>> wrong, please correct me.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> IIUC, lazy initialization means only you need to
> > >>>> access
> > >>>>>> the
> > >>>>>>>>>>> catalog,
> > >>>>>>>>>>>>> then
> > >>>>>>>>>>>>>>> you initialize it. But from the code in Proposed
> > >>>>> Changes,
> > >>>>>>>> once we
> > >>>>>>>>>>>>>> register
> > >>>>>>>>>>>>>>> the Catalog,
> > >>>>>>>>>>>>>>> we initialize it and open it. right?
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>> Yuxia
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> ----- 原始邮件 -----
> > >>>>>>>>>>>>>>> 发件人: "Jing Ge" <j...@ververica.com.INVALID>
> > >>>>>>>>>>>>>>> 收件人: "dev" <dev@flink.apache.org>
> > >>>>>>>>>>>>>>> 发送时间: 星期一, 2023年 5 月 29日 下午 5:12:46
> > >>>>>>>>>>>>>>> 主题: Re: [DISCUSS] FLIP 295: Support persistence of
> > >>>>>> Catalog
> > >>>>>>>>>>>>> configuration
> > >>>>>>>>>>>>>>> and asynchronous registration
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Thanks for your effort! +1 for the proposal.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> One of the major changes is that current design
> > >>> will
> > >>>>>>> provide
> > >>>>>>>>>>>>>>> Map<String,Catalog> catalogs as a snapshot instead
> > >>>> of a
> > >>>>>>>> cache,
> > >>>>>>>>>>> which
> > >>>>>>>>>>>>>> means
> > >>>>>>>>>>>>>>> once it has been initialized, any changes done by
> > >>>> other
> > >>>>>>>> sessions
> > >>>>>>>>>>> will
> > >>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>> affect it. Point 6 described follow-up options for
> > >>>>>> further
> > >>>>>>>>>>>> improvement.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>> Jing
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> On Mon, May 29, 2023 at 5:31 AM Feng Jin <
> > >>>>>>>> jinfeng1...@gmail.com>
> > >>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Hi all, I would like to update you on the latest
> > >>>>>> progress
> > >>>>>>>> of
> > >>>>>>>>>> the
> > >>>>>>>>>>>>> FLIP.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Last week, Leonard Xu, HangRuan, Jing Ge,
> > >>> Shammon
> > >>>> FY,
> > >>>>>>>> ShengKai
> > >>>>>>>>>>> Fang
> > >>>>>>>>>>>>>> and I
> > >>>>>>>>>>>>>>>> had an offline discussion regarding the overall
> > >>>>>> solution
> > >>>>>>>> for
> > >>>>>>>>>>> Flink
> > >>>>>>>>>>>>>>>> CatalogStore. We have reached a consensus and I
> > >>>> have
> > >>>>>>>> updated
> > >>>>>>>>>> the
> > >>>>>>>>>>>>> final
> > >>>>>>>>>>>>>>>> solution in FLIP.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Next, let me briefly describe the entire design:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> 1.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Introduce CatalogDescriptor to store catalog
> > >>>>>>>> configuration
> > >>>>>>>>>>>> similar
> > >>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>> TableDescriptor.
> > >>>>>>>>>>>>>>>> 2.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> The two key functions of CatalogStore - void
> > >>>>>>>>>>> storeCatalog(String
> > >>>>>>>>>>>>>>>> catalogName, CatalogDescriptor) and
> > >>>>>> CatalogDescriptor
> > >>>>>>>>>>>>>>> getCatalog(String)
> > >>>>>>>>>>>>>>>> will both use CatalogDescriptor instead of
> > >>>> Catalog
> > >>>>>>>> instance.
> > >>>>>>>>>>>> This
> > >>>>>>>>>>>>>> way,
> > >>>>>>>>>>>>>>>> CatalogStore will only be responsible for
> > >>> saving
> > >>>>> and
> > >>>>>>>>>>> retrieving
> > >>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>> configurations without having to initialize
> > >>>>>> catalogs.
> > >>>>>>>>>>>>>>>> 3.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> The default registerCatalog(String
> > >>> catalogName,
> > >>>>>>> Catalog
> > >>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>> function in CatalogManager will be marked as
> > >>>>>>> deprecated.
> > >>>>>>>>>>>>>>>> 4.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> A new function registerCatalog(String
> > >>>> catalogName,
> > >>>>>>>>>>>>> CatalogDescriptor
> > >>>>>>>>>>>>>>>> catalog) will be added to serve as the
> > >>> default
> > >>>>>>>> registration
> > >>>>>>>>>>>>> function
> > >>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>> catalogs in CatalogManager.
> > >>>>>>>>>>>>>>>> 5.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Map<String,Catalog> catalogs in CataloManager
> > >>>> will
> > >>>>>>>> remain
> > >>>>>>>>>>>>> unchanged
> > >>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>> save initialized catalogs.This means that
> > >>>> deletion
> > >>>>>>>>>> operations
> > >>>>>>>>>>>> from
> > >>>>>>>>>>>>>> one
> > >>>>>>>>>>>>>>>> session won't synchronize with other
> > >>> sessions.
> > >>>>>>>>>>>>>>>> 6.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> To support multi-session synchronization
> > >>>> scenarios
> > >>>>>> for
> > >>>>>>>>>>> deletions
> > >>>>>>>>>>>>>> later
> > >>>>>>>>>>>>>>>> on we should make Map<String,Catalog>catalogs
> > >>>>>>>>>>> configurable.There
> > >>>>>>>>>>>>> may
> > >>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>> three possible situations:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> a.Default caching of all initialized catalogs
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> b.Introduction of LRU cache logic which can
> > >>>>>>>> automatically
> > >>>>>>>>>>> clear
> > >>>>>>>>>>>>>>>> long-unused catalogs.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> c.No caching of any instances; each call to
> > >>>>>> getCatalog
> > >>>>>>>>>>> creates a
> > >>>>>>>>>>>>> new
> > >>>>>>>>>>>>>>>> instance.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> This is the document for discussion:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>
> > >>>>
> > >>>
> >
> https://docs.google.com/document/d/1HRJNd4_id7i6cUxGnAybmYZIwl5g1SmZCOzGdUz-6lU/edit
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> This is the final proposal document:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>
> > >>>>
> > >>>
> >
> https://cwiki.apache.org/confluence/display/FLINK/FLIP-295%3A+Support+lazy+initialization+of+catalogs+and+persistence+of+catalog+configurations
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Thank you very much for your attention and
> > >>>>> suggestions
> > >>>>>> on
> > >>>>>>>> this
> > >>>>>>>>>>>>> FLIP. A
> > >>>>>>>>>>>>>>>> special thanks to Hang Ruan for his suggestions
> > >>> on
> > >>>>> the
> > >>>>>>>> entire
> > >>>>>>>>>>>> design
> > >>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>> organizing offline discussions.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> If you have any further suggestions or feedback
> > >>>> about
> > >>>>>>> this
> > >>>>>>>> FLIP
> > >>>>>>>>>>>>> please
> > >>>>>>>>>>>>>>> feel
> > >>>>>>>>>>>>>>>> free to share.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> On Sat, May 6, 2023 at 8:32 PM Jing Ge
> > >>>>>>>>>>> <j...@ververica.com.invalid
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> Thanks for improving the FLIP. It looks good
> > >>> to
> > >>>> me.
> > >>>>>> We
> > >>>>>>>> could
> > >>>>>>>>>>>> still
> > >>>>>>>>>>>>>>>>> reconsider in the future how to provide more
> > >>>> common
> > >>>>>>>> built-in
> > >>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>>>> functionality in CatalogManager so that not
> > >>> every
> > >>>>>>>>>> CatalogSotre
> > >>>>>>>>>>>>>>>>> implementation has to take care of it.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>> Jing
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> On Thu, May 4, 2023 at 1:47 PM Feng Jin <
> > >>>>>>>>>> jinfeng1...@gmail.com
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Hi Jing,
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Thanks for your reply.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> There might be more such issues. I would
> > >>>>> suggest
> > >>>>>>> you
> > >>>>>>>>>>>>> completely
> > >>>>>>>>>>>>>>> walk
> > >>>>>>>>>>>>>>>>>> through the FLIP again and fix those issues
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> I am very sorry for my carelessness and at
> > >>> the
> > >>>>> same
> > >>>>>>>> time, I
> > >>>>>>>>>>>>> greatly
> > >>>>>>>>>>>>>>>>>> appreciate your careful review. I have
> > >>>> thoroughly
> > >>>>>>>> checked
> > >>>>>>>>>> the
> > >>>>>>>>>>>>>> entire
> > >>>>>>>>>>>>>>>> FLIP
> > >>>>>>>>>>>>>>>>>> and made corrections to these issues.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> If I am not mistaken, with the current
> > >>> FLIP
> > >>>>>>> design,
> > >>>>>>>>>>>>>>> CatalogManager
> > >>>>>>>>>>>>>>>>>> could work without Optional CatalogStore
> > >>> being
> > >>>>>>>> configured.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Yes, in the original design, CatalogStore
> > >>> was
> > >>>> not
> > >>>>>>>> necessary
> > >>>>>>>>>>>>> because
> > >>>>>>>>>>>>>>>>>> CatalogManager used Map<String, Catalog>
> > >>>> catalogs
> > >>>>>> to
> > >>>>>>>> store
> > >>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>> instances.
> > >>>>>>>>>>>>>>>>>> However, this caused inconsistency issues.
> > >>>>>>> Therefore, I
> > >>>>>>>>>>>> modified
> > >>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>> part
> > >>>>>>>>>>>>>>>>>> of the design and removed Map<String,
> > >>> Catalog>
> > >>>>>>> catalogs
> > >>>>>>>>>> from
> > >>>>>>>>>>>>>>>>>> CatalogManager.
> > >>>>>>>>>>>>>>>>>> At the same time, InMemoryCatalog will
> > >>> serve
> > >>>> as
> > >>>>>> the
> > >>>>>>>>>> default
> > >>>>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>> to save catalogs in memory and replace the
> > >>>>>>>> functionality of
> > >>>>>>>>>>>>>>>>>> Map<String,Catalog>catalogs.
> > >>>>>>>>>>>>>>>>>> The previous plan that kept
> > >>>>>>>> Map<String,Catalog>catalogs has
> > >>>>>>>>>>>> been
> > >>>>>>>>>>>>>>> moved
> > >>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>> Rejected Alternatives.
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> On Sun, Apr 30, 2023 at 9:03 PM Jing Ge
> > >>>>>>>>>>>>> <j...@ververica.com.invalid
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> There are still many places contain
> > >>>>> inconsistent
> > >>>>>>>> content,
> > >>>>>>>>>>>> e.g.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> 1. "Asynchronous registration" is still
> > >>> used.
> > >>>>>>>>>>>>>>>>>>> 2. The java comment of the method
> > >>>>>>>> registerCatalog(String
> > >>>>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>>>> Catalog catalog) in CatalogManager does
> > >>> not
> > >>>>> tell
> > >>>>>>>> what the
> > >>>>>>>>>>>>> method
> > >>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>> doing.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> There might be more such issues. I would
> > >>>>> suggest
> > >>>>>>> you
> > >>>>>>>>>>>> completely
> > >>>>>>>>>>>>>>> walk
> > >>>>>>>>>>>>>>>>>>> through the FLIP again and fix those
> > >>> issues.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> About the inMemoryCatalogStore, do you
> > >>> mean
> > >>>>> that
> > >>>>>>> you
> > >>>>>>>> will
> > >>>>>>>>>>>> build
> > >>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>>>>>> functionality in the CatalogStore? This
> > >>> is a
> > >>>>> very
> > >>>>>>>>>> different
> > >>>>>>>>>>>>>> design
> > >>>>>>>>>>>>>>>>>> concept
> > >>>>>>>>>>>>>>>>>>> from what the current FLIP described. If
> > >>> I am
> > >>>>> not
> > >>>>>>>>>> mistaken,
> > >>>>>>>>>>>>> with
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>> current FLIP design, CatalogManager could
> > >>>> work
> > >>>>>>>> without
> > >>>>>>>>>>>> Optional
> > >>>>>>>>>>>>>>>>>>> CatalogStore being configured. That is the
> > >>>>> reason
> > >>>>>>>> why I
> > >>>>>>>>>>>>> mentioned
> > >>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>> last email that the example code wrt the
> > >>>>> Optional
> > >>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>> correct.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>>>> Jing
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> On Thu, Apr 27, 2023 at 3:55 PM Feng Jin <
> > >>>>>>>>>>>>> jinfeng1...@gmail.com>
> > >>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Hi Jing
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> There are still some NIT issues in the
> > >>>> FLIP
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Thank you very much for the careful
> > >>>> review. I
> > >>>>>>> have
> > >>>>>>>>>>> already
> > >>>>>>>>>>>>> made
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> relevant changes.
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Speaking of the conflict issues in
> > >>> the
> > >>>>>>>>>> multi-instance
> > >>>>>>>>>>>>>>>> scenarios, I
> > >>>>>>>>>>>>>>>>>> am
> > >>>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>> sure if this is the intended behaviour
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Currently, there are conflicts in
> > >>> multiple
> > >>>>>>>> scenarios
> > >>>>>>>>>> with
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> current
> > >>>>>>>>>>>>>>>>>>>> design. I am thinking whether we should
> > >>>>> remove
> > >>>>>>>>>>> 'Map<String,
> > >>>>>>>>>>>>>>>> Catalog>'
> > >>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>> make Cache the default behavior of
> > >>>>>>>>>> InMemoryCatalogStore.
> > >>>>>>>>>>>> This
> > >>>>>>>>>>>>>>> way,
> > >>>>>>>>>>>>>>>>>> users
> > >>>>>>>>>>>>>>>>>>>> can implement their own CatalogStore to
> > >>>>> achieve
> > >>>>>>>>>>>>> multi-instance
> > >>>>>>>>>>>>>>>>>>>> non-conflicting scenarios. What do you
> > >>>> think?
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> On Thu, Apr 27, 2023 at 9:03 PM Jing Ge
> > >>>>>>>>>>>>>>> <j...@ververica.com.invalid
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Thanks for working on the FLIP. There
> > >>> are
> > >>>>>> still
> > >>>>>>>> some
> > >>>>>>>>>>> NIT
> > >>>>>>>>>>>>>> issues
> > >>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> FLIP
> > >>>>>>>>>>>>>>>>>>>>> like:
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> 1. Optional<CatalogStore> catalogStore
> > >>>> has
> > >>>>>> been
> > >>>>>>>> used
> > >>>>>>>>>> as
> > >>>>>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>>>>> instead of Optional in the code
> > >>> example.
> > >>>> It
> > >>>>>>>> should be
> > >>>>>>>>>>>> fine
> > >>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>> use
> > >>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>> as
> > >>>>>>>>>>>>>>>>>>>>> pseudo code for now and update it
> > >>> after
> > >>>> you
> > >>>>>>>> submit
> > >>>>>>>>>> the
> > >>>>>>>>>>>> PR.
> > >>>>>>>>>>>>>>>>>>>>> 2. addCatalog(...) is still used
> > >>>> somewhere
> > >>>>> in
> > >>>>>>> the
> > >>>>>>>>>>>> rejected
> > >>>>>>>>>>>>>>>> section
> > >>>>>>>>>>>>>>>>>>> which
> > >>>>>>>>>>>>>>>>>>>>> should be persistContext(...) to keep
> > >>> it
> > >>>>>>>> consistent.
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Speaking of the conflict issues in the
> > >>>>>>>> multi-instance
> > >>>>>>>>>>>>>>> scenarios,
> > >>>>>>>>>>>>>>>> I
> > >>>>>>>>>>>>>>>>> am
> > >>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>> sure if this is the intended
> > >>> behaviour.
> > >>>> If
> > >>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>> catalogs
> > >>>>>>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>>>>> used as a cache, it should be invalid,
> > >>>> once
> > >>>>>> the
> > >>>>>>>>>> related
> > >>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>> has
> > >>>>>>>>>>>>>>>>>>> been
> > >>>>>>>>>>>>>>>>>>>>> removed from the CatalogStore by
> > >>> another
> > >>>>>>>> instance.
> > >>>>>>>>>> Did
> > >>>>>>>>>>> I
> > >>>>>>>>>>>>> miss
> > >>>>>>>>>>>>>>>>>>> something?
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>>>>>> Jing
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> On Thu, Apr 13, 2023 at 4:40 PM Feng
> > >>> Jin
> > >>>> <
> > >>>>>>>>>>>>>>> jinfeng1...@gmail.com>
> > >>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>> Hi Jing,Shammon
> > >>>>>>>>>>>>>>>>>>>>>> Thanks for your reply.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>> @Jing
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> How about persistCatalog()?
> > >>>>>>>>>>>>>>>>>>>>>> I think this is a good function
> > >>> name, I
> > >>>>>> have
> > >>>>>>>>>> updated
> > >>>>>>>>>>> it
> > >>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>> documentation.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> Some common cache features
> > >>> should
> > >>>> be
> > >>>>>>>>>> implemented
> > >>>>>>>>>>>>>>>>>>>>>> Thank you for the suggestion. If
> > >>>>>> alternative
> > >>>>>>> 1
> > >>>>>>>>>> turns
> > >>>>>>>>>>>> out
> > >>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>> more
> > >>>>>>>>>>>>>>>>>>>>>> appropriate later, I will improve
> > >>> this
> > >>>>> part
> > >>>>>>> of
> > >>>>>>>> the
> > >>>>>>>>>>>>> content.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> As the above discussion moves
> > >>>> forward,
> > >>>>>> the
> > >>>>>>>>>> option 2
> > >>>>>>>>>>>>>>> solution
> > >>>>>>>>>>>>>>>>>> looks
> > >>>>>>>>>>>>>>>>>>>> more
> > >>>>>>>>>>>>>>>>>>>>>> like a replacement of option 1
> > >>>>>>>>>>>>>>>>>>>>>> Yes, after discussing with Shammon
> > >>>>> offline,
> > >>>>>>> we
> > >>>>>>>>>> think
> > >>>>>>>>>>>> that
> > >>>>>>>>>>>>>>>>> solution
> > >>>>>>>>>>>>>>>>>> 2
> > >>>>>>>>>>>>>>>>>>>>> might
> > >>>>>>>>>>>>>>>>>>>>>> be more suitable and also avoid any
> > >>>>>>>> inconsistency
> > >>>>>>>>>>>> issues.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> There are some inconsistent
> > >>>>> descriptions
> > >>>>>> in
> > >>>>>>>> the
> > >>>>>>>>>>>>> content.
> > >>>>>>>>>>>>>>>> Would
> > >>>>>>>>>>>>>>>>>> you
> > >>>>>>>>>>>>>>>>>>>>> like
> > >>>>>>>>>>>>>>>>>>>>>> to clean them up?
> > >>>>>>>>>>>>>>>>>>>>>> I will do my best to improve the
> > >>>> document
> > >>>>>> and
> > >>>>>>>>>>>> appreciate
> > >>>>>>>>>>>>>> your
> > >>>>>>>>>>>>>>>>>>>>> suggestions.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>> @Shammon
> > >>>>>>>>>>>>>>>>>>>>>>> can you put the unselected option
> > >>> in
> > >>>>>>>> `Rejected
> > >>>>>>>>>>>>>>> Alternatives`
> > >>>>>>>>>>>>>>>>>>>>>> Sure, I have moved it to the
> > >>> `Rejected
> > >>>>>>>>>> Alternatives`.
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>> Best
> > >>>>>>>>>>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>> On Thu, Apr 13, 2023 at 8:52 AM
> > >>> Shammon
> > >>>>> FY
> > >>>>>> <
> > >>>>>>>>>>>>>>> zjur...@gmail.com>
> > >>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> Hi Feng
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> Thanks for your update.
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> I found there are two options in
> > >>>>>> `Proposed
> > >>>>>>>>>>> Changes`,
> > >>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>> you
> > >>>>>>>>>>>>>>>>> put
> > >>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> unselected option in `Rejected
> > >>>>>>>> Alternatives`? I
> > >>>>>>>>>>> think
> > >>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>> may
> > >>>>>>>>>>>>>>>>>> help
> > >>>>>>>>>>>>>>>>>>>> us
> > >>>>>>>>>>>>>>>>>>>>>>> better understand your proposal
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>>>>>>> Shammon FY
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> On Thu, Apr 13, 2023 at 4:49 AM
> > >>> Jing
> > >>>> Ge
> > >>>>>>>>>>>>>>>>>> <j...@ververica.com.invalid
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>> Thanks for raising this FLIP. I
> > >>> am
> > >>>>>> still
> > >>>>>>>>>> confused
> > >>>>>>>>>>>>> after
> > >>>>>>>>>>>>>>>>>>> completely
> > >>>>>>>>>>>>>>>>>>>>>>> reading
> > >>>>>>>>>>>>>>>>>>>>>>>> the thread with following
> > >>>> questions:
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>> 1. Naming confusion -
> > >>>>> registerCatalog()
> > >>>>>>> and
> > >>>>>>>>>>>>>> addCatalog()
> > >>>>>>>>>>>>>>>> have
> > >>>>>>>>>>>>>>>>>> no
> > >>>>>>>>>>>>>>>>>>>> big
> > >>>>>>>>>>>>>>>>>>>>>>>> difference based on their names.
> > >>>> One
> > >>>>> of
> > >>>>>>>> them is
> > >>>>>>>>>>>>>>> responsible
> > >>>>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>> data
> > >>>>>>>>>>>>>>>>>>>>>>>> persistence. How about
> > >>>>>> persistCatalog()?
> > >>>>>>>>>>>>>>>>>>>>>>>> 2. As you mentioned that
> > >>>> Map<String,
> > >>>>>>>> Catalog>
> > >>>>>>>>>>>>> catalogs
> > >>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>> used
> > >>>>>>>>>>>>>>>>>>> as a
> > >>>>>>>>>>>>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>>>>>>>>>>> and catalogStore is used for
> > >>> data
> > >>>>>>>> persistence.
> > >>>>>>>>>> I
> > >>>>>>>>>>>>> would
> > >>>>>>>>>>>>>>>>> suggest
> > >>>>>>>>>>>>>>>>>>>>>> describing
> > >>>>>>>>>>>>>>>>>>>>>>>> their purpose conceptually and
> > >>>>> clearly
> > >>>>>> in
> > >>>>>>>> the
> > >>>>>>>>>>> FLIP.
> > >>>>>>>>>>>>>> Some
> > >>>>>>>>>>>>>>>>> common
> > >>>>>>>>>>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>>>>>>>>>>> features should be implemented,
> > >>>> i.e.
> > >>>>>> data
> > >>>>>>>> in
> > >>>>>>>>>> the
> > >>>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> store
> > >>>>>>>>>>>>>>>>>>>>>>> should
> > >>>>>>>>>>>>>>>>>>>>>>>> be consistent. Same Catalog
> > >>>> instance
> > >>>>>>>> should be
> > >>>>>>>>>>>> found
> > >>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> store
> > >>>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>> the cache(either it has been
> > >>>>>> initialized
> > >>>>>>>> or it
> > >>>>>>>>>>> will
> > >>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>> lazy
> > >>>>>>>>>>>>>>>>>>>>>> initialized)
> > >>>>>>>>>>>>>>>>>>>>>>>> for the same catalog name. The
> > >>>>>>> consistency
> > >>>>>>>> will
> > >>>>>>>>>>> be
> > >>>>>>>>>>>>>> taken
> > >>>>>>>>>>>>>>>> care
> > >>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>> while
> > >>>>>>>>>>>>>>>>>>>>>>>> updating the catalog.
> > >>>>>>>>>>>>>>>>>>>>>>>> 3. As the above discussion moves
> > >>>>>> forward,
> > >>>>>>>> the
> > >>>>>>>>>>>> option
> > >>>>>>>>>>>>> 2
> > >>>>>>>>>>>>>>>>> solution
> > >>>>>>>>>>>>>>>>>>>> looks
> > >>>>>>>>>>>>>>>>>>>>>>> more
> > >>>>>>>>>>>>>>>>>>>>>>>> like a replacement of option 1,
> > >>>>>> because,
> > >>>>>>>> afaiu,
> > >>>>>>>>>>>>> issues
> > >>>>>>>>>>>>>>>>>> mentioned
> > >>>>>>>>>>>>>>>>>>>>>>>> previously with option 1 are not
> > >>>>> solved
> > >>>>>>>> yet. Do
> > >>>>>>>>>>> you
> > >>>>>>>>>>>>>> still
> > >>>>>>>>>>>>>>>>> want
> > >>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>> propose
> > >>>>>>>>>>>>>>>>>>>>>>>> both options and ask for
> > >>>> suggestions
> > >>>>>> for
> > >>>>>>>> both
> > >>>>>>>>>> of
> > >>>>>>>>>>>>> them?
> > >>>>>>>>>>>>>>>>>>>>>>>> 4. After you updated the FLIP,
> > >>>> there
> > >>>>>> are
> > >>>>>>>> some
> > >>>>>>>>>>>>>>> inconsistent
> > >>>>>>>>>>>>>>>>>>>>> descriptions
> > >>>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>> the content. Would you like to
> > >>>> clean
> > >>>>>>> them
> > >>>>>>>> up?
> > >>>>>>>>>>>>> Thanks!
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>>>>>>>>> Jing
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>> On Fri, Apr 7, 2023 at 9:24 AM
> > >>> Feng
> > >>>>>> Jin <
> > >>>>>>>>>>>>>>>>> jinfeng1...@gmail.com
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> hi Shammon
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> Thank you for your response,
> > >>> and
> > >>>> I
> > >>>>>>>> completely
> > >>>>>>>>>>>> agree
> > >>>>>>>>>>>>>>> with
> > >>>>>>>>>>>>>>>>> your
> > >>>>>>>>>>>>>>>>>>>> point
> > >>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>> view.
> > >>>>>>>>>>>>>>>>>>>>>>>>> Initially, I may have over
> > >>>>>> complicated
> > >>>>>>>> the
> > >>>>>>>>>>> whole
> > >>>>>>>>>>>>>> issue.
> > >>>>>>>>>>>>>>>>> First
> > >>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>>>> foremost,
> > >>>>>>>>>>>>>>>>>>>>>>>>> we need to consider the
> > >>>> persistence
> > >>>>>> of
> > >>>>>>>> the
> > >>>>>>>>>>>>> Catalog's
> > >>>>>>>>>>>>>>>>>>>> Configuration.
> > >>>>>>>>>>>>>>>>>>>>>>>>> If we only need to provide
> > >>>>>> persistence
> > >>>>>>>> for
> > >>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>> Configuration,
> > >>>>>>>>>>>>>>>>>>>>> we
> > >>>>>>>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>>>>>> add a toConfiguration method
> > >>> to
> > >>>> the
> > >>>>>>>> Catalog
> > >>>>>>>>>>>>>> interface.
> > >>>>>>>>>>>>>>>>>>>>>>>>> This method can convert a
> > >>> Catalog
> > >>>>>>>> instance
> > >>>>>>>>>> to a
> > >>>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>>> String>
> > >>>>>>>>>>>>>>>>>>>>>>>>> properties, and the default
> > >>>>>>>> implementation
> > >>>>>>>>>> will
> > >>>>>>>>>>>>> throw
> > >>>>>>>>>>>>>>> an
> > >>>>>>>>>>>>>>>>>>>> exception.
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> public interface Catalog {
> > >>>>>>>>>>>>>>>>>>>>>>>>> /**
> > >>>>>>>>>>>>>>>>>>>>>>>>> * Returns a map containing
> > >>> the
> > >>>>>>>> properties
> > >>>>>>>>>> of
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>>>> object.
> > >>>>>>>>>>>>>>>>>>>>>>>>> *
> > >>>>>>>>>>>>>>>>>>>>>>>>> * @return a map containing
> > >>> the
> > >>>>>>>> properties
> > >>>>>>>>>> of
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>>>> object
> > >>>>>>>>>>>>>>>>>>>>>>>>> * @throws
> > >>>>>>>> UnsupportedOperationException if
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> implementing
> > >>>>>>>>>>>>>>>>>>>>> class
> > >>>>>>>>>>>>>>>>>>>>>>> does
> > >>>>>>>>>>>>>>>>>>>>>>>>> not override
> > >>>>>>>>>>>>>>>>>>>>>>>>> * the default
> > >>> implementation
> > >>>> of
> > >>>>>> this
> > >>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>>>>> */
> > >>>>>>>>>>>>>>>>>>>>>>>>> default Map<String, String>
> > >>>>>>>> toProperties()
> > >>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>>>>>>> throw new
> > >>>>>>>>>>>> UnsupportedOperationException("Please
> > >>>>>>>>>>>>>>>>> implement
> > >>>>>>>>>>>>>>>>>>>>>>>> toProperties
> > >>>>>>>>>>>>>>>>>>>>>>>>> for this catalog");
> > >>>>>>>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> The specific process is as
> > >>>> follows:
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> 1. If the user has
> > >>> configured a
> > >>>>>>>>>> CatalogStore,
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>> toConfiguration()
> > >>>>>>>>>>>>>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>>>>> will be called when
> > >>> registering a
> > >>>>>>> Catalog
> > >>>>>>>>>>>> instance
> > >>>>>>>>>>>>>> with
> > >>>>>>>>>>>>>>>>>>>>>>>>> registerCatalog(String
> > >>>> catalogName,
> > >>>>>>>> Catalog
> > >>>>>>>>>>>>> catalog).
> > >>>>>>>>>>>>>>> The
> > >>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>>> instance
> > >>>>>>>>>>>>>>>>>>>>>>>>> will be converted to a
> > >>>> Map<String,
> > >>>>>>>> String>
> > >>>>>>>>>>>>> properties
> > >>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>> saved
> > >>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>> CatalogStore. If some Catalog
> > >>>>>> instances
> > >>>>>>>> do
> > >>>>>>>>>> not
> > >>>>>>>>>>>>>>> implement
> > >>>>>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>>>>>> method,
> > >>>>>>>>>>>>>>>>>>>>>>> an
> > >>>>>>>>>>>>>>>>>>>>>>>>> exception will be thrown.
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> 2. If the user does not use a
> > >>>>>>>> CatalogStore,
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> toConfiguration()
> > >>>>>>>>>>>>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>>>>> will not be called, ensuring
> > >>>>>>> consistency
> > >>>>>>>> with
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> original
> > >>>>>>>>>>>>>>>>>>>> process.
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> 3. Saving both the Map<String,
> > >>>>>> Catalog>
> > >>>>>>>>>>> catalogs
> > >>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>>>>>>> at
> > >>>>>>>>>>>>>>>>>>>>>>>>> the same time can also avoid
> > >>>>>> conflicts
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> For lazy initialization:
> > >>>>>>>>>>>>>>>>>>>>>>>>> we can start from the Catalog
> > >>>>> itself
> > >>>>>>> and
> > >>>>>>>>>>> provide
> > >>>>>>>>>>>> a
> > >>>>>>>>>>>>>>>>> dedicated
> > >>>>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>>>> implementation for lazy
> > >>> loading,
> > >>>>> such
> > >>>>>>> as
> > >>>>>>>>>>>>>>>>> ConfigurationCatalog
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> public class
> > >>> ConfigurationCatalog
> > >>>>>>>> implements
> > >>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>> ConfigurationCatalog(Map<String,
> > >>>>>>> String>
> > >>>>>>>>>>>>> properties)
> > >>>>>>>>>>>>>> {
> > >>>>>>>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>>>>>> }
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> I have added this design to
> > >>> the
> > >>>>> FLIP.
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>>>>>>>>> Feng
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, Apr 6, 2023 at
> > >>> 10:03 AM
> > >>>>>> Shammon
> > >>>>>>>> FY <
> > >>>>>>>>>>>>>>>>>> zjur...@gmail.com>
> > >>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> Hi Feng
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> Thanks for your answer.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> I have no questions about
> > >>> the
> > >>>>>>>> functionality
> > >>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>> `CatalogStore`,
> > >>>>>>>>>>>>>>>>>>>>> but
> > >>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>> different operations of
> > >>>> multiple
> > >>>>>>>>>>>>> `registerCatalog`
> > >>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>> `storeCatalog`
> > >>>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>>>> `CatalogManager`. The
> > >>>>>> implementation
> > >>>>>>> in
> > >>>>>>>>>> Trino
> > >>>>>>>>>>>> is
> > >>>>>>>>>>>>>> also
> > >>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>> same,
> > >>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>> `CatalogManager` in trino
> > >>> only
> > >>>>> has
> > >>>>>>> one
> > >>>>>>>>>>>>>>> `createCatalog`,
> > >>>>>>>>>>>>>>>>>> which
> > >>>>>>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>>>>> save
> > >>>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>> catalog to memory and
> > >>>>>> `CatalogStore`.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> I think we don't need to add
> > >>>>>> another
> > >>>>>>>>>>>>>>> `registerCatalog`
> > >>>>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>>> `addCatalog`
> > >>>>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>>> save a catalog in
> > >>> `Map<String,
> > >>>>>>> Catalog>
> > >>>>>>>>>>>> catalogs`
> > >>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>> `CatalogStore
> > >>>>>>>>>>>>>>>>>>>>>>>>>> catalogStore`. As you
> > >>>> mentioned
> > >>>>>>>> before,
> > >>>>>>>>>> the
> > >>>>>>>>>>>>>>>> `Map<String,
> > >>>>>>>>>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> catalogs` is a cache in
> > >>>>>>>> `CatalogManager`.
> > >>>>>>>>>> How
> > >>>>>>>>>>>>> about
> > >>>>>>>>>>>>>>>>> saving
> > >>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>>>> `Map<String, Catalog>
> > >>> catalogs`
> > >>>>> and
> > >>>>>>>>>>>> `CatalogStore
> > >>>>>>>>>>>>>>>>>>> catalogStore`
> > >>>>>>>>>>>>>>>>>>>>>>>> together
> > >>>>>>>>>>>>>>>>>>>>>>>>>> when it is registered or
> > >>> added
> > >>>> in
> > >>>>>>>>>>>>> `CatalogManager`?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>>>>>>>>>> Shammon FY
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>> On Tue, Apr 4, 2023 at
> > >>> 5:22 PM
> > >>>>> Feng
> > >>>>>>>> Jin <
> > >>>>>>>>>>>>>>>>>>> jinfeng1...@gmail.com
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> Thank you for your reply.
> > >>> I
> > >>>> am
> > >>>>>> very
> > >>>>>>>> sorry
> > >>>>>>>>>>> for
> > >>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>> misunderstanding
> > >>>>>>>>>>>>>>>>>>>>>>>>> caused
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> by my deviation from the
> > >>>>> original
> > >>>>>>>>>>> discussion.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> @Shammon
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> I found there is a
> > >>>>>> pre-discussion
> > >>>>>>>> [1]
> > >>>>>>>>>> for
> > >>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>> FLIP
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, there was indeed
> > >>> such a
> > >>>>>>>> discussion
> > >>>>>>>>>>>> before.
> > >>>>>>>>>>>>>>>>> However,
> > >>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>> designing
> > >>>>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> whole solution, I found
> > >>> that
> > >>>>> the
> > >>>>>>>> logic of
> > >>>>>>>>>>>>>>>>> CatalogManager
> > >>>>>>>>>>>>>>>>>>>> itself
> > >>>>>>>>>>>>>>>>>>>>>>>> doesn't
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> need to change much. *We
> > >>>> cannot
> > >>>>>>> only
> > >>>>>>>>>>> persist
> > >>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>> instances
> > >>>>>>>>>>>>>>>>>>>>>>>>>> themselves*,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> so exposing only
> > >>>>>>>> registerCatalog(String
> > >>>>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>>>>>>>>>>>> might
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> not be enough to save
> > >>>> Catalogs,
> > >>>>>>>> because
> > >>>>>>>>>> in
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>> end
> > >>>>>>>>>>>>>>> we
> > >>>>>>>>>>>>>>>>>> still
> > >>>>>>>>>>>>>>>>>>>>> need
> > >>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>> save
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> the configurations
> > >>>>> corresponding
> > >>>>>> to
> > >>>>>>>> the
> > >>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>> instances.
> > >>>>>>>>>>>>>>>>>>>>>>>> Therefore,
> > >>>>>>>>>>>>>>>>>>>>>>>>> I
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> decided to introduce the
> > >>>>>>> CatalogStore
> > >>>>>>>>>>>> interface
> > >>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>>> configuration
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> persistence. Regarding
> > >>> this
> > >>>>>> part, I
> > >>>>>>>> also
> > >>>>>>>>>>> took
> > >>>>>>>>>>>>>>>>> inspiration
> > >>>>>>>>>>>>>>>>>>>> from
> > >>>>>>>>>>>>>>>>>>>>>>>> Trino's
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> implementation[1].
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> @yuxia
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> 1: The mechanism of
> > >>>> handling
> > >>>>>>>> catalog
> > >>>>>>>>>> with
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>> same
> > >>>>>>>>>>>>>>>>> name
> > >>>>>>>>>>>>>>>>>>>>> looks a
> > >>>>>>>>>>>>>>>>>>>>>>>>> little
> > >>>>>>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> complex to me.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> Thank you for the
> > >>>> suggestion. I
> > >>>>>>> will
> > >>>>>>>>>>> provide
> > >>>>>>>>>>>> a
> > >>>>>>>>>>>>>>>> detailed
> > >>>>>>>>>>>>>>>>>>>>>> description
> > >>>>>>>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> code examples for this
> > >>> part,
> > >>>>> and
> > >>>>>>> add
> > >>>>>>>> it
> > >>>>>>>>>> to
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>> FLIP.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> 2: TBH, the method name
> > >>>>>>>> `addCatalog`
> > >>>>>>>>>>> still
> > >>>>>>>>>>>>>> looks
> > >>>>>>>>>>>>>>>>>> confused
> > >>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>> me.
> > >>>>>>>>>>>>>>>>>>>>>>>>> IIUC,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> this method is for storing
> > >>>>>> catalog
> > >>>>>>> to
> > >>>>>>>>>>>>>> CatalogStore,
> > >>>>>>>>>>>>>>>> how
> > >>>>>>>>>>>>>>>>>>> about
> > >>>>>>>>>>>>>>>>>>>>>>>> renaming
> > >>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> to `storeCatalog`? It's
> > >>> very
> > >>>>>>> personal
> > >>>>>>>>>>>> opinion,
> > >>>>>>>>>>>>>> you
> > >>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>> decide
> > >>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>> take
> > >>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> not by your self.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> StoreCatalog looks more
> > >>>>> intuitive
> > >>>>>>> to
> > >>>>>>>> me.
> > >>>>>>>>>> I
> > >>>>>>>>>>>>> don't
> > >>>>>>>>>>>>>>> see
> > >>>>>>>>>>>>>>>>> any
> > >>>>>>>>>>>>>>>>>>>>> problem
> > >>>>>>>>>>>>>>>>>>>>>>> with
> > >>>>>>>>>>>>>>>>>>>>>>>>> it.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> 3.For CREATE CATALOG
> > >>>>> statement,
> > >>>>>>>> which
> > >>>>>>>>>>>> method
> > >>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>> called?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> `registerCatalog` or
> > >>>>>> `addCatalog`?
> > >>>>>>>> I'm
> > >>>>>>>>>>>>> wondering
> > >>>>>>>>>>>>>>>>> whether
> > >>>>>>>>>>>>>>>>>>> user
> > >>>>>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>>>>> add a
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> catalog to store with SQL
> > >>>>>> stement.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> For CREATE CATALOG, my
> > >>>> original
> > >>>>>>>> design
> > >>>>>>>>>> was
> > >>>>>>>>>>> to
> > >>>>>>>>>>>>> add
> > >>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>> directly
> > >>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> CatalogStore, but this
> > >>> would
> > >>>>>>> disrupt
> > >>>>>>>> the
> > >>>>>>>>>>>>> existing
> > >>>>>>>>>>>>>>>>> logic.
> > >>>>>>>>>>>>>>>>>>>>>>> Therefore, I
> > >>>>>>>>>>>>>>>>>>>>>>>>>> think
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> we can do both: save the
> > >>>>>>>> configuration to
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>>>>> initialize
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> the Catalog instance at
> > >>> the
> > >>>>> same
> > >>>>>>> time
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> 3. Is it really
> > >>> neccessary
> > >>>> to
> > >>>>>>>> provide a
> > >>>>>>>>>>>>> default
> > >>>>>>>>>>>>>>>>>>>> implmentation
> > >>>>>>>>>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> interface
> > >>>>> `CatalogStoreFactory`?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> I think it is necessary,
> > >>>>>> otherwise
> > >>>>>>> we
> > >>>>>>>>>> would
> > >>>>>>>>>>>>> need
> > >>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>> introduce
> > >>>>>>>>>>>>>>>>>>>>> an
> > >>>>>>>>>>>>>>>>>>>>>>>>>> additional
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> Map to store the
> > >>>> configuration
> > >>>>>> for
> > >>>>>>>> lazy
> > >>>>>>>>>>>>> loading.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> 4: About asynchronous
> > >>>>>>> registration
> > >>>>>>>> for
> > >>>>>>>>>>>>> catalog.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think
> > >>>>>>> registerCatalog(String
> > >>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> made into an asynchronous
> > >>>>>> interface
> > >>>>>>>>>> because
> > >>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>>>> already
> > >>>>>>>>>>>>>>>>>>>>> an
> > >>>>>>>>>>>>>>>>>>>>>>>>>> instance.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> It looks more like lazy
> > >>>>>>>> initialization
> > >>>>>>>>>>> for
> > >>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>> than
> > >>>>>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> registration, right?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, my description was
> > >>>>>>>> inaccurate. It
> > >>>>>>>>>>>>> should
> > >>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>> lazy
> > >>>>>>>>>>>>>>>>>>>>>>> registration
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> instead of asynchronous
> > >>>>>>>> registration. I
> > >>>>>>>>>>> have
> > >>>>>>>>>>>>>>> already
> > >>>>>>>>>>>>>>>>>>> updated
> > >>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>> title
> > >>>>>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> the FLIP.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> [1].
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>
> > >>>>
> > >>>
> >
> https://github.com/trinodb/trino/blob/master/core/trino-main/src/main/java/io/trino/connector/CatalogStore.java
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tue, Apr 4, 2023 at
> > >>>> 4:27 PM
> > >>>>>>>> Shammon
> > >>>>>>>>>> FY <
> > >>>>>>>>>>>>>>>>>>> zjur...@gmail.com
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> Hi Feng
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> I think if there is a
> > >>>>>>>> `registerCatalog`
> > >>>>>>>>>>>>> method
> > >>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>> `CatalogManager`,
> > >>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> confuse users whether a
> > >>>>> method
> > >>>>>>>> named
> > >>>>>>>>>>>>>> `addCatalog`
> > >>>>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>>> `storeCatalog`
> > >>>>>>>>>>>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> added.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> And as you mentioned,
> > >>> the
> > >>>>>> memory
> > >>>>>>>>>> catalog
> > >>>>>>>>>>>> is a
> > >>>>>>>>>>>>>>>>> `cache`,
> > >>>>>>>>>>>>>>>>>> I
> > >>>>>>>>>>>>>>>>>>>>> think
> > >>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> concept
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> of `cache` should not be
> > >>>>>> exposed
> > >>>>>>> to
> > >>>>>>>>>>> users.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> I found there is a
> > >>>>>> pre-discussion
> > >>>>>>>> [1]
> > >>>>>>>>>> for
> > >>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>> FLIP.
> > >>>>>>>>>>>>>>>>>>> Please
> > >>>>>>>>>>>>>>>>>>>>>>> correct
> > >>>>>>>>>>>>>>>>>>>>>>>>> me
> > >>>>>>>>>>>>>>>>>>>>>>>>>> if
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> I'm wrong, IIUC, the
> > >>>>> conclusion
> > >>>>>>> of
> > >>>>>>>> that
> > >>>>>>>>>>>>>>> discussion
> > >>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>> use
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> `CatalogManager` as an
> > >>>>>> interface
> > >>>>>>>> and
> > >>>>>>>>>>>>> implement
> > >>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>>> different
> > >>>>>>>>>>>>>>>>>>>>>>>>> stores
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> such
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> as memory, file and
> > >>>> external
> > >>>>>>>> system.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> I think there is a gap
> > >>>>> between
> > >>>>>>> the
> > >>>>>>>>>>> current
> > >>>>>>>>>>>>> FLIP
> > >>>>>>>>>>>>>>>>> design
> > >>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>> that
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> conclusion.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> What about the proposal
> > >>> of
> > >>>>> the
> > >>>>>>>>>> discussion
> > >>>>>>>>>>>> in
> > >>>>>>>>>>>>>>> thread
> > >>>>>>>>>>>>>>>>>> [1] ?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> [1]
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>> https://lists.apache.org/thread/9bnjblgd9wvrl75lkm84oo654c4lqv70
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> Best,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> Shammon FY
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tue, Apr 4, 2023 at
> > >>>>> 3:41 PM
> > >>>>>>>> yuxia <
> > >>>>>>>>>>>>>>>>>>>>>>> luoyu...@alumni.sjtu.edu.cn>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks Feng for
> > >>> driving
> > >>>>> this
> > >>>>>>>> FLIP.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have few comments:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1: The mechanism of
> > >>>>> handling
> > >>>>>>>> catalog
> > >>>>>>>>>>> with
> > >>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> same
> > >>>>>>>>>>>>>>>>>> name
> > >>>>>>>>>>>>>>>>>>>>>> looks a
> > >>>>>>>>>>>>>>>>>>>>>>>>>> little
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> complex to me. I think
> > >>>>> it'll
> > >>>>>> be
> > >>>>>>>>>> better
> > >>>>>>>>>>> to
> > >>>>>>>>>>>>>>> explain
> > >>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> java
> > >>>>>>>>>>>>>>>>>>>>>>>>> doc
> > >>>>>>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> these methods and
> > >>> give a
> > >>>>>> brief
> > >>>>>>>>>> example
> > >>>>>>>>>>> in
> > >>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>> FLIP.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2: TBH, the method
> > >>> name
> > >>>>>>>> `addCatalog`
> > >>>>>>>>>>>> still
> > >>>>>>>>>>>>>>> looks
> > >>>>>>>>>>>>>>>>>>> confused
> > >>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>> me.
> > >>>>>>>>>>>>>>>>>>>>>>>>>> IIUC,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this method is for
> > >>>> storing
> > >>>>>>>> catalog to
> > >>>>>>>>>>>>>>>> CatalogStore,
> > >>>>>>>>>>>>>>>>>> how
> > >>>>>>>>>>>>>>>>>>>>> about
> > >>>>>>>>>>>>>>>>>>>>>>>>>> renaming
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to `storeCatalog`?
> > >>> It's
> > >>>>> very
> > >>>>>>>> personal
> > >>>>>>>>>>>>>> opinion,
> > >>>>>>>>>>>>>>>> you
> > >>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>> decide
> > >>>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>> take
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not by your self.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3: For CREATE CATALOG
> > >>>>>>> statement,
> > >>>>>>>>>> which
> > >>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>> called?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> `registerCatalog` or
> > >>>>>>>> `addCatalog`?
> > >>>>>>>>>> I'm
> > >>>>>>>>>>>>>>> wondering
> > >>>>>>>>>>>>>>>>>>> whether
> > >>>>>>>>>>>>>>>>>>>>> user
> > >>>>>>>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>>>>>>> add a
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalog to store with
> > >>> SQL
> > >>>>>>>> stement.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3: Is it really
> > >>>> neccessary
> > >>>>> to
> > >>>>>>>>>> provide a
> > >>>>>>>>>>>>>> default
> > >>>>>>>>>>>>>>>>>>>>> implmentation
> > >>>>>>>>>>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> interface
> > >>>>>>> `CatalogStoreFactory`?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4: About asynchronous
> > >>>>>>>> registration
> > >>>>>>>>>> for
> > >>>>>>>>>>>>>> catalog.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When creating a
> > >>> catalog
> > >>>>>> with
> > >>>>>>>> CREATE
> > >>>>>>>>>>>>>> CATALOG,
> > >>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> registration method is
> > >>>> used
> > >>>>>> by
> > >>>>>>>>>> default.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If asynchronous
> > >>>>> registration
> > >>>>>> is
> > >>>>>>>> the
> > >>>>>>>>>>>> default
> > >>>>>>>>>>>>>>>>> behavior,
> > >>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>> there
> > >>>>>>>>>>>>>>>>>>>>>>>> any
> > >>>>>>>>>>>>>>>>>>>>>>>>>> way
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that user can switch
> > >>> to
> > >>>>>>>> synchronous
> > >>>>>>>>>>>>>>> registration
> > >>>>>>>>>>>>>>>>> just
> > >>>>>>>>>>>>>>>>>>>> like
> > >>>>>>>>>>>>>>>>>>>>>>>> before?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will both method
> > >>>>> `addCatalog`
> > >>>>>>> and
> > >>>>>>>>>>>>>>>> `registerCatalog`
> > >>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> registration?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> IIUC, in asynchronous
> > >>>>>>>> registration,
> > >>>>>>>>>> it
> > >>>>>>>>>>>> may
> > >>>>>>>>>>>>>> well
> > >>>>>>>>>>>>>>>>> that
> > >>>>>>>>>>>>>>>>>>>> CREATE
> > >>>>>>>>>>>>>>>>>>>>>>>> CATALOG
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> executes successfully,
> > >>>> but
> > >>>>>> then
> > >>>>>>>> the
> > >>>>>>>>>>>>> following
> > >>>>>>>>>>>>>>>>> CREATE
> > >>>>>>>>>>>>>>>>>>>> TABLE
> > >>>>>>>>>>>>>>>>>>>>>>>>> statement
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> fail for the catalog
> > >>> fail
> > >>>>> to
> > >>>>>>>> open.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I think it's a break
> > >>>> change
> > >>>>>>> which
> > >>>>>>>>>>> should
> > >>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>> highlighted
> > >>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>>>>>>>>>> FLIP,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> may
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> be in compatibility
> > >>> part.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> BTW, by saying
> > >>>> asynchronous
> > >>>>>>>>>>>> registration, I
> > >>>>>>>>>>>>>>> would
> > >>>>>>>>>>>>>>>>>> like
> > >>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>> expect
> > >>>>>>>>>>>>>>>>>>>>>>>>>> there
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be an executor to
> > >>>> open
> > >>>>>> or
> > >>>>>>>>>> register
> > >>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>> background,
> > >>>>>>>>>>>>>>>>>>>>>>>>>> but
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> from
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> your previous
> > >>> comments,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> "the Catalog instance
> > >>>> will
> > >>>>> be
> > >>>>>>>>>>> initialized
> > >>>>>>>>>>>>> if
> > >>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>> has
> > >>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>> been
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> initialized
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> yet. If the
> > >>>> initialization
> > >>>>>>>> process
> > >>>>>>>>>>> fails,
> > >>>>>>>>>>>>>> these
> > >>>>>>>>>>>>>>>>>>>> statements
> > >>>>>>>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed
> > >>> successfully."
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> It looks more like
> > >>> lazy
> > >>>>>>>>>> initialization
> > >>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>> than
> > >>>>>>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> registration, right?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yuxia
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ----- 原始邮件 -----
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 发件人: "Feng Jin" <
> > >>>>>>>>>> jinfeng1...@gmail.com
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 收件人: "dev" <
> > >>>>>>> dev@flink.apache.org
> > >>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 发送时间: 星期一, 2023年 4 月
> > >>> 03日
> > >>>> 下午
> > >>>>>>>> 3:27:45
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 主题: Re: [DISCUSS] FLIP
> > >>>> 295:
> > >>>>>>>> Support
> > >>>>>>>>>>>>>> persistence
> > >>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> configuration
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> and asynchronous
> > >>>>> registration
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hi everyone, Thank you
> > >>>> all
> > >>>>>> for
> > >>>>>>>> your
> > >>>>>>>>>>>>> interest
> > >>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>>>>>> DISCUSS.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> @Shammon
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How to handle a
> > >>> catalog
> > >>>>>> with
> > >>>>>>>> the
> > >>>>>>>>>> same
> > >>>>>>>>>>>>> name
> > >>>>>>>>>>>>>>> that
> > >>>>>>>>>>>>>>>>>>> exists
> > >>>>>>>>>>>>>>>>>>>>> for
> > >>>>>>>>>>>>>>>>>>>>>>> both
> > >>>>>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> them?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I believe this is a
> > >>>> crucial
> > >>>>>>>> point.
> > >>>>>>>>>>> Based
> > >>>>>>>>>>>> on
> > >>>>>>>>>>>>>> my
> > >>>>>>>>>>>>>>>>>> current
> > >>>>>>>>>>>>>>>>>>>>>> personal
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> understanding, the
> > >>>>>> Map<String,
> > >>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>> catalogs
> > >>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>> serve
> > >>>>>>>>>>>>>>>>>>>>>> as
> > >>>>>>>>>>>>>>>>>>>>>>> a
> > >>>>>>>>>>>>>>>>>>>>>>>>>> cache
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> for instantiated
> > >>> catalogs
> > >>>>> and
> > >>>>>>>> have
> > >>>>>>>>>> the
> > >>>>>>>>>>>>>> highest
> > >>>>>>>>>>>>>>>>>>> priority.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> There are three
> > >>> methods
> > >>>>> that
> > >>>>>>> can
> > >>>>>>>>>> affect
> > >>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogs:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1.
> > >>> registerCatalog(String
> > >>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This method puts the
> > >>>>> catalog
> > >>>>>>>> instance
> > >>>>>>>>>>>> into
> > >>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogs.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2.
> > >>>> unregisterCatalog(String
> > >>>>>>>>>>> catalogName)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This method removes
> > >>> the
> > >>>>>> catalog
> > >>>>>>>>>>> instance
> > >>>>>>>>>>>>>>>>>> corresponding
> > >>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>> catalogName
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from the Map<String,
> > >>>>> Catalog>
> > >>>>>>>>>> catalogs.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3. getCatalog(String
> > >>>>>>> catalogName)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This method first
> > >>>> retrieves
> > >>>>>> the
> > >>>>>>>>>>>>> corresponding
> > >>>>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>>>>>> instance
> > >>>>>>>>>>>>>>>>>>>>>>>> from
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Map<String,
> > >>> Catalog>
> > >>>>>>>> catalogs. If
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>>>> does
> > >>>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>>>> exist,
> > >>>>>>>>>>>>>>>>>>>>>>>>> it
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> retrieves the
> > >>>> corresponding
> > >>>>>>>>>>> configuration
> > >>>>>>>>>>>>>> from
> > >>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> CatalogStore,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> initializes it, and
> > >>> puts
> > >>>>> the
> > >>>>>>>>>>> initialized
> > >>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>> instance
> > >>>>>>>>>>>>>>>>>>>>>> into
> > >>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Map<String, Catalog>
> > >>>>>> catalogs.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following two
> > >>> methods
> > >>>>>> only
> > >>>>>>>> modify
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> configuration
> > >>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> CatalogStore:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1. addCatalog(String
> > >>>>>>> catalogName,
> > >>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>> String>
> > >>>>>>>>>>>>>>>>>>>>>>> properties)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This method saves the
> > >>>>>>> properties
> > >>>>>>>> to
> > >>>>>>>>>> the
> > >>>>>>>>>>>>>>>>> catalogStore
> > >>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>> checks
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether there is a
> > >>>>>> catalogName
> > >>>>>>>> with
> > >>>>>>>>>> the
> > >>>>>>>>>>>>> same
> > >>>>>>>>>>>>>>>> name.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2.
> > >>> removeCatalog(String
> > >>>>>>>> catalogName)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This method removes
> > >>> the
> > >>>>>>> specified
> > >>>>>>>>>>>>>> configuration
> > >>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> specified
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogName in the
> > >>>>>>> catalogStore.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> The following are
> > >>>> possible
> > >>>>>>>> conflict
> > >>>>>>>>>>>>>> scenarios:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1. When the
> > >>> corresponding
> > >>>>>>>> catalogName
> > >>>>>>>>>>>>> already
> > >>>>>>>>>>>>>>>>> exists
> > >>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> CatalogStore but not
> > >>> in
> > >>>> the
> > >>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>> Catalog>,
> > >>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> registerCatalog(String
> > >>>>>>>> catalogName,
> > >>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>> can
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> succeed and be
> > >>> directly
> > >>>>> saved
> > >>>>>>> to
> > >>>>>>>> the
> > >>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>>>>>>> catalogs.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2. When the
> > >>> corresponding
> > >>>>>>>> catalogName
> > >>>>>>>>>>>>> already
> > >>>>>>>>>>>>>>>>> exists
> > >>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>> both
> > >>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> CatalogStore and the
> > >>>>>>> Map<String,
> > >>>>>>>>>>>> Catalog>,
> > >>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>> registerCatalog(String
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogName, Catalog
> > >>>>> catalog)
> > >>>>>>>> method
> > >>>>>>>>>>> will
> > >>>>>>>>>>>>>> fail.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3. When the
> > >>> corresponding
> > >>>>>>>> catalogName
> > >>>>>>>>>>>>> already
> > >>>>>>>>>>>>>>>>> exists
> > >>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Map<String, Catalog>,
> > >>> the
> > >>>>>>>>>>>> addCatalog(String
> > >>>>>>>>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> String> properties)
> > >>>> method
> > >>>>>> can
> > >>>>>>>>>> directly
> > >>>>>>>>>>>>> save
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> properties
> > >>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogStore, but the
> > >>>>>>>>>> getCatalog(String
> > >>>>>>>>>>>>>>>>> catalogName)
> > >>>>>>>>>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> use the new properties
> > >>>> for
> > >>>>>>>>>>> initialization
> > >>>>>>>>>>>>>>> because
> > >>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>> corresponding
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalog instance
> > >>> already
> > >>>>>> exists
> > >>>>>>>> in
> > >>>>>>>>>>>> catalogs
> > >>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>>> prioritized.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore, using the
> > >>>>>>>>>>>>> unregisterCatalog(String
> > >>>>>>>>>>>>>>>>>>>> catalogName)
> > >>>>>>>>>>>>>>>>>>>>>>> method
> > >>>>>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> remove the instance
> > >>>>>>>> corresponding to
> > >>>>>>>>>>> the
> > >>>>>>>>>>>>>>> original
> > >>>>>>>>>>>>>>>>>>>>> catalogName
> > >>>>>>>>>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessary.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I think it will
> > >>> confuse
> > >>>>>> users
> > >>>>>>>> that
> > >>>>>>>>>>>>>>>>>>>>> `registerCatalog(String
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogName,Catalog
> > >>>>> catalog)`
> > >>>>>>> in
> > >>>>>>>> the
> > >>>>>>>>>>>>>>> `Map<String,
> > >>>>>>>>>>>>>>>>>>>> Catalog>
> > >>>>>>>>>>>>>>>>>>>>>>>>> catalogs`
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>> `registerCatalog(String
> > >>>>>>>> catalogName,
> > >>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>> String>
> > >>>>>>>>>>>>>>>>>>>>>>>>> properties)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This could potentially
> > >>>> lead
> > >>>>>> to
> > >>>>>>>>>>>> confusion. I
> > >>>>>>>>>>>>>>>> suggest
> > >>>>>>>>>>>>>>>>>>>>> changing
> > >>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> method name, perhaps
> > >>> to
> > >>>>>>>>>>> addCatalog(String
> > >>>>>>>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>>>>>>>>> Map<String,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> String> properties),
> > >>> as
> > >>>>>>>> previously
> > >>>>>>>>>>>>> mentioned
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> @Hang
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> add
> > >>>>> `registerCatalog(String
> > >>>>>>>>>>>>>>> catalogName,Catalog
> > >>>>>>>>>>>>>>>>>>>> catalog,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> boolean lazyInit)`
> > >>> method
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since a catalog is
> > >>>> already
> > >>>>> an
> > >>>>>>>>>> instance,
> > >>>>>>>>>>>>>> adding
> > >>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>> "lazyInit"
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> parameter to the
> > >>>>>>>>>> registerCatalog(String
> > >>>>>>>>>>>>>>>>> catalogName,
> > >>>>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>>>> catalog)
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> method may not
> > >>>> necessarily
> > >>>>>>>> result in
> > >>>>>>>>>>> lazy
> > >>>>>>>>>>>>>>>>>>> initialization.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do we need to think
> > >>>> about
> > >>>>>>>>>> encryption
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I think encryption is
> > >>>>>>> necessary,
> > >>>>>>>> but
> > >>>>>>>>>>>>> perhaps
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> encryption
> > >>>>>>>>>>>>>>>>>>>>>>> logic
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> should be implemented
> > >>> in
> > >>>>> the
> > >>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>> when
> > >>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> data
> > >>>>>>>>>>>>>>>>>>>> is
> > >>>>>>>>>>>>>>>>>>>>>>>> actually
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> saved. For instance,
> > >>> the
> > >>>>>>>>>>> FileCatalogStore
> > >>>>>>>>>>>>>> could
> > >>>>>>>>>>>>>>>>>> encrypt
> > >>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>> data
> > >>>>>>>>>>>>>>>>>>>>>>>>> when
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is saved to a file,
> > >>>>> while
> > >>>>>>> the
> > >>>>>>>>>>>>>>>> MemoryCatalogStore
> > >>>>>>>>>>>>>>>>>>> does
> > >>>>>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>>>>>>> require
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> encryption.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do we really need
> > >>> the
> > >>>>>>>>>>>>>> `MemoryCatalogStore`?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> I think it is
> > >>> necessary
> > >>>> to
> > >>>>>>> have a
> > >>>>>>>>>>>>>>>>> MemoryCatalogStore
> > >>>>>>>>>>>>>>>>>> as
> > >>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>> default
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> implementation, which
> > >>>> saves
> > >>>>>>>> Catalog
> > >>>>>>>>>>>>>>>> configurations
> > >>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>> memory.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise, if we want
> > >>> to
> > >>>>>>>> implement
> > >>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>> loading
> > >>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>> Catalog,
> > >>>>>>>>>>>>>>>>>>>>>>>>>> we
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> would need to
> > >>> introduce
> > >>>>>>>> additional
> > >>>>>>>>>>> cache.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> @Xianxun
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What if asynchronous
> > >>>>>>>> registration
> > >>>>>>>>>>>> failed?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is also a
> > >>> critical
> > >>>>>>> concern.
> > >>>>>>>>>> When
> > >>>>>>>>>>>>>>> executing
> > >>>>>>>>>>>>>>>>> DDL,
> > >>>>>>>>>>>>>>>>>>>> DQL,
> > >>>>>>>>>>>>>>>>>>>>> or
> > >>>>>>>>>>>>>>>>>>>>>>> DML
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> statements that
> > >>>> reference a
> > >>>>>>>> specific
> > >>>>>>>>>>>>> Catalog,
> > >>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>> Catalog
> > >>>>>>>>>>>>>>>>>>>>>>>> instance
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be initialized
> > >>> if it
> > >>>>> has
> > >>>>>>> not
> > >>>>>>>>>> been
> > >>>>>>>>>>>>>>>> initialized
> > >>>>>>>>>>>>>>>>>> yet.
> > >>>>>>>>>>>>>>>>>>>> If
> > >>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> initialization process
> > >>>>> fails,
> > >>>>>>>> these
> > >>>>>>>>>>>>>> statements
> > >>>>>>>>>>>>>>>> will
> > >>>>>>>>>>>>>>>>>> not
> > >>>>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>> executed
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> successfully.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nt. The Map<String,
> > >>>>>> Catalog>
> > >>>>>>>>>> catalogs
> > >>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>>>>>>>>> catalogstore
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the CatalogManager all
> > >>>> have
> > >>>>>> the
> > >>>>>>>> same
> > >>>>>>>>>>>>> catalog
> > >>>>>>>>>>>>>>>> name,
> > >>>>>>>>>>>>>>>>>> but
> > >>>>>>>>>>>>>>>>>>>>>>>> correponding
> > >>>>>>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> different catalog
> > >>>>> instances.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This issue can be
> > >>>> resolved
> > >>>>> by
> > >>>>>>>>>> referring
> > >>>>>>>>>>>> to
> > >>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>> previous
> > >>>>>>>>>>>>>>>>>>>>>>>> responses.
> > >>>>>>>>>>>>>>>>>>>>>>>>>> The
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> key principle is that
> > >>> the
> > >>>>>>> Catalog
> > >>>>>>>>>> that
> > >>>>>>>>>>>> has
> > >>>>>>>>>>>>>> been
> > >>>>>>>>>>>>>>>>> most
> > >>>>>>>>>>>>>>>>>>>>> recently
> > >>>>>>>>>>>>>>>>>>>>>>>> used
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be given priority
> > >>>> for
> > >>>>>>>> subsequent
> > >>>>>>>>>>>> use.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, Apr 2, 2023 at
> > >>>>>> 10:58 PM
> > >>>>>>>>>> Xianxun
> > >>>>>>>>>>>> Ye
> > >>>>>>>>>>>>> <
> > >>>>>>>>>>>>>>>>>>>>>>>>> yesorno828...@gmail.com>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hi Feng,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thanks for driving
> > >>> this
> > >>>>>> Flip,
> > >>>>>>>> I do
> > >>>>>>>>>>>>> believe
> > >>>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>>> Flip
> > >>>>>>>>>>>>>>>>>>>>> could
> > >>>>>>>>>>>>>>>>>>>>>> be
> > >>>>>>>>>>>>>>>>>>>>>>>>>> helpful
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> for users. The firm I
> > >>>> work
> > >>>>>> for
> > >>>>>>>> also
> > >>>>>>>>>>>>> manages a
> > >>>>>>>>>>>>>>> lot
> > >>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>> catalogs,
> > >>>>>>>>>>>>>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> submission of tasks
> > >>>> becomes
> > >>>>>>> slow
> > >>>>>>>>>>> because
> > >>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>> loading a
> > >>>>>>>>>>>>>>>>>>>>> number
> > >>>>>>>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> catalogs.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> We obtain the
> > >>> catalogs in
> > >>>>> the
> > >>>>>>>> user's
> > >>>>>>>>>>>> Flink
> > >>>>>>>>>>>>>> SQL
> > >>>>>>>>>>>>>>>>>> through
> > >>>>>>>>>>>>>>>>>>>>>> regular
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> expression
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to avoid loading all
> > >>>>> catalogs
> > >>>>>>> to
> > >>>>>>>>>>> improve
> > >>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>> speed
> > >>>>>>>>>>>>>>>>> of
> > >>>>>>>>>>>>>>>>>>>> task
> > >>>>>>>>>>>>>>>>>>>>>>>>>> submission.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> After reading
> > >>> flip-295, I
> > >>>>>> have
> > >>>>>>>> some
> > >>>>>>>>>>>>>> questions:
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1. When creating a
> > >>>>> catalog
> > >>>>>>> with
> > >>>>>>>>>>> CREATE
> > >>>>>>>>>>>>>>> CATALOG,
> > >>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> registration method is
> > >>>> used
> > >>>>>> by
> > >>>>>>>>>> default.
> > >>>>>>>>>>>>> What
> > >>>>>>>>>>>>>> if
> > >>>>>>>>>>>>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>>>>>>>>>>> registration
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> failed? And how to
> > >>>>> implement
> > >>>>>>>>>>> asynchronous
> > >>>>>>>>>>>>>>>>>> registration?
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2. I also have the
> > >>> same
> > >>>>>>>> question
> > >>>>>>>>>> with
> > >>>>>>>>>>>>>>> Shammon’s
> > >>>>>>>>>>>>>>>>>> first
> > >>>>>>>>>>>>>>>>>>>>>>> comment.
> > >>>>>>>>>>>>>>>>>>>>>>>>> The
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Map<String, Catalog>
> > >>>>> catalogs
> > >>>>>>> and
> > >>>>>>>>>>>>>> CatalogStore
> > >>>>>>>>>>>>>>>>>>>> catalogstore
> > >>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> CatalogManager all
> > >>> have
> > >>>> the
> > >>>>>>> same
> > >>>>>>>>>>> catalog
> > >>>>>>>>>>>>>> name,
> > >>>>>>>>>>>>>>>> but
> > >>>>>>>>>>>>>>>>>>>>>> correponding
> > >>>>>>>>>>>>>>>>>>>>>>>> to
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> different catalog
> > >>>>> instances.
> > >>>>>>> For
> > >>>>>>>>>>> example:
> > >>>>>>>>>>>>>>>>> catalog1->
> > >>>>>>>>>>>>>>>>>>>>>>> jdbcCatalog
> > >>>>>>>>>>>>>>>>>>>>>>>> in
> > >>>>>>>>>>>>>>>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> catalogs, but
> > >>> catalog1 ->
> > >>>>>>>> hiveCatalog
> > >>>>>>>>>>> in
> > >>>>>>>>>>>>> the
> > >>>>>>>>>>>>>>>>>>>> catalogstore.
> > >>>>>>>>>>>>>>>>>>>>>>> Would
> > >>>>>>>>>>>>>>>>>>>>>>>>> this
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> case
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> happen? Maybe we
> > >>> should
> > >>>>>> define
> > >>>>>>>>>>> `catalogs`
> > >>>>>>>>>>>>> and
> > >>>>>>>>>>>>>>>>>>>>> `catalogstore`
> > >>>>>>>>>>>>>>>>>>>>>>> more
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>> clearly.
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Best regards,
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Xianxun
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2023年3月31日
> > >>> 11:13，Hang
> > >>>>>> Ruan
> > >>>>>>> <
> > >>>>>>>>>>>>>>>>>> ruanhang1...@gmail.com
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>> 写道：
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MemoryCatalogStore
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>
> > >>>>>>>
> > >>>>>>
> > >>>>>
> > >>>>
> > >>>
> > >>
> >
> >
>
