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
