Pavel, good point. Thanks. I've added async methods. On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <ptupit...@apache.org> wrote:
> Andrey, > > What about corresponding async APIs, do we add them now or later? > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov < > andrey.mashen...@gmail.com> > wrote: > > > Hi Igniters. > > > > I've created a PR for Table access API [1]. > > This is an initial version. So, any suggestions\objections are welcomed. > > Please, do not hesitate to write your comments and\or examples to the PR. > > > > Ignite-api module contains API classes, e.g. TableView classes as > > projections for a table for different purposes. > > Ignite-table contains dummy implementation and Example class explained > how > > it is supposed to be used. > > > > > > Also, I'm still waiting for any feedback for Schema configuration public > > API PR [2]. > > > > [1] https://github.com/apache/ignite-3/pull/33 > > [2] https://github.com/apache/ignite-3/pull/2 > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov < > > andrey.mashen...@gmail.com> > > wrote: > > > > > > > > I've updated a PR regarding your feedback [1]. > > > > > > [1] https://github.com/apache/ignite-3/pull/2 > > > > > > On Mon, Jan 11, 2021 at 10:58 AM Alexey Goncharuk < > > > alexey.goncha...@gmail.com> wrote: > > > > > >> Folks, > > >> > > >> I updated the IEP to contain the missing pieces; actually, most of the > > >> questions here were covered by the text. Please let me know if there > is > > >> something still missing or unclear. > > >> > > >> чт, 31 дек. 2020 г. в 12:48, Alexey Goncharuk < > > alexey.goncha...@gmail.com > > >> >: > > >> > > >> > Mikhail and Igniters, > > >> > > > >> > Thanks for your comments. The questions are reasonable, though I > think > > >> all > > >> > concerns are addressed by the IEP as Val mentioned. I will update > the > > >> > document according to your questions in the following week or so, so > > we > > >> can > > >> > have a constructive discussion further. > > >> > > > >> > ср, 30 дек. 2020 г. в 11:45, Michael Cherkasov < > > >> > michael.cherka...@gmail.com>: > > >> > > > >> >> Hi Val, Andrey, > > >> >> > > >> >> thank you for clarifying. > > >> >> > > >> >> I still have a few comments. > > >> >> > > >> >> 1. one table == one schema. KV vs SQL: > > >> >> Looks like all agreed that KV is just a special case of a regular > > table > > >> >> with (blob,blob) schema. > > >> >> I worry about the case when the user starts from KV case and later > > will > > >> >> try > > >> >> to expand it and try to leverage SQL for the existing KV table it > > >> won't be > > >> >> able to do so and will require to reload data. which isn't > convenient > > >> and > > >> >> sometimes not even possible. Is it possible to extract a new field > > from > > >> >> (blob, blob) schema and apply index on it? > > >> >> > > >> >> 2. Could you please also list all ways of schema definition in the > > >> IEP? It > > >> >> significant change and I bet the main point of this IEP, everyone > > hates > > >> >> QueryEntities, they are difficult to manage and in general, it's > very > > >> >> confusing to have a data model(schemas) and node/cluster > > configuration > > >> in > > >> >> one place. > > >> >> > > >> >> So there will be SchemaBuilder and SQL to define schemas, but > Andrey > > >> also > > >> >> mentioned annotations. > > >> >> > > >> >> I personally against configuration via annotations, while it's > > >> convenient > > >> >> for development, it difficult to manage because different classes > can > > >> be > > >> >> deployed on different clients/servers nodes and it can lead to > > >> >> unpredictable results. > > >> >> > > >> >> 3. IEP doesn't mention field type changes, only drop/add fields. > > Field > > >> >> type > > >> >> changes are extremely painful right now(if even possible), so it > > would > > >> be > > >> >> nice if some scenarios would be supported(like int8->int16, or > > >> >> int8->String). > > >> >> > > >> >> 4. got it, I thought IEP will have more details about the > > >> implementation. > > >> >> I've seen Andrey even sent benchmark results for a new > serialization, > > >> will > > >> >> ping him about this. > > >> >> > > >> >> 5. Thanks for the clarification. I had a wrong understanding of > > strick > > >> >> mode. > > >> >> > > >> >> > > >> >> вт, 29 дек. 2020 г. в 19:32, Valentin Kulichenko < > > >> >> valentin.kuliche...@gmail.com>: > > >> >> > > >> >> > Hi Mike, > > >> >> > > > >> >> > Thanks for providing your feedback. Please see my comments below. > > >> >> > > > >> >> > I would also encourage you to go through the IEP-54 [1] - it has > a > > >> lot > > >> >> of > > >> >> > detail on the topic. > > >> >> > > > >> >> > [1] > > >> >> > > > >> >> > > > >> >> > > >> > > > https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach > > >> >> > > > >> >> > -Val > > >> >> > > > >> >> > On Mon, Dec 28, 2020 at 11:22 PM Michael Cherkasov < > > >> >> > michael.cherka...@gmail.com> wrote: > > >> >> > > > >> >> > > Hi all, > > >> >> > > > > >> >> > > I reviewed the mail thread and proposal page and I still don't > > >> fully > > >> >> > > understand what is going to be changed, I would really > appreciate > > >> it > > >> >> if > > >> >> > you > > >> >> > > will answer a few questions: > > >> >> > > > > >> >> > > 1. Are you going to leave only one schema per cache? if so, > will > > be > > >> >> there > > >> >> > > an option to have a table with arbitrary objects(pure KV case)? > > >> >> > > > > >> >> > > > >> >> > My opinion is that KV case should be natively supported. I think > > this > > >> >> still > > >> >> > needs to be thought over, my current view on this is that we > should > > >> have > > >> >> > separate APIs for KV and more generic storages. KV storage can be > > >> >> > implemented as a "table" with two BLOB fields where we will store > > >> >> > serialized key-value pairs. That would imply deserialization on > > read, > > >> >> but I > > >> >> > believe this is OK for KV use cases. I'm happy to hear other > ideas > > >> >> though > > >> >> > :) > > >> >> > > > >> >> > > > >> >> > > 2. What options will Apache Ignite 3.0 have to define schema? > > >> >> > SchemaBuilder > > >> >> > > and SQL only? Is there an option to put the schema definition > to > > >> the > > >> >> > > configuration?(I really don't like this, I would prefer to have > > >> >> > > separate scripts to create schemas) > > >> >> > > > > >> >> > > > >> >> > There will be no such thing as a static configuration in the > first > > >> >> place. > > >> >> > Tables and schemas are created in runtime. Even if there is a > file > > >> >> provided > > >> >> > on node startup, this file is only applied in the scope of the > > >> 'start' > > >> >> > operation. All configurations will be stored in a meta storage > > >> >> available to > > >> >> > all nodes, as opposed to individual files. > > >> >> > > > >> >> > > > >> >> > > 3. Is there a way to change field type? if yes, can it be done > in > > >> >> > runtime? > > >> >> > > > > >> >> > > > >> >> > Absolutely! IEP-54 has a whole section about schema evolution. > > >> >> > > > >> >> > > > >> >> > > 4. Looks like BinaryMarshaller is going to be re-worked too, is > > >> there > > >> >> any > > >> >> > > IEP for this? > > >> >> > > > > >> >> > > > >> >> > BinaryMarshaller as a tool for arbitrary object serialization > will > > be > > >> >> gone, > > >> >> > but we will reuse a lot of its concept to implement an internal > > tuple > > >> >> > serialization mechanism. IEP-54 has the description of the > proposed > > >> data > > >> >> > format. > > >> >> > > > >> >> > > > >> >> > > 5. I don't like automatic schema evaluation when a new field is > > >> added > > >> >> > > automatically on record put, so is there a way to prohibit this > > >> >> behavior? > > >> >> > > I think all schema changes should be done only explicitly > except > > >> >> initial > > >> >> > > schema creation. > > >> >> > > > > >> >> > > > >> >> > The way I see it is that we should have two modes: schema-first > and > > >> >> > schema-last. Schema-first means exactly what you've described - > > >> schemas > > >> >> are > > >> >> > defined and updated explicitly by the user. In the schema-last > > mode, > > >> >> > the user does not deal with schemas, as they are inferred from > the > > >> data > > >> >> > inserted into tables. We should definitely not mix these modes - > it > > >> has > > >> >> to > > >> >> > be one or another. And it probably makes sense to discuss which > > mode > > >> >> should > > >> >> > be the default one. > > >> >> > > > >> >> > > > >> >> > > > > >> >> > > Thanks, > > >> >> > > Mike. > > >> >> > > > > >> >> > > пн, 21 дек. 2020 г. в 06:40, Andrey Mashenkov < > > >> >> > andrey.mashen...@gmail.com > > >> >> > > >: > > >> >> > > > > >> >> > > > Hi, Igniters. > > >> >> > > > > > >> >> > > > We all know that the current QueryEntity API is not > convenient > > >> and > > >> >> > needs > > >> >> > > to > > >> >> > > > be reworked. > > >> >> > > > So, I'm glad to share PR [1] with schema configuration public > > API > > >> >> for > > >> >> > > > Ignite 3.0. > > >> >> > > > > > >> >> > > > New schema configuration uses Builder pattern, which looks > more > > >> >> > > comfortable > > >> >> > > > to use. > > >> >> > > > > > >> >> > > > In the PR you will find a 'schema' package with the API > itself, > > >> and > > >> >> a > > >> >> > > draft > > >> >> > > > implementation in 'internal' sub-package, > > >> >> > > > and a test that demonstrates how the API could be used. > > >> >> > > > > > >> >> > > > Please note: > > >> >> > > > > > >> >> > > > * Entrypoint is 'SchemaBuilders' class with static factory > > >> methods. > > >> >> > > > * The implementation is decoupled and can be easily extracted > > to > > >> >> > separate > > >> >> > > > module if we decide to do so. > > >> >> > > > * Some columns types (e.g. Date/Time) are missed, they will > be > > >> added > > >> >> > > lately > > >> >> > > > in separate tickes. > > >> >> > > > * Index configuration extends marker interface that makes > > >> possible > > >> >> to > > >> >> > > > implement indexes of new types in plugins. > > >> >> > > > Hopfully, we could add a persistent geo-indices support in > > >> future. > > >> >> > > > * Supposedly, current table schema can be changed via > > >> builder-like > > >> >> > > > structure as it is done if JOOQ project. See > > >> >> 'TableModificationBuilder' > > >> >> > > for > > >> >> > > > details. > > >> >> > > > I'm not sure 'SchemaTable' should have 'toBuilder()' > converter > > >> for > > >> >> that > > >> >> > > > purpose as it is a Schema Manager responsibility to create > > >> mutator > > >> >> > > objects > > >> >> > > > from the current schema, > > >> >> > > > but implementing the Schema manager is out of scope and will > be > > >> >> > designed > > >> >> > > > within the next task. > > >> >> > > > * Interfaces implementations are out of scope. I did not > intend > > >> to > > >> >> > merge > > >> >> > > > them right now, but for test/demostration purposes. > > >> >> > > > > > >> >> > > > It is NOT the final version and some may be changed before > the > > >> first > > >> >> > > > release of course. > > >> >> > > > For now, we have to agree if we can proceed with this > approach > > or > > >> >> some > > >> >> > > > issues should be resolved at first. > > >> >> > > > > > >> >> > > > Any thoughts or objections? > > >> >> > > > Are interfaces good enough to be merged within the current > > >> ticket? > > >> >> > > > > > >> >> > > > > > >> >> > > > https://issues.apache.org/jira/browse/IGNITE-13748 > > >> >> > > > > > >> >> > > > On Thu, Nov 26, 2020 at 2:33 PM Юрий < > > >> jury.gerzhedow...@gmail.com> > > >> >> > > wrote: > > >> >> > > > > > >> >> > > > > A little bit my thoughts about unsigned types: > > >> >> > > > > > > >> >> > > > > 1. Seems we may support unsign types > > >> >> > > > > 2. It requires adding new types to the internal > > representation, > > >> >> > > protocol, > > >> >> > > > > e.t.c. > > >> >> > > > > 3. internal representation should be the same as we keep > sign > > >> >> types. > > >> >> > So > > >> >> > > > it > > >> >> > > > > will not requires more memory > > >> >> > > > > 4. User should be aware of specifics such types for > platforms > > >> >> which > > >> >> > not > > >> >> > > > > support unsigned types. For example, a user could derive -6 > > >> value > > >> >> in > > >> >> > > Java > > >> >> > > > > for 250 unsigned byte value (from bits perspective will be > > >> >> right). I > > >> >> > > > think > > >> >> > > > > We shouldn't use more wide type for such cases, especially > it > > >> >> will be > > >> >> > > bad > > >> >> > > > > for unsigned long when we require returns BigInteger type. > > >> >> > > > > 5. Possible it requires some suffix/preffix for new types > > like > > >> a > > >> >> > > '250u' - > > >> >> > > > > it means that 250 is an unsigned value type. > > >> >> > > > > 6. It requires a little bit more expensive comparison logic > > for > > >> >> > indexes > > >> >> > > > > 7. It requires new comparison logic for expressions. I > think > > it > > >> >> not > > >> >> > > > > possible for the current H2 engine and probably possible > for > > >> the > > >> >> new > > >> >> > > > > Calcite engine. Need clarification from anybody who > involved > > in > > >> >> this > > >> >> > > part > > >> >> > > > > > > >> >> > > > > WDYT? > > >> >> > > > > > > >> >> > > > > вт, 24 нояб. 2020 г. в 18:36, Alexey Goncharuk < > > >> >> > > > alexey.goncha...@gmail.com > > >> >> > > > > >: > > >> >> > > > > > > >> >> > > > > > Actually, we can support comparisons in 3.0: once we the > > >> actual > > >> >> > type > > >> >> > > > > > information, we can make proper runtime adjustments and > > >> >> conversions > > >> >> > > to > > >> >> > > > > > treat those values as unsigned - it will be just a bit > more > > >> >> > > expensive. > > >> >> > > > > > > > >> >> > > > > > вт, 24 нояб. 2020 г. в 18:32, Pavel Tupitsyn < > > >> >> ptupit...@apache.org > > >> >> > >: > > >> >> > > > > > > > >> >> > > > > > > > SQL range queries it will break > > >> >> > > > > > > > WHERE x > y may return wrong results > > >> >> > > > > > > > > >> >> > > > > > > Yes, range queries, inequality comparisons and so on > are > > >> >> broken > > >> >> > > > > > > for unsigned data types, I think I mentioned this > > somewhere > > >> >> > above. > > >> >> > > > > > > > > >> >> > > > > > > Again, in my opinion, we can document that SQL is not > > >> >> supported > > >> >> > on > > >> >> > > > > those > > >> >> > > > > > > types, > > >> >> > > > > > > end of story. > > >> >> > > > > > > > > >> >> > > > > > > On Tue, Nov 24, 2020 at 6:25 PM Alexey Goncharuk < > > >> >> > > > > > > alexey.goncha...@gmail.com> > > >> >> > > > > > > wrote: > > >> >> > > > > > > > > >> >> > > > > > > > Folks, I think this is a reasonable request. I > thought > > >> about > > >> >> > this > > >> >> > > > > when > > >> >> > > > > > I > > >> >> > > > > > > > was drafting the IEP, but hesitated to add these > types > > >> right > > >> >> > > away. > > >> >> > > > > > > > > > >> >> > > > > > > > > That is how it works in Ignite since the beginning > > with > > >> >> .NET > > >> >> > > and > > >> >> > > > > C++ > > >> >> > > > > > :) > > >> >> > > > > > > > I have some doubts that it actually works as > expected, > > it > > >> >> needs > > >> >> > > > some > > >> >> > > > > > > > checking (will be glad if my concerns are false): > > >> >> > > > > > > > > > >> >> > > > > > > > - It's true that equality check works properly, > but > > >> for > > >> >> SQL > > >> >> > > > range > > >> >> > > > > > > > queries it will break unless some special care is > > >> taken > > >> >> on > > >> >> > > Java > > >> >> > > > > > side: > > >> >> > > > > > > > for > > >> >> > > > > > > > u8 255 > 10, but in Java (byte)255 will be > converted > > >> to > > >> >> -1, > > >> >> > > > which > > >> >> > > > > > will > > >> >> > > > > > > > break the comparison. Since we don't have unsigned > > >> types > > >> >> > now, > > >> >> > > I > > >> >> > > > > > doubt > > >> >> > > > > > > it > > >> >> > > > > > > > works. > > >> >> > > > > > > > - There is an obvious cross-platform data loss > when > > >> >> > > "intuitive" > > >> >> > > > > type > > >> >> > > > > > > > mapping is used by a user (u8 corresponds to byte > > >> type in > > >> >> > > .NET, > > >> >> > > > > but > > >> >> > > > > > to > > >> >> > > > > > > > avoid values loss, a user will have to use short > > type > > >> in > > >> >> > Java, > > >> >> > > > and > > >> >> > > > > > > > Ignite > > >> >> > > > > > > > will also need to take care of the range check > > during > > >> >> > > > > > serialization). > > >> >> > > > > > > I > > >> >> > > > > > > > think we can even allow to try to deserialize a > > value > > >> >> into > > >> >> > > > > arbitrary > > >> >> > > > > > > > type, > > >> >> > > > > > > > but throw an exception if the range is out of > > bounds. > > >> >> > > > > > > > > > >> >> > > > > > > > Overall, I agree with Andrey's comments. > > >> >> > > > > > > > Andrey, do you mind updating the IEP once all the > > details > > >> >> are > > >> >> > > > settled > > >> >> > > > > > > here? > > >> >> > > > > > > > > > >> >> > > > > > > > вт, 24 нояб. 2020 г. в 18:19, Andrey Mashenkov < > > >> >> > > > > > > andrey.mashen...@gmail.com > > >> >> > > > > > > > >: > > >> >> > > > > > > > > > >> >> > > > > > > > > Pavel, > > >> >> > > > > > > > > > > >> >> > > > > > > > > I believe uLong values beyond 2^63 can't be treated > > >> >> correctly > > >> >> > > for > > >> >> > > > > now > > >> >> > > > > > > > > (WHERE x > y may return wrong results) > > >> >> > > > > > > > > > > >> >> > > > > > > > > I think we could make "true" support for unsigned > > >> types, > > >> >> but > > >> >> > > they > > >> >> > > > > > will > > >> >> > > > > > > > have > > >> >> > > > > > > > > limitations on the Java side. > > >> >> > > > > > > > > Thus, the one will not be able to map uint64 to > Java > > >> long > > >> >> > > > > primitive, > > >> >> > > > > > > but > > >> >> > > > > > > > to > > >> >> > > > > > > > > BigInteger only. > > >> >> > > > > > > > > As for indices, we could read uint64 to Java long, > > but > > >> >> treat > > >> >> > > > > negative > > >> >> > > > > > > > > values in a different way to preserve correct > > ordering. > > >> >> > > > > > > > > > > >> >> > > > > > > > > These limitations will affect only mixed > environments > > >> when > > >> >> > .Net > > >> >> > > > and > > >> >> > > > > > > Java > > >> >> > > > > > > > > used to access the data. > > >> >> > > > > > > > > Will this solution address your issues? > > >> >> > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > On Tue, Nov 24, 2020 at 5:45 PM Pavel Tupitsyn < > > >> >> > > > > ptupit...@apache.org > > >> >> > > > > > > > > >> >> > > > > > > > > wrote: > > >> >> > > > > > > > > > > >> >> > > > > > > > > > > That way is impossible. > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > That is how it works in Ignite since the > beginning > > >> with > > >> >> > .NET > > >> >> > > > and > > >> >> > > > > > C++ > > >> >> > > > > > > :) > > >> >> > > > > > > > > > You can use unsigned primitives as cache keys and > > >> >> values, > > >> >> > as > > >> >> > > > > fields > > >> >> > > > > > > and > > >> >> > > > > > > > > > properties, > > >> >> > > > > > > > > > and in SQL queries (even in WHERE x=y clauses) - > it > > >> >> works > > >> >> > > > > > > transparently > > >> >> > > > > > > > > for > > >> >> > > > > > > > > > the users. > > >> >> > > > > > > > > > Java side knows nothing and treats those values > as > > >> >> > > > corresponding > > >> >> > > > > > > signed > > >> >> > > > > > > > > > types. > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > However, this abstraction leaks in some cases > only > > >> >> because > > >> >> > > > there > > >> >> > > > > > are > > >> >> > > > > > > no > > >> >> > > > > > > > > > corresponding type ids. > > >> >> > > > > > > > > > That is why I'm proposing a very simple change to > > the > > >> >> > > protocol > > >> >> > > > - > > >> >> > > > > > add > > >> >> > > > > > > > type > > >> >> > > > > > > > > > ids, but handle them the same way as signed > > >> >> counterparts. > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > On Tue, Nov 24, 2020 at 5:00 PM Andrey Mashenkov > < > > >> >> > > > > > > > > > andrey.mashen...@gmail.com> > > >> >> > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > Pavel, > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > - Treat uLong as long in Java (bitwise > > >> representation > > >> >> is > > >> >> > > the > > >> >> > > > > > same) > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > That way is impossible. > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > Assume, you have a .NET class with a uByte > field > > >> and > > >> >> map > > >> >> > it > > >> >> > > > to > > >> >> > > > > > > > 'uint8' > > >> >> > > > > > > > > > > column. > > >> >> > > > > > > > > > > Then you set the field value to "250" and put > the > > >> >> object > > >> >> > > > into a > > >> >> > > > > > > > table, > > >> >> > > > > > > > > > > field value perfectly fits to a single byte > > 'int8' > > >> >> > column. > > >> >> > > > > > > > > > > But in Java you can't deserialize it to > directly > > >> the > > >> >> Java > > >> >> > > > > object > > >> >> > > > > > > > field > > >> >> > > > > > > > > of > > >> >> > > > > > > > > > > 'byte' type, so we should map uint8 type to > Java > > >> >> 'short' > > >> >> > > type > > >> >> > > > > > > > > > > because the one expected to see "250" as a > value > > >> which > > >> >> > > > doesn't > > >> >> > > > > > fit > > >> >> > > > > > > to > > >> >> > > > > > > > > the > > >> >> > > > > > > > > > > signed type. > > >> >> > > > > > > > > > > For uLong the one will need a BigInteger field > in > > >> >> Java. > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > SQL index either can't treat column value as > Java > > >> >> 'byte' > > >> >> > as > > >> >> > > > is, > > >> >> > > > > > > > because > > >> >> > > > > > > > > > > after reading you will get a negative value, so > > it > > >> >> should > > >> >> > > be > > >> >> > > > > cast > > >> >> > > > > > > to > > >> >> > > > > > > > > > short > > >> >> > > > > > > > > > > at first. (converted to BigInteger for uint64) > > >> >> > > > > > > > > > > So, index on signed type will require a > different > > >> >> > > comparator. > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > That way doesn't look simpler. > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > On Tue, Nov 24, 2020 at 4:23 PM Pavel Tupitsyn > < > > >> >> > > > > > > ptupit...@apache.org > > >> >> > > > > > > > > > > >> >> > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > Andrey, > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > I don't think range narrowing is a good idea. > > >> >> > > > > > > > > > > > Do you see any problems with the simple > > approach > > >> I > > >> >> > > > described? > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > On Tue, Nov 24, 2020 at 4:01 PM Andrey > > Mashenkov > > >> < > > >> >> > > > > > > > > > > > andrey.mashen...@gmail.com> > > >> >> > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > Pavel, > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > If you are ok with narrowing range for > > unsigned > > >> >> types > > >> >> > > > then > > >> >> > > > > we > > >> >> > > > > > > > could > > >> >> > > > > > > > > > > add a > > >> >> > > > > > > > > > > > > constraint for unsigned types on schema > level > > >> >> (like > > >> >> > > > > > nullability > > >> >> > > > > > > > > flag) > > >> >> > > > > > > > > > > > > and treat them as signed types in storage. > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > We are going with a separate storage > > >> type-system > > >> >> and > > >> >> > > > binary > > >> >> > > > > > > > > protocol > > >> >> > > > > > > > > > > > > type-system, however most of type will > match > > 1 > > >> to > > >> >> 1 > > >> >> > > with > > >> >> > > > > > > storage > > >> >> > > > > > > > > > > (native) > > >> >> > > > > > > > > > > > > type. > > >> >> > > > > > > > > > > > > On .Net side you will either have a > separate > > >> type > > >> >> id > > >> >> > or > > >> >> > > > > treat > > >> >> > > > > > > > > > > serialized > > >> >> > > > > > > > > > > > > value regarding a schema (signed or > unsigned > > >> >> flag). > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > Igor, > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > I'm not sure users can ever foresee the > > >> >> consequences > > >> >> > of > > >> >> > > > > using > > >> >> > > > > > > > > > unsigned > > >> >> > > > > > > > > > > > > types. > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > Assume, a user used to unsigned types > > perfectly > > >> >> works > > >> >> > > > with > > >> >> > > > > > some > > >> >> > > > > > > > > > > database, > > >> >> > > > > > > > > > > > > then he turns into Ignite successor > > confession > > >> >> with > > >> >> > our > > >> >> > > > > > > "native" > > >> >> > > > > > > > > > > > > unsigned-types support. > > >> >> > > > > > > > > > > > > But later, he finds that he can use the > power > > >> of > > >> >> > Ignite > > >> >> > > > > > Compute > > >> >> > > > > > > > on > > >> >> > > > > > > > > > Java > > >> >> > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > some tasks or a new app. > > >> >> > > > > > > > > > > > > Finally, the user will either fail to use > his > > >> >> > unsigned > > >> >> > > > data > > >> >> > > > > > on > > >> >> > > > > > > > Java > > >> >> > > > > > > > > > due > > >> >> > > > > > > > > > > > or > > >> >> > > > > > > > > > > > > face performance issues due to natural Java > > >> type > > >> >> > system > > >> >> > > > > > > > limitations > > >> >> > > > > > > > > > > e.g. > > >> >> > > > > > > > > > > > > conversion uLong to BigInteger. > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > I believe that natively supported types > with > > >> >> possible > > >> >> > > > value > > >> >> > > > > > > > ranges > > >> >> > > > > > > > > > and > > >> >> > > > > > > > > > > > > limitations should be known. > > >> >> > > > > > > > > > > > > So, the only question is what trade-off we > > >> found > > >> >> > > > > acceptable: > > >> >> > > > > > > > > > narrowing > > >> >> > > > > > > > > > > > > unsigned type range or use types of wider > > >> range on > > >> >> > > > systems > > >> >> > > > > > like > > >> >> > > > > > > > > Java. > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > On Tue, Nov 24, 2020 at 3:25 PM Igor > Sapego < > > >> >> > > > > > > isap...@apache.org> > > >> >> > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > Actually, I think it is not so hard to > > >> implement > > >> >> > > > > comparison > > >> >> > > > > > > of > > >> >> > > > > > > > > > > unsigned > > >> >> > > > > > > > > > > > > > numbers in > > >> >> > > > > > > > > > > > > > SQL even in Java, so it does not seem to > > be a > > >> >> big > > >> >> > > issue > > >> >> > > > > > from > > >> >> > > > > > > my > > >> >> > > > > > > > > > > > > > perspective. > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > Now to the usage of unsigned types from > > Java > > >> - I > > >> >> > > think, > > >> >> > > > > if > > >> >> > > > > > a > > >> >> > > > > > > > user > > >> >> > > > > > > > > > > uses > > >> >> > > > > > > > > > > > > > unsigned type > > >> >> > > > > > > > > > > > > > in a schema and is going to interact with > > it > > >> >> from > > >> >> > > Java > > >> >> > > > he > > >> >> > > > > > > knows > > >> >> > > > > > > > > > what > > >> >> > > > > > > > > > > he > > >> >> > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > doing. > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > Mostly they are for use from platforms > > where > > >> >> they > > >> >> > > have > > >> >> > > > > > native > > >> >> > > > > > > > > > support > > >> >> > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > widely > > >> >> > > > > > > > > > > > > > used, like in C++ or .NET, where users > > >> currently > > >> >> > have > > >> >> > > > to > > >> >> > > > > > > make a > > >> >> > > > > > > > > > > manual > > >> >> > > > > > > > > > > > > type > > >> >> > > > > > > > > > > > > > casting > > >> >> > > > > > > > > > > > > > or even just stop using unsigned types > when > > >> they > > >> >> > use > > >> >> > > > > > Ignite. > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > Best Regards, > > >> >> > > > > > > > > > > > > > Igor > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 3:06 PM Pavel > > >> Tupitsyn < > > >> >> > > > > > > > > > ptupit...@apache.org > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > Andrey, > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > I think it is much simpler: > > >> >> > > > > > > > > > > > > > > - Add protocol support for those types > > >> >> > (basically, > > >> >> > > > just > > >> >> > > > > > add > > >> >> > > > > > > > > more > > >> >> > > > > > > > > > > type > > >> >> > > > > > > > > > > > > > ids) > > >> >> > > > > > > > > > > > > > > - Treat uLong as long in Java (bitwise > > >> >> > > representation > > >> >> > > > > is > > >> >> > > > > > > the > > >> >> > > > > > > > > > same) > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > ANSI SQL does not have unsigned > integers, > > >> so > > >> >> we > > >> >> > can > > >> >> > > > > > simply > > >> >> > > > > > > > say > > >> >> > > > > > > > > > that > > >> >> > > > > > > > > > > > > > > unsigned value relative comparison is > not > > >> >> > supported > > >> >> > > > in > > >> >> > > > > > SQL > > >> >> > > > > > > > > > > (equality > > >> >> > > > > > > > > > > > > will > > >> >> > > > > > > > > > > > > > > work). > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 2:40 PM Andrey > > >> >> Mashenkov > > >> >> > < > > >> >> > > > > > > > > > > > > > > andrey.mashen...@gmail.com> > > >> >> > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > Thanks, Pavel and Igor. > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > I like your ideas to have i8 or int8 > > >> >> instead of > > >> >> > > > > > Integer. > > >> >> > > > > > > > > > > > > > > > But the naming doesn't address the > > issue. > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > I agree internal types should be > > portable > > >> >> > across > > >> >> > > > > > > different > > >> >> > > > > > > > > > > systems > > >> >> > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > without unsigned type support. > > >> >> > > > > > > > > > > > > > > > The only issue here is that unsigned > > >> types > > >> >> > cover > > >> >> > > > > > > different > > >> >> > > > > > > > > > > ranges. > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > Let's assume we want to introduce a > > >> uLong. > > >> >> > > > > > > > > > > > > > > > It doesn't look like a big deal to > add > > >> uLong > > >> >> > type > > >> >> > > > > > support > > >> >> > > > > > > > at > > >> >> > > > > > > > > > > > storage > > >> >> > > > > > > > > > > > > > > level > > >> >> > > > > > > > > > > > > > > > and fit it to a 8 bytes and then use > it > > >> in > > >> >> e.g. > > >> >> > > > .Net > > >> >> > > > > > > only. > > >> >> > > > > > > > > > > > > > > > But how we could support it in e.g. > > Java? > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > Let's keep in mind Long range is > about > > >> >> (2^-63 > > >> >> > .. > > >> >> > > > > 2^63) > > >> >> > > > > > > and > > >> >> > > > > > > > > > uLong > > >> >> > > > > > > > > > > > > range > > >> >> > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > (0 .. 2^64) > > >> >> > > > > > > > > > > > > > > > 1. The first option is to restrict > > range > > >> to > > >> >> (0 > > >> >> > .. > > >> >> > > > > > 2^63). > > >> >> > > > > > > > This > > >> >> > > > > > > > > > > > allows > > >> >> > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > use > > >> >> > > > > > > > > > > > > > > > signed in e.g. > > >> >> > > > > > > > > > > > > > > > Java with no conversion, but doesn't > > look > > >> >> like > > >> >> > a > > >> >> > > > > 'real' > > >> >> > > > > > > > > > unsigned > > >> >> > > > > > > > > > > > > uLong > > >> >> > > > > > > > > > > > > > > > support. Things go worse when the > user > > >> will > > >> >> use > > >> >> > > > > uByte, > > >> >> > > > > > as > > >> >> > > > > > > > > > > > limitation > > >> >> > > > > > > > > > > > > > can > > >> >> > > > > > > > > > > > > > > > make uByte totally unusable. > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > 2. The second one is to map unsigned > > >> types > > >> >> to a > > >> >> > > > type > > >> >> > > > > of > > >> >> > > > > > > > wider > > >> >> > > > > > > > > > > type > > >> >> > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > add > > >> >> > > > > > > > > > > > > > > > a constraint for negative values. > E.g. > > >> >> uLong to > > >> >> > > > > > > BigInteger. > > >> >> > > > > > > > > > > > > > > > So, we can't use primitive Java type > > for > > >> >> Long > > >> >> > > here. > > >> >> > > > > > > > However, > > >> >> > > > > > > > > it > > >> >> > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > still > > >> >> > > > > > > > > > > > > > > > possible to store uLong in 8 bytes, > but > > >> >> have a > > >> >> > > > > special > > >> >> > > > > > > > > > comparator > > >> >> > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > > > > unsigned types to avoid unwanted > > >> >> > deserialization. > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > WDYT? > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 2:04 PM Pavel > > >> >> Tupitsyn > > >> >> > < > > >> >> > > > > > > > > > > > ptupit...@apache.org > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > Agree, let's get rid of "long, > short, > > >> >> byte" > > >> >> > in > > >> >> > > > the > > >> >> > > > > > > > protocol > > >> >> > > > > > > > > > > > > > definition. > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > We can use Rust style, which is > > concise > > >> >> and > > >> >> > > > > > > unambiguous: > > >> >> > > > > > > > > > > > > > > > > i8, u8, i16, u16, etc > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 1:58 PM > Igor > > >> >> Sapego < > > >> >> > > > > > > > > > > isap...@apache.org> > > >> >> > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > Pavel, > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > I totally support that. Also, if > we > > >> are > > >> >> > > aiming > > >> >> > > > > for > > >> >> > > > > > > > > > > > > > > > > > stronger platform-independance, > > >> >> > > > > > > > > > > > > > > > > > in our schemas we may want to > > support > > >> >> > > > > bit-notation > > >> >> > > > > > > > > (int32, > > >> >> > > > > > > > > > > > > uint64)? > > >> >> > > > > > > > > > > > > > > For > > >> >> > > > > > > > > > > > > > > > > > example > > >> >> > > > > > > > > > > > > > > > > > "long" can mean a different type > on > > >> >> > different > > >> >> > > > > > > platforms > > >> >> > > > > > > > > and > > >> >> > > > > > > > > > > > it's > > >> >> > > > > > > > > > > > > > easy > > >> >> > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > confuse > > >> >> > > > > > > > > > > > > > > > > > them (happens often when using > ODBC > > >> for > > >> >> > > > example). > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > Best Regards, > > >> >> > > > > > > > > > > > > > > > > > Igor > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 1:34 PM > > Pavel > > >> >> > > Tupitsyn > > >> >> > > > < > > >> >> > > > > > > > > > > > > > ptupit...@apache.org > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > Igniters, > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > I think we should support > > unsigned > > >> >> data > > >> >> > > > types: > > >> >> > > > > > > > > > > > > > > > > > > uByte, uShort, uInt, uLong > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > Java does not have them, but > many > > >> >> other > > >> >> > > > > languages > > >> >> > > > > > > do, > > >> >> > > > > > > > > > > > > > > > > > > and with the growing number of > > thin > > >> >> > clients > > >> >> > > > > this > > >> >> > > > > > is > > >> >> > > > > > > > > > > > important. > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > For example, in current > > Ignite.NET > > >> >> > > > > implementation > > >> >> > > > > > > we > > >> >> > > > > > > > > > store > > >> >> > > > > > > > > > > > > > unsigned > > >> >> > > > > > > > > > > > > > > > > > values > > >> >> > > > > > > > > > > > > > > > > > > as signed internally, > > >> >> > > > > > > > > > > > > > > > > > > but this is a huge pain when it > > >> comes > > >> >> to > > >> >> > > > > > metadata, > > >> >> > > > > > > > > binary > > >> >> > > > > > > > > > > > > > objects, > > >> >> > > > > > > > > > > > > > > > etc. > > >> >> > > > > > > > > > > > > > > > > > > (it is easy to deserialize int > as > > >> uint > > >> >> > when > > >> >> > > > you > > >> >> > > > > > > have > > >> >> > > > > > > > a > > >> >> > > > > > > > > > > class, > > >> >> > > > > > > > > > > > > but > > >> >> > > > > > > > > > > > > > > not > > >> >> > > > > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > > BinaryObject.GetField) > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > Any objections? > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 12:28 > PM > > >> >> Andrey > > >> >> > > > > > Mashenkov < > > >> >> > > > > > > > > > > > > > > > > > > andrey.mashen...@gmail.com> > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > Denis, > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > Good point. Both serializers > > use > > >> >> > > reflection > > >> >> > > > > > API. > > >> >> > > > > > > > > > > > > > > > > > > > However, we will allow users > to > > >> >> > configure > > >> >> > > > > > static > > >> >> > > > > > > > > schema > > >> >> > > > > > > > > > > > along > > >> >> > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > > 'strict' > > >> >> > > > > > > > > > > > > > > > > > > > schema mode, we still need to > > >> >> validate > > >> >> > > user > > >> >> > > > > > > classes > > >> >> > > > > > > > > on > > >> >> > > > > > > > > > > > client > > >> >> > > > > > > > > > > > > > > nodes > > >> >> > > > > > > > > > > > > > > > > > > against > > >> >> > > > > > > > > > > > > > > > > > > > the latest schema in the grid > > >> and > > >> >> > > > reflection > > >> >> > > > > > API > > >> >> > > > > > > > is > > >> >> > > > > > > > > > the > > >> >> > > > > > > > > > > > only > > >> >> > > > > > > > > > > > > > way > > >> >> > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > do > > >> >> > > > > > > > > > > > > > > > > > > it. > > >> >> > > > > > > > > > > > > > > > > > > > One can find a few articles > on > > >> the > > >> >> > > internet > > >> >> > > > > on > > >> >> > > > > > > how > > >> >> > > > > > > > to > > >> >> > > > > > > > > > > > enable > > >> >> > > > > > > > > > > > > > > > > reflection > > >> >> > > > > > > > > > > > > > > > > > > in > > >> >> > > > > > > > > > > > > > > > > > > > GraalVM. > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > I'll create a task for > > supporting > > >> >> > > GraalVM, > > >> >> > > > > and > > >> >> > > > > > > > maybe > > >> >> > > > > > > > > > > > someone > > >> >> > > > > > > > > > > > > > who > > >> >> > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > familiar with GraalVM will > > >> suggest a > > >> >> > > > solution > > >> >> > > > > > or > > >> >> > > > > > > a > > >> >> > > > > > > > > > proper > > >> >> > > > > > > > > > > > > > > > workaround. > > >> >> > > > > > > > > > > > > > > > > > Or > > >> >> > > > > > > > > > > > > > > > > > > > I'll do it a bit later. > > >> >> > > > > > > > > > > > > > > > > > > > If no workaround is found, we > > >> could > > >> >> > allow > > >> >> > > > > users > > >> >> > > > > > > to > > >> >> > > > > > > > > > write > > >> >> > > > > > > > > > > > it's > > >> >> > > > > > > > > > > > > > own > > >> >> > > > > > > > > > > > > > > > > > > > serializer, but I don't think > > it > > >> is > > >> >> a > > >> >> > > good > > >> >> > > > > idea > > >> >> > > > > > > to > > >> >> > > > > > > > > > expose > > >> >> > > > > > > > > > > > any > > >> >> > > > > > > > > > > > > > > > > internal > > >> >> > > > > > > > > > > > > > > > > > > > classes to the public. > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > On Tue, Nov 24, 2020 at 2:55 > AM > > >> >> Denis > > >> >> > > > Magda < > > >> >> > > > > > > > > > > > > dma...@apache.org > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > Andrey, thanks for the > > update, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > Does any of the serializers > > >> take > > >> >> into > > >> >> > > > > > > > consideration > > >> >> > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > native-image-generation > > >> feature of > > >> >> > > > GraalVM? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > >> https://www.graalvm.org/reference-manual/native-image/ > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > With the current binary > > >> >> marshaller, > > >> >> > we > > >> >> > > > > can't > > >> >> > > > > > > even > > >> >> > > > > > > > > > > > generate > > >> >> > > > > > > > > > > > > a > > >> >> > > > > > > > > > > > > > > > native > > >> >> > > > > > > > > > > > > > > > > > > image > > >> >> > > > > > > > > > > > > > > > > > > > > for the code using our thin > > >> client > > >> >> > > APIs. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > - > > >> >> > > > > > > > > > > > > > > > > > > > > Denis > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > On Mon, Nov 23, 2020 at > 4:39 > > AM > > >> >> > Andrey > > >> >> > > > > > > Mashenkov > > >> >> > > > > > > > < > > >> >> > > > > > > > > > > > > > > > > > > > > andrey.mashen...@gmail.com > > > > >> >> > > > > > > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Hi Igniters, > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > I'd like to continue > > >> discussion > > >> >> of > > >> >> > > > IEP-54 > > >> >> > > > > > > > > > > (Schema-first > > >> >> > > > > > > > > > > > > > > > > approach). > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Hope everyone who is > > >> interested > > >> >> > had a > > >> >> > > > > > chance > > >> >> > > > > > > to > > >> >> > > > > > > > > get > > >> >> > > > > > > > > > > > > > familiar > > >> >> > > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > proposal [1]. > > >> >> > > > > > > > > > > > > > > > > > > > > > Please, do not hesitate > to > > >> ask > > >> >> > > > questions > > >> >> > > > > > and > > >> >> > > > > > > > > share > > >> >> > > > > > > > > > > your > > >> >> > > > > > > > > > > > > > > ideas. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > I've prepared a prototype > > of > > >> >> > > serializer > > >> >> > > > > [2] > > >> >> > > > > > > for > > >> >> > > > > > > > > the > > >> >> > > > > > > > > > > > data > > >> >> > > > > > > > > > > > > > > layout > > >> >> > > > > > > > > > > > > > > > > > > > described > > >> >> > > > > > > > > > > > > > > > > > > > > > in the proposal. > > >> >> > > > > > > > > > > > > > > > > > > > > > In prototy, I compared 2 > > >> >> approaches > > >> >> > > to > > >> >> > > > > > > > > > (de)serialize > > >> >> > > > > > > > > > > > > > objects, > > >> >> > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > first > > >> >> > > > > > > > > > > > > > > > > > > > > one > > >> >> > > > > > > > > > > > > > > > > > > > > > uses java > reflection/unsafe > > >> API > > >> >> and > > >> >> > > > > similar > > >> >> > > > > > > to > > >> >> > > > > > > > > one > > >> >> > > > > > > > > > we > > >> >> > > > > > > > > > > > > > already > > >> >> > > > > > > > > > > > > > > > use > > >> >> > > > > > > > > > > > > > > > > > in > > >> >> > > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > and the second one > > generates > > >> >> > > serializer > > >> >> > > > > for > > >> >> > > > > > > > > > > particular > > >> >> > > > > > > > > > > > > user > > >> >> > > > > > > > > > > > > > > > class > > >> >> > > > > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > uses > > >> >> > > > > > > > > > > > > > > > > > > > > > Janino library for > > >> compilation. > > >> >> > > > > > > > > > > > > > > > > > > > > > Second one shows better > > >> results > > >> >> in > > >> >> > > > > > > benchmarks. > > >> >> > > > > > > > > > > > > > > > > > > > > > I think we can go with it > > as > > >> >> > default > > >> >> > > > > > > serializer > > >> >> > > > > > > > > and > > >> >> > > > > > > > > > > > have > > >> >> > > > > > > > > > > > > > > > > > > > reflection-based > > >> >> > > > > > > > > > > > > > > > > > > > > > implementation as a > > fallback > > >> if > > >> >> > > someone > > >> >> > > > > > will > > >> >> > > > > > > > have > > >> >> > > > > > > > > > > > issues > > >> >> > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > first > > >> >> > > > > > > > > > > > > > > > > > > > > > one. > > >> >> > > > > > > > > > > > > > > > > > > > > > WDYT? > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > There are a number of > tasks > > >> >> under > > >> >> > the > > >> >> > > > > > > umbrella > > >> >> > > > > > > > > > ticket > > >> >> > > > > > > > > > > > [3] > > >> >> > > > > > > > > > > > > > > > waiting > > >> >> > > > > > > > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > assignee. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > BTW, I'm going to create > > more > > >> >> > tickets > > >> >> > > > for > > >> >> > > > > > > > schema > > >> >> > > > > > > > > > > > manager > > >> >> > > > > > > > > > > > > > > modes > > >> >> > > > > > > > > > > > > > > > > > > > > > implementation, but would > > >> like > > >> >> to > > >> >> > > > clarify > > >> >> > > > > > > some > > >> >> > > > > > > > > > > details. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > I thought schemaManager > on > > >> each > > >> >> > node > > >> >> > > > > should > > >> >> > > > > > > > held: > > >> >> > > > > > > > > > > > > > > > > > > > > > 1. Local mapping of > > "schema > > >> >> > > version" > > >> >> > > > > <--> > > >> >> > > > > > > > > > validated > > >> >> > > > > > > > > > > > > local > > >> >> > > > > > > > > > > > > > > > > > key/value > > >> >> > > > > > > > > > > > > > > > > > > > > > classes pair. > > >> >> > > > > > > > > > > > > > > > > > > > > > 2. Cluster-wide schema > > >> changes > > >> >> > > > history. > > >> >> > > > > > > > > > > > > > > > > > > > > > On the client side. > Before > > >> any > > >> >> > > > key-value > > >> >> > > > > > API > > >> >> > > > > > > > > > > operation > > >> >> > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > should > > >> >> > > > > > > > > > > > > > > > > > > > > validate a > > >> >> > > > > > > > > > > > > > > > > > > > > > schema for a given > > key-value > > >> >> pair. > > >> >> > > > > > > > > > > > > > > > > > > > > > If there is no > > local-mapping > > >> >> exists > > >> >> > > > for a > > >> >> > > > > > > given > > >> >> > > > > > > > > > > > key-value > > >> >> > > > > > > > > > > > > > > pair > > >> >> > > > > > > > > > > > > > > > or > > >> >> > > > > > > > > > > > > > > > > > if > > >> >> > > > > > > > > > > > > > > > > > > a > > >> >> > > > > > > > > > > > > > > > > > > > > > cluster wide schema has a > > >> more > > >> >> > recent > > >> >> > > > > > version > > >> >> > > > > > > > > then > > >> >> > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > key-value > > >> >> > > > > > > > > > > > > > > > > > pair > > >> >> > > > > > > > > > > > > > > > > > > > > > should be validated > against > > >> the > > >> >> > > latest > > >> >> > > > > > > version > > >> >> > > > > > > > > and > > >> >> > > > > > > > > > > > local > > >> >> > > > > > > > > > > > > > > > mapping > > >> >> > > > > > > > > > > > > > > > > > > should > > >> >> > > > > > > > > > > > > > > > > > > > > be > > >> >> > > > > > > > > > > > > > > > > > > > > > updated/actualized. > > >> >> > > > > > > > > > > > > > > > > > > > > > If an object doesn't fit > to > > >> the > > >> >> > > latest > > >> >> > > > > > schema > > >> >> > > > > > > > > then > > >> >> > > > > > > > > > it > > >> >> > > > > > > > > > > > > > depends > > >> >> > > > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > > > mode: either fail the > > >> operation > > >> >> > > > ('strict' > > >> >> > > > > > > mode) > > >> >> > > > > > > > > or > > >> >> > > > > > > > > > a > > >> >> > > > > > > > > > > > new > > >> >> > > > > > > > > > > > > > > > mapping > > >> >> > > > > > > > > > > > > > > > > > > should > > >> >> > > > > > > > > > > > > > > > > > > > > be > > >> >> > > > > > > > > > > > > > > > > > > > > > created and a new schema > > >> version > > >> >> > > should > > >> >> > > > > be > > >> >> > > > > > > > > > propagated > > >> >> > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > cluster. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > On the server side we > > usually > > >> >> have > > >> >> > no > > >> >> > > > > > > key-value > > >> >> > > > > > > > > > > classes > > >> >> > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > > > > operate > > >> >> > > > > > > > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > > > > > tuples. > > >> >> > > > > > > > > > > > > > > > > > > > > > As schema change history > is > > >> >> > available > > >> >> > > > > and a > > >> >> > > > > > > > tuple > > >> >> > > > > > > > > > has > > >> >> > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > version, > > >> >> > > > > > > > > > > > > > > > > > > > > then > > >> >> > > > > > > > > > > > > > > > > > > > > > it is possible to upgrade > > any > > >> >> > > received > > >> >> > > > > > tuple > > >> >> > > > > > > to > > >> >> > > > > > > > > the > > >> >> > > > > > > > > > > > last > > >> >> > > > > > > > > > > > > > > > version > > >> >> > > > > > > > > > > > > > > > > > > > without > > >> >> > > > > > > > > > > > > > > > > > > > > > desialization. > > >> >> > > > > > > > > > > > > > > > > > > > > > Thus we could allow nodes > > to > > >> >> send > > >> >> > > > > key-value > > >> >> > > > > > > > pairs > > >> >> > > > > > > > > > of > > >> >> > > > > > > > > > > > > > previous > > >> >> > > > > > > > > > > > > > > > > > > versions > > >> >> > > > > > > > > > > > > > > > > > > > > (if > > >> >> > > > > > > > > > > > > > > > > > > > > > they didn't receive a > > schema > > >> >> update > > >> >> > > > yet) > > >> >> > > > > > > > without > > >> >> > > > > > > > > > > > > reverting > > >> >> > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > changes > > >> >> > > > > > > > > > > > > > > > > > > > > > made by a node with newer > > >> >> classes. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Alex, Val, Ivan did you > > mean > > >> the > > >> >> > > same? > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > [1] > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > > >> >> > > > > > > >> >> > > > > > >> >> > > > > >> >> > > > >> >> > > >> > > > https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach > > >> >> > > > > > > > > > > > > > > > > > > > > > [2] > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > >> https://github.com/apache/ignite/tree/ignite-13618/modules/commons > > >> >> > > > > > > > > > > > > > > > > > > > > > [3] > > >> >> > > > > > > > > > > > > https://issues.apache.org/jira/browse/IGNITE-13616 > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > On Thu, Sep 17, 2020 at > > 9:21 > > >> AM > > >> >> > Ivan > > >> >> > > > > > > Pavlukhin > > >> >> > > > > > > > < > > >> >> > > > > > > > > > > > > > > > > > vololo...@gmail.com> > > >> >> > > > > > > > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Folks, > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Please do not ignore > > >> history. > > >> >> We > > >> >> > > had > > >> >> > > > a > > >> >> > > > > > > thread > > >> >> > > > > > > > > [1] > > >> >> > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > many > > >> >> > > > > > > > > > > > > > > > > > bright > > >> >> > > > > > > > > > > > > > > > > > > > > > > ideas. We can resume > it. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > [1] > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > > >> >> > > > > > > >> >> > > > > > >> >> > > > > >> >> > > > >> >> > > >> > > > http://apache-ignite-developers.2346864.n4.nabble.com/Applicability-of-term-cache-to-Apache-Ignite-td36541.html > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > 2020-09-10 0:08 > > GMT+03:00, > > >> >> Denis > > >> >> > > > Magda > > >> >> > > > > < > > >> >> > > > > > > > > > > > > > dma...@apache.org > > >> >> > > > > > > > > > > > > > > >: > > >> >> > > > > > > > > > > > > > > > > > > > > > > > Val, makes sense, > > thanks > > >> for > > >> >> > > > > > explaining. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > Agree that we need to > > >> have a > > >> >> > > > separate > > >> >> > > > > > > > > > discussion > > >> >> > > > > > > > > > > > > thread > > >> >> > > > > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > "table" > > >> >> > > > > > > > > > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > > > > "cache" terms > > >> substitution. > > >> >> > I'll > > >> >> > > > > > > appreciate > > >> >> > > > > > > > > it > > >> >> > > > > > > > > > if > > >> >> > > > > > > > > > > > you > > >> >> > > > > > > > > > > > > > > start > > >> >> > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > thread > > >> >> > > > > > > > > > > > > > > > > > > > > > > > sharing pointers to > any > > >> >> > relevant > > >> >> > > > IEPs > > >> >> > > > > > and > > >> >> > > > > > > > > > > reasoning > > >> >> > > > > > > > > > > > > > > behind > > >> >> > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > suggested > > >> >> > > > > > > > > > > > > > > > > > > > > > > > change. > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > - > > >> >> > > > > > > > > > > > > > > > > > > > > > > > Denis > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > On Tue, Sep 8, 2020 > at > > >> 6:01 > > >> >> PM > > >> >> > > > > Valentin > > >> >> > > > > > > > > > > Kulichenko > > >> >> > > > > > > > > > > > < > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> valentin.kuliche...@gmail.com> > > >> >> > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> Hi Denis, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> I guess the wording > in > > >> the > > >> >> IEP > > >> >> > > is > > >> >> > > > a > > >> >> > > > > > > little > > >> >> > > > > > > > > bit > > >> >> > > > > > > > > > > > > > > confusing. > > >> >> > > > > > > > > > > > > > > > > All > > >> >> > > > > > > > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > > > > > > means > > >> >> > > > > > > > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> that you should not > > >> create > > >> >> > > nested > > >> >> > > > > > POJOs, > > >> >> > > > > > > > but > > >> >> > > > > > > > > > > > rather > > >> >> > > > > > > > > > > > > > > inline > > >> >> > > > > > > > > > > > > > > > > > > fields > > >> >> > > > > > > > > > > > > > > > > > > > > > into a > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> single POJO that is > > >> mapped > > >> >> to > > >> >> > a > > >> >> > > > > > > particular > > >> >> > > > > > > > > > > schema. > > >> >> > > > > > > > > > > > > In > > >> >> > > > > > > > > > > > > > > > other > > >> >> > > > > > > > > > > > > > > > > > > words, > > >> >> > > > > > > > > > > > > > > > > > > > > > > nested > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> POJOs are not > > supported. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> Alex, is this > correct? > > >> >> Please > > >> >> > > let > > >> >> > > > me > > >> >> > > > > > > know > > >> >> > > > > > > > if > > >> >> > > > > > > > > > I'm > > >> >> > > > > > > > > > > > > > missing > > >> >> > > > > > > > > > > > > > > > > > > > something. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> As for the "cache" > > >> term, I > > >> >> > agree > > >> >> > > > > that > > >> >> > > > > > it > > >> >> > > > > > > > is > > >> >> > > > > > > > > > > > > outdated, > > >> >> > > > > > > > > > > > > > > but > > >> >> > > > > > > > > > > > > > > > > I'm > > >> >> > > > > > > > > > > > > > > > > > > not > > >> >> > > > > > > > > > > > > > > > > > > > > sure > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> what we can replace > it > > >> >> with. > > >> >> > > > "Table" > > >> >> > > > > > is > > >> >> > > > > > > > > > tightly > > >> >> > > > > > > > > > > > > > > associated > > >> >> > > > > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > > > SQL, > > >> >> > > > > > > > > > > > > > > > > > > > > > but > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> SQL is optional in > our > > >> >> case. > > >> >> > Do > > >> >> > > > you > > >> >> > > > > > want > > >> >> > > > > > > > to > > >> >> > > > > > > > > > > > create a > > >> >> > > > > > > > > > > > > > > > > separate > > >> >> > > > > > > > > > > > > > > > > > > > > > discussion > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> about this? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> -Val > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> On Tue, Sep 8, 2020 > at > > >> >> 4:37 PM > > >> >> > > > Denis > > >> >> > > > > > > > Magda < > > >> >> > > > > > > > > > > > > > > > > dma...@apache.org > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Val, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> I've checked the > IEP > > >> again > > >> >> > and > > >> >> > > > > have a > > >> >> > > > > > > few > > >> >> > > > > > > > > > > > > questions. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Arbitrary nested > > >> objects > > >> >> and > > >> >> > > > > > > collections > > >> >> > > > > > > > > are > > >> >> > > > > > > > > > > not > > >> >> > > > > > > > > > > > > > > allowed > > >> >> > > > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > > > > > column > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> values. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Nested POJOs > should > > >> >> either > > >> >> > be > > >> >> > > > > > inlined > > >> >> > > > > > > > > into > > >> >> > > > > > > > > > > > > schema, > > >> >> > > > > > > > > > > > > > or > > >> >> > > > > > > > > > > > > > > > > > stored > > >> >> > > > > > > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > > > > > > > BLOBs > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Could you provide a > > DDL > > >> >> code > > >> >> > > > > snippet > > >> >> > > > > > > > > showing > > >> >> > > > > > > > > > > how > > >> >> > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > inlining > > >> >> > > > > > > > > > > > > > > > > > > of > > >> >> > > > > > > > > > > > > > > > > > > > > > POJOs > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> supposed to work? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Also, we keep using > > the > > >> >> terms > > >> >> > > > > "cache" > > >> >> > > > > > > and > > >> >> > > > > > > > > > > "table" > > >> >> > > > > > > > > > > > > > > > > throughout > > >> >> > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > IEP. > > >> >> > > > > > > > > > > > > > > > > > > > > > > Is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> it > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> the right time to > > >> discuss > > >> >> an > > >> >> > > > > > alternate > > >> >> > > > > > > > name > > >> >> > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > would > > >> >> > > > > > > > > > > > > > > > > > replace > > >> >> > > > > > > > > > > > > > > > > > > > > those > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> too? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Personally, the > > "table" > > >> >> > should > > >> >> > > > stay > > >> >> > > > > > and > > >> >> > > > > > > > the > > >> >> > > > > > > > > > > > "cache" > > >> >> > > > > > > > > > > > > > > > should > > >> >> > > > > > > > > > > > > > > > > go > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> considering > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> that SQL is one of > > the > > >> >> > primary > > >> >> > > > APIs > > >> >> > > > > > in > > >> >> > > > > > > > > Ignite > > >> >> > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > > > DDL > > >> >> > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > > supported > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> out-of-the-box. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> - > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Denis > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> On Mon, Sep 7, 2020 > > at > > >> >> 12:26 > > >> >> > PM > > >> >> > > > > > > Valentin > > >> >> > > > > > > > > > > > > Kulichenko < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > valentin.kuliche...@gmail.com> > > >> >> > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Ivan, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > I see your > point. I > > >> >> agree > > >> >> > > that > > >> >> > > > > with > > >> >> > > > > > > the > > >> >> > > > > > > > > > > > automatic > > >> >> > > > > > > > > > > > > > > > updates > > >> >> > > > > > > > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > > > > > step > > >> >> > > > > > > > > > > > > > > > > > > > > > > into > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > schema-last > > >> territory. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Actually, if we > > >> support > > >> >> > > > automatic > > >> >> > > > > > > > > > evolution, > > >> >> > > > > > > > > > > we > > >> >> > > > > > > > > > > > > can > > >> >> > > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > > well > > >> >> > > > > > > > > > > > > > > > > > > > > support > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > creating a cache > > >> without > > >> >> > > schema > > >> >> > > > > and > > >> >> > > > > > > > > > inferring > > >> >> > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > from > > >> >> > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > first > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > insert. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> In > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > other words, we > can > > >> have > > >> >> > both > > >> >> > > > > > > > > > "schema-first" > > >> >> > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > "schema-last" > > >> >> > > > > > > > > > > > > > > > > > > > > > modes. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Alexey, what do > you > > >> >> think? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > -Val > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > On Mon, Sep 7, > 2020 > > >> at > > >> >> 5:59 > > >> >> > > AM > > >> >> > > > > > Alexey > > >> >> > > > > > > > > > > > Goncharuk < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> alexey.goncha...@gmail.com > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > Ivan, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > Thank you, I > got > > >> your > > >> >> > > concern > > >> >> > > > > > now. > > >> >> > > > > > > As > > >> >> > > > > > > > > it > > >> >> > > > > > > > > > is > > >> >> > > > > > > > > > > > > > mostly > > >> >> > > > > > > > > > > > > > > > > > > regarding > > >> >> > > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > terminology, I > am > > >> >> > > absolutely > > >> >> > > > > fine > > >> >> > > > > > > > with > > >> >> > > > > > > > > > > > changing > > >> >> > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > name > > >> >> > > > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > > > > > > whatever > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> fits > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > the approach > > best. > > >> >> > Dynamic > > >> >> > > or > > >> >> > > > > > > > evolving > > >> >> > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > sounds > > >> >> > > > > > > > > > > > > > > > > > > great. I > > >> >> > > > > > > > > > > > > > > > > > > > > > will > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> make > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > corresponding > > >> changes > > >> >> to > > >> >> > > the > > >> >> > > > > IEP > > >> >> > > > > > > once > > >> >> > > > > > > > > we > > >> >> > > > > > > > > > > > settle > > >> >> > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > name. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > пн, 7 сент. > 2020 > > >> г. в > > >> >> > > 11:33, > > >> >> > > > > Ivan > > >> >> > > > > > > > > > > Pavlukhin < > > >> >> > > > > > > > > > > > > > > > > > > > > vololo...@gmail.com > > >> >> > > > > > > > > > > > > > > > > > > > > > >: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Hi Val, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Thank you for > > >> your > > >> >> > > answer! > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > My > > understanding > > >> is > > >> >> a > > >> >> > > > little > > >> >> > > > > > bit > > >> >> > > > > > > > > > > different. > > >> >> > > > > > > > > > > > > > Yes, > > >> >> > > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > > > evolution > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > definitely > > >> should be > > >> >> > > > > possible. > > >> >> > > > > > > But > > >> >> > > > > > > > I > > >> >> > > > > > > > > > see > > >> >> > > > > > > > > > > a > > >> >> > > > > > > > > > > > > main > > >> >> > > > > > > > > > > > > > > > > > > difference > > >> >> > > > > > > > > > > > > > > > > > > > in > > >> >> > > > > > > > > > > > > > > > > > > > > > > "how > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > schema is > > >> updated". > > >> >> I > > >> >> > > > treat a > > >> >> > > > > > > > common > > >> >> > > > > > > > > > SQL > > >> >> > > > > > > > > > > > > > approach > > >> >> > > > > > > > > > > > > > > > > > > > > schema-first. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Schema > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > and data > > >> >> manipulation > > >> >> > > > > > operations > > >> >> > > > > > > > are > > >> >> > > > > > > > > > > > clearly > > >> >> > > > > > > > > > > > > > > > > separated > > >> >> > > > > > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> enables > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > interesting > > >> >> > capabilities, > > >> >> > > > > e.g. > > >> >> > > > > > > > > > preventing > > >> >> > > > > > > > > > > > > > > untended > > >> >> > > > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > > > changes > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > by > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > mistaken data > > >> >> > operations, > > >> >> > > > > > > > restricting > > >> >> > > > > > > > > > > user > > >> >> > > > > > > > > > > > > > > > > permissions > > >> >> > > > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > > > > > change > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > schema. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > Schema-first > > >> means > > >> >> > that > > >> >> > > > > > schema > > >> >> > > > > > > > > exists > > >> >> > > > > > > > > > > in > > >> >> > > > > > > > > > > > > > > advance > > >> >> > > > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > all > > >> >> > > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> stored > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > data > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > is compliant > > with > > >> >> it - > > >> >> > > > that's > > >> >> > > > > > > > exactly > > >> >> > > > > > > > > > > what > > >> >> > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > proposed. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > A schema-last > > >> >> approach > > >> >> > > > > > mentioned > > >> >> > > > > > > in > > >> >> > > > > > > > > [1] > > >> >> > > > > > > > > > > > also > > >> >> > > > > > > > > > > > > > > > assumes > > >> >> > > > > > > > > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > exists, but > it > > is > > >> >> > > inferred > > >> >> > > > > from > > >> >> > > > > > > > data. > > >> >> > > > > > > > > > Is > > >> >> > > > > > > > > > > > not > > >> >> > > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > more > > >> >> > > > > > > > > > > > > > > > > > > > similar > > >> >> > > > > > > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > proposing > > >> approach? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > And I would > > like > > >> to > > >> >> > say, > > >> >> > > > that > > >> >> > > > > > my > > >> >> > > > > > > > main > > >> >> > > > > > > > > > > > concern > > >> >> > > > > > > > > > > > > > so > > >> >> > > > > > > > > > > > > > > > far > > >> >> > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > mostly > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > about > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > terminology. > > And > > >> I > > >> >> > > suppose > > >> >> > > > if > > >> >> > > > > > it > > >> >> > > > > > > > > > confuses > > >> >> > > > > > > > > > > > me > > >> >> > > > > > > > > > > > > > then > > >> >> > > > > > > > > > > > > > > > > > others > > >> >> > > > > > > > > > > > > > > > > > > > > might > > >> >> > > > > > > > > > > > > > > > > > > > > > be > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > confused as > > >> well. My > > >> >> > > > feeling > > >> >> > > > > is > > >> >> > > > > > > > > closer > > >> >> > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > "dynamic > > >> >> > > > > > > > > > > > > > > > or > > >> >> > > > > > > > > > > > > > > > > > > > liquid > > >> >> > > > > > > > > > > > > > > > > > > > > or > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > may > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> be > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > evolving > > schema". > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > [1] > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > >> >> > > > > >> >> > > >> > https://people.cs.umass.edu/~yanlei/courses/CS691LL-f06/papers/SH05.pdf > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > 2020-09-07 > 0:47 > > >> >> > > GMT+03:00, > > >> >> > > > > > > Valentin > > >> >> > > > > > > > > > > > > Kulichenko > > >> >> > > > > > > > > > > > > > < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > valentin.kuliche...@gmail.com > > >> >> > > > > > >: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > Hi Ivan, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > I don't see > > an > > >> >> issue > > >> >> > > with > > >> >> > > > > > that. > > >> >> > > > > > > > > > > > > Schema-first > > >> >> > > > > > > > > > > > > > > > means > > >> >> > > > > > > > > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > > > > > > > > > schema > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> exists > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > in > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > advance and > > all > > >> >> the > > >> >> > > > stored > > >> >> > > > > > data > > >> >> > > > > > > > is > > >> >> > > > > > > > > > > > > compliant > > >> >> > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > > > - > > >> >> > > > > > > > > > > > > > > > > > > > > that's > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> exactly > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > what > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > is > proposed. > > >> There > > >> >> > are > > >> >> > > no > > >> >> > > > > > > > > > restrictions > > >> >> > > > > > > > > > > > > > > > prohibiting > > >> >> > > > > > > > > > > > > > > > > > > > changes > > >> >> > > > > > > > > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > schema. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > -Val > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > On Sat, Sep > > 5, > > >> >> 2020 > > >> >> > at > > >> >> > > > 9:52 > > >> >> > > > > > PM > > >> >> > > > > > > > Ivan > > >> >> > > > > > > > > > > > > > Pavlukhin < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > vololo...@gmail.com> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Alexey, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> I am a > > little > > >> bit > > >> >> > > > confused > > >> >> > > > > > > with > > >> >> > > > > > > > > > > > > terminology. > > >> >> > > > > > > > > > > > > > > My > > >> >> > > > > > > > > > > > > > > > > > > > > > understanding > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > conforms > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> to a > survey > > >> [1] > > >> >> (see > > >> >> > > > part > > >> >> > > > > X > > >> >> > > > > > > Semi > > >> >> > > > > > > > > > > > > Structured > > >> >> > > > > > > > > > > > > > > > Data). > > >> >> > > > > > > > > > > > > > > > > > Can > > >> >> > > > > > > > > > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> really > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > treat > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> a "dynamic > > >> >> schema" > > >> >> > > > > approach > > >> >> > > > > > > as a > > >> >> > > > > > > > > > kind > > >> >> > > > > > > > > > > of > > >> >> > > > > > > > > > > > > > > > > > > "schema-first"? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> [1] > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > >> >> > > > > >> >> > > >> > https://people.cs.umass.edu/~yanlei/courses/CS691LL-f06/papers/SH05.pdf > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> 2020-09-02 > > >> 1:53 > > >> >> > > > GMT+03:00, > > >> >> > > > > > > Denis > > >> >> > > > > > > > > > > Magda < > > >> >> > > > > > > > > > > > > > > > > > > > dma...@apache.org > > >> >> > > > > > > > > > > > > > > > > > > > > >: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > However, > > >> could > > >> >> > you > > >> >> > > > > please > > >> >> > > > > > > > > > elaborate > > >> >> > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > relation > > >> >> > > > > > > > > > > > > > > > > > > > > > between > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> ORM? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> Is > there > > a > > >> use > > >> >> > case > > >> >> > > > for > > >> >> > > > > > > > > Hibernate > > >> >> > > > > > > > > > > > > running > > >> >> > > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > > top > > >> >> > > > > > > > > > > > > > > > > > of > > >> >> > > > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> (I > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > haven't > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> seen > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> one so > > >> far)? > > >> >> If > > >> >> > so, > > >> >> > > > > what > > >> >> > > > > > is > > >> >> > > > > > > > > > missing > > >> >> > > > > > > > > > > > > > exactly > > >> >> > > > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> side to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> support > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> this? > In > > my > > >> >> > > > > > understanding, > > >> >> > > > > > > > all > > >> >> > > > > > > > > > you > > >> >> > > > > > > > > > > > need > > >> >> > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > SQL > > >> >> > > > > > > > > > > > > > > > > > API > > >> >> > > > > > > > > > > > > > > > > > > > > which > > >> >> > > > > > > > > > > > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > already > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> have. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> Am I > > >> missing > > >> >> > > > something? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > Good > > point, > > >> >> yes, > > >> >> > if > > >> >> > > > all > > >> >> > > > > > the > > >> >> > > > > > > > ORM > > >> >> > > > > > > > > > > > > > integrations > > >> >> > > > > > > > > > > > > > > > use > > >> >> > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > SQL > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> APIs > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > internally, > > >> >> then > > >> >> > > they > > >> >> > > > > can > > >> >> > > > > > > > easily > > >> >> > > > > > > > > > > > > translate > > >> >> > > > > > > > > > > > > > > an > > >> >> > > > > > > > > > > > > > > > > > Entity > > >> >> > > > > > > > > > > > > > > > > > > > > > object > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> into > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > an > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> INSERT/UPDATE > > >> >> > > > statement > > >> >> > > > > > that > > >> >> > > > > > > > > lists > > >> >> > > > > > > > > > > all > > >> >> > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > object's > > >> >> > > > > > > > > > > > > > > > > > > > > > fields. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Luckily, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > our > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > Spring > > Data > > >> >> > > > integration > > >> >> > > > > is > > >> >> > > > > > > > > already > > >> >> > > > > > > > > > > > based > > >> >> > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > SQL > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > APIs > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > and > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > needs > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > to be > > >> improved > > >> >> > once > > >> >> > > > the > > >> >> > > > > > > > > > schema-first > > >> >> > > > > > > > > > > > > > > approach > > >> >> > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > > supported. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> That > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > would > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > solve a > > ton > > >> of > > >> >> > > > usability > > >> >> > > > > > > > issues. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > I would > > >> revise > > >> >> the > > >> >> > > > > > Hibernate > > >> >> > > > > > > > > > > > integration > > >> >> > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > well > > >> >> > > > > > > > > > > > > > > > > > > > during > > >> >> > > > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > 3.0 > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> dev > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > phase. > > Can't > > >> >> say > > >> >> > if > > >> >> > > > it's > > >> >> > > > > > > used > > >> >> > > > > > > > a > > >> >> > > > > > > > > > lot > > >> >> > > > > > > > > > > > but > > >> >> > > > > > > > > > > > > > > Spring > > >> >> > > > > > > > > > > > > > > > > > Data > > >> >> > > > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > getting > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > traction > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> for > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > sure. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > @Michael > > >> >> Pollind, > > >> >> > > I'll > > >> >> > > > > > loop > > >> >> > > > > > > > you > > >> >> > > > > > > > > in > > >> >> > > > > > > > > > > as > > >> >> > > > > > > > > > > > > long > > >> >> > > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > > > you've > > >> >> > > > > > > > > > > > > > > > > > > > > > started > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > working > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > on > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > Ignite > > >> support > > >> >> for > > >> >> > > > > > Micornaut > > >> >> > > > > > > > > Data > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > >> >> https://micronaut-projects.github.io/micronaut-data/latest/guide/> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > came > > across > > >> >> some > > >> >> > > > > > challenges. > > >> >> > > > > > > > > Just > > >> >> > > > > > > > > > > > watch > > >> >> > > > > > > > > > > > > > this > > >> >> > > > > > > > > > > > > > > > > > > > discussion. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > That's > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > what > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > coming > in > > >> >> Ignite > > >> >> > > 3.0. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > - > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > Denis > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > On Mon, > > Aug > > >> 31, > > >> >> > 2020 > > >> >> > > > at > > >> >> > > > > > 5:11 > > >> >> > > > > > > > PM > > >> >> > > > > > > > > > > > Valentin > > >> >> > > > > > > > > > > > > > > > > > Kulichenko > > >> >> > > > > > > > > > > > > > > > > > > < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > valentin.kuliche...@gmail.com > > >> >> > > > > > > > > > > >> >> > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> Hi > Denis, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > Generally > > >> >> > > speaking, I > > >> >> > > > > > > believe > > >> >> > > > > > > > > > that > > >> >> > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > schema-first > > >> >> > > > > > > > > > > > > > > > > > > > > > > approach > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > natively > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > addresses > > >> the > > >> >> > issue > > >> >> > > > if > > >> >> > > > > > > > > duplicate > > >> >> > > > > > > > > > > > fields > > >> >> > > > > > > > > > > > > > in > > >> >> > > > > > > > > > > > > > > > key > > >> >> > > > > > > > > > > > > > > > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > value > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> objects, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> because > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> schema > > >> will be > > >> >> > > > created > > >> >> > > > > > for > > >> >> > > > > > > a > > >> >> > > > > > > > > > cache, > > >> >> > > > > > > > > > > > not > > >> >> > > > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > > > > an > > >> >> > > > > > > > > > > > > > > > > > > > object, > > >> >> > > > > > > > > > > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > happens > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> now. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > Basically, > > >> the > > >> >> > > schema > > >> >> > > > > > will > > >> >> > > > > > > > > define > > >> >> > > > > > > > > > > > > whether > > >> >> > > > > > > > > > > > > > > > there > > >> >> > > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > a > > >> >> > > > > > > > > > > > > > > > > > > > > > > primary > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> key > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > or > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> not, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> and > which > > >> >> fields > > >> >> > > are > > >> >> > > > > > > included > > >> >> > > > > > > > > in > > >> >> > > > > > > > > > > case > > >> >> > > > > > > > > > > > > > there > > >> >> > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > one. > > >> >> > > > > > > > > > > > > > > > > > > > Any > > >> >> > > > > > > > > > > > > > > > > > > > > > API > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> that > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > we > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> would > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> have > must > > >> be > > >> >> > > > compliant > > >> >> > > > > > with > > >> >> > > > > > > > > this, > > >> >> > > > > > > > > > > so > > >> >> > > > > > > > > > > > it > > >> >> > > > > > > > > > > > > > > > becomes > > >> >> > > > > > > > > > > > > > > > > > > > fairly > > >> >> > > > > > > > > > > > > > > > > > > > > > easy > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > work > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> with > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> data as > > >> with a > > >> >> > set > > >> >> > > of > > >> >> > > > > > > > records, > > >> >> > > > > > > > > > > rather > > >> >> > > > > > > > > > > > > > than > > >> >> > > > > > > > > > > > > > > > > > > key-value > > >> >> > > > > > > > > > > > > > > > > > > > > > pairs. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > However, > > >> could > > >> >> > you > > >> >> > > > > please > > >> >> > > > > > > > > > elaborate > > >> >> > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > relation > > >> >> > > > > > > > > > > > > > > > > > > > > > between > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > and > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> ORM? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> Is > there > > a > > >> use > > >> >> > case > > >> >> > > > for > > >> >> > > > > > > > > Hibernate > > >> >> > > > > > > > > > > > > running > > >> >> > > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > > top > > >> >> > > > > > > > > > > > > > > > > > of > > >> >> > > > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> (I > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > haven't > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> seen > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> one so > > >> far)? > > >> >> If > > >> >> > so, > > >> >> > > > > what > > >> >> > > > > > is > > >> >> > > > > > > > > > missing > > >> >> > > > > > > > > > > > > > exactly > > >> >> > > > > > > > > > > > > > > > on > > >> >> > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> side to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> support > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> this? > In > > my > > >> >> > > > > > understanding, > > >> >> > > > > > > > all > > >> >> > > > > > > > > > you > > >> >> > > > > > > > > > > > need > > >> >> > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > SQL > > >> >> > > > > > > > > > > > > > > > > > API > > >> >> > > > > > > > > > > > > > > > > > > > > which > > >> >> > > > > > > > > > > > > > > > > > > > > > we > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > already > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> have. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> Am I > > >> missing > > >> >> > > > something? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> -Val > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> On Mon, > > Aug > > >> >> 31, > > >> >> > > 2020 > > >> >> > > > at > > >> >> > > > > > > 2:08 > > >> >> > > > > > > > PM > > >> >> > > > > > > > > > > Denis > > >> >> > > > > > > > > > > > > > > Magda < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> dma...@apache.org> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > Val, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > I > would > > >> >> propose > > >> >> > > > > adding > > >> >> > > > > > > > > another > > >> >> > > > > > > > > > > > point > > >> >> > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > motivations > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > list > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > which > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > is > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > related > > >> to > > >> >> the > > >> >> > > ORM > > >> >> > > > > > > > frameworks > > >> >> > > > > > > > > > > such > > >> >> > > > > > > > > > > > as > > >> >> > > > > > > > > > > > > > > > Spring > > >> >> > > > > > > > > > > > > > > > > > > Data, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> Hibernate, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Micronaut > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> and > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > many > > >> others. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> Presently, > > >> >> the > > >> >> > > > > storage > > >> >> > > > > > > > engine > > >> >> > > > > > > > > > > > > requires > > >> >> > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > > > > > distinguish > > >> >> > > > > > > > > > > > > > > > > > > > > > key > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > objects > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > from > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > value > > >> ones > > >> >> that > > >> >> > > > > > > complicate > > >> >> > > > > > > > > the > > >> >> > > > > > > > > > > > usage > > >> >> > > > > > > > > > > > > of > > >> >> > > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > > with > > >> >> > > > > > > > > > > > > > > > > > > > > > those > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> ORM > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> frameworks > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> (especially > > >> >> if > > >> >> > a > > >> >> > > > key > > >> >> > > > > > > object > > >> >> > > > > > > > > > > > comprises > > >> >> > > > > > > > > > > > > > > > several > > >> >> > > > > > > > > > > > > > > > > > > > > fields). > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > More > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> on > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > this > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> can > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> be > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > found > > >> here: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > > >> >> > > > > > > >> >> > > > > > >> >> > > > > >> >> > > > >> >> > > >> > > > http://apache-ignite-developers.2346864.n4.nabble.com/DISCUSSION-Key-and-Value-fields-with-same-name-and-SQL-DML-td47557.html > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > It > will > > >> be > > >> >> nice > > >> >> > > if > > >> >> > > > > the > > >> >> > > > > > > new > > >> >> > > > > > > > > > > > > schema-first > > >> >> > > > > > > > > > > > > > > > > > approach > > >> >> > > > > > > > > > > > > > > > > > > > > allows > > >> >> > > > > > > > > > > > > > > > > > > > > > > us > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > work > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> with > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > a > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > single > > >> >> entity > > >> >> > > > object > > >> >> > > > > > when > > >> >> > > > > > > > it > > >> >> > > > > > > > > > > comes > > >> >> > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > ORMs. > > >> >> > > > > > > > > > > > > > > > > > > > With > > >> >> > > > > > > > > > > > > > > > > > > > > no > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> need to > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > split > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > entity > > >> into > > >> >> a > > >> >> > key > > >> >> > > > and > > >> >> > > > > > > > value. > > >> >> > > > > > > > > > Just > > >> >> > > > > > > > > > > > > want > > >> >> > > > > > > > > > > > > > to > > >> >> > > > > > > > > > > > > > > > be > > >> >> > > > > > > > > > > > > > > > > > sure > > >> >> > > > > > > > > > > > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > Ignite > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > 3.0 > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > has > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > all > the > > >> >> > essential > > >> >> > > > > > public > > >> >> > > > > > > > APIs > > >> >> > > > > > > > > > > that > > >> >> > > > > > > > > > > > > > would > > >> >> > > > > > > > > > > > > > > > > > support > > >> >> > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > single-entity > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > based > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > approach. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > What > do > > >> you > > >> >> > > think? > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > - > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > Denis > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > On > Fri, > > >> Aug > > >> >> 28, > > >> >> > > > 2020 > > >> >> > > > > at > > >> >> > > > > > > > 3:50 > > >> >> > > > > > > > > PM > > >> >> > > > > > > > > > > > > > Valentin > > >> >> > > > > > > > > > > > > > > > > > > > Kulichenko < > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > valentin.kuliche...@gmail.com> > > >> >> > > > > > > > > > > > > wrote: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> Igniters, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > One > > of > > >> the > > >> >> > big > > >> >> > > > > > changes > > >> >> > > > > > > > > > proposed > > >> >> > > > > > > > > > > > for > > >> >> > > > > > > > > > > > > > > > Ignite > > >> >> > > > > > > > > > > > > > > > > > 3.0 > > >> >> > > > > > > > > > > > > > > > > > > is > > >> >> > > > > > > > > > > > > > > > > > > > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> "schema-first > > >> >> > > > > > > approach". > > >> >> > > > > > > > To > > >> >> > > > > > > > > > add > > >> >> > > > > > > > > > > > > more > > >> >> > > > > > > > > > > > > > > > > clarity, > > >> >> > > > > > > > > > > > > > > > > > > > I've > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > started > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > writing > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > the > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > IEP > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > for > > >> this > > >> >> > > change: > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > > >> >> > > > > > > >> >> > > > > > >> >> > > > > >> >> > > > >> >> > > >> > > > https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > Please > > >> >> take a > > >> >> > > > look > > >> >> > > > > > and > > >> >> > > > > > > > let > > >> >> > > > > > > > > me > > >> >> > > > > > > > > > > > know > > >> >> > > > > > > > > > > > > if > > >> >> > > > > > > > > > > > > > > > there > > >> >> > > > > > > > > > > > > > > > > > are > > >> >> > > > > > > > > > > > > > > > > > > > any > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> thoughts, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> suggestions, > > >> >> > or > > >> >> > > > > > > > objections. > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > -Val > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> -- > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Best > > regards, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Ivan > > Pavlukhin > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > -- > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best regards, > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan > Pavlukhin > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > -- > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin > > >> >> > > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > -- > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > -- > > >> >> > > > > > > > > > > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > -- > > >> >> > > > > > > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > -- > > >> >> > > > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > > > > > >> >> > > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > -- > > >> >> > > > > > > > > > > Best regards, > > >> >> > > > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > > > >> >> > > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > > > >> >> > > > > > > > > -- > > >> >> > > > > > > > > Best regards, > > >> >> > > > > > > > > Andrey V. Mashenkov > > >> >> > > > > > > > > > > >> >> > > > > > > > > > >> >> > > > > > > > > >> >> > > > > > > > >> >> > > > > > > >> >> > > > > > > >> >> > > > > -- > > >> >> > > > > Живи с улыбкой! :D > > >> >> > > > > > > >> >> > > > > > >> >> > > > > > >> >> > > > -- > > >> >> > > > Best regards, > > >> >> > > > Andrey V. Mashenkov > > >> >> > > > > > >> >> > > > > >> >> > > > >> >> > > >> > > > >> > > > > > > > > > -- > > > Best regards, > > > Andrey V. Mashenkov > > > > > > > > > -- > > Best regards, > > Andrey V. Mashenkov > > > -- Best regards, Andrey V. Mashenkov
