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 > > > > > > > > > >
