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