Re: IEP-54: Schema-first approach for 3.0

[Alexey Goncharuk <al...@gmail.com>]

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 <al...@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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 Юрий <ju...@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.goncharuk@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 <
>> ptupitsyn@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.goncharuk@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.mashenkov@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 <
>> > > > > ptupitsyn@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.mashenkov@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 <
>> > > > > > > ptupitsyn@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.mashenkov@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 <
>> > > > > > > isapego@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 <
>> > > > > > > > > > ptupitsyn@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.mashenkov@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
>> > <
>> > > > > > > > > > > > ptupitsyn@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 <
>> > > > > > > > > > > isapego@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
>> > > > <
>> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
>> > > > > > > > > > > > > dmagda@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.mashenkov@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
>> > > > > > > > <
>> > > > > > > > > > > > > > > > > > vololo100@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
>> > > > > <
>> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
>> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
>> > > > > > > > > > > > > > > > > > > > > > > >>> vololo100@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 <
>> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> > > > > > > > > > > > > > > > > > > > > > > >>> dmagda@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.kulichenko@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
>> > > >
>> > >
>> >
>>
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Hi Ignites,

I've made 2 PRs with different approaches for writing rows in a compact way.
Both approached imply using a different format for different row sizes.

* the first one is similar to what we have now: the exact target row size
is calculated, then the row is written to the byte[].
String characters are analyzed to calculate exact row size.

* the second one: write a row to a byte[] then compact it if possible.
Row size is estimated, to reduce row buffer expanding, So, no string
analysis is needed, string length is just multiplied by 2.

Benchmark results are attached to a ticket. [1]

I've found
* Latin1 string serialization is costly (about x20) comparing to byte[]
regardless the approach described above.
* Non-latin string (when contains char coded into >1 byte) costs even more
(~ x30-x40)
* Writing string to a byte[] at first with String.toBytes(), then writing
it to row shows much better performance.
Actually, String.toBytes() is a highly optimized method and for 'latin1'
strings benchmarks show similar performance as for byte[] columns.
This result looks expected as no character conversion is required. However,
using CharsetEncoder.encode() for the same purpose, shows much worse (x20
times) results.

Sadly, JVM offers no other way to write String into a buffer or stream than
CharsetEncoder.
So, we can either accept x2-20 (latin and non-latin strings) times worse
performance or be ok with additional allocations.

Overall, marshaling time difference for other types looks insignificant
comparing to strings.

[1] https://issues.apache.org/jira/browse/IGNITE-14743

On Thu, Jun 10, 2021 at 4:13 PM Ilya Kasnacheev <il...@gmail.com>
wrote:

> Hello!
>
> This makes sense, Andrey.
>
> I also think that we may skip 2-byte lengths.
> If the variable length fields section is larger than 255 bytes then we may
> just always use 4 byte lengths, because their length becomes irrelevant
> after a few kb of data stored.
>
> So we may just have 1-byte addressing for small objects and 4-byte
> addressing for larger ones.
>
> WDYT?
>
> Regards,
> --
> Ilya Kasnacheev
>
>
> чт, 10 июн. 2021 г. в 15:36, Andrey Mashenkov <andrey.mashenkov@gmail.com
> >:
>
> > Hi Ilya,
> >
> > Thanks for the answer. I like the idea with "re-packing".
> > You suggest re-pack to larger sizes, that can cause up to 4 array
> copying,
> > however, this could be improved.
> >
> > We can start with 4-bytes offset.
> > Then once we have finish writing a chunk (key or value), we check if
> > offsets fits into smaller type,
> > then compact vartable and shift chunk data.
> >
> > If we will write 'sizes' instead 'offsets' or write relative offsets
> (e.g.
> > from data block begin), then we'll not need to recalculate them. but just
> > convert the types.
> > We'll not need to create a new array for shifting the data.
> >
> > On Thu, Jun 10, 2021 at 12:40 PM Ilya Kasnacheev <
> > ilya.kasnacheev@gmail.com>
> > wrote:
> >
> > > Hello!
> > >
> > > If we have determined that next varstring is too long to fit in 1-2
> bytes
> > > index, we can re-pack the whole object from scratch with 2-4 bytes
> index.
> > >
> > > Such as:
> > >
> > > We write all fixlen fields in the beginning.
> > > We start to write first varlen string. Accumulated len is <255 so we
> use
> > > single byte length
> > > We start to write second varlen string. Accumulated len is now >255 but
> > > <64k so we re-pack the first varlen string with 2 byte length also.
> > > We start to write third varlen (let's say it's byte[] blob).
> Accumulated
> > > len is suddenly >64k so we re-pack already written varlen fields to
> use 4
> > > byte lengths/offsets.
> > >
> > > The overhead here is not as great as you could expect. When reading, we
> > > already know total varlen fields section length so we also know how
> many
> > > bytes size offsets take.
> > >
> > > Regards,
> > >
> > > --
> > > Ilya Kasnacheev
> > >
> > >
> > > вт, 25 мая 2021 г. в 16:40, Andrey Mashenkov <
> andrey.mashenkov@gmail.com
> > >:
> > >
> > > > >
> > > > > I never said that you can predict string size.
> > > >
> > > > You suggest to use offsets use 1-2-4 bytes based on overall varlen
> > > section
> > > > size.
> > > > Actually, we can't predict varlen section size if a string column
> > defined
> > > > before serializing strings.
> > > >
> > > > Do you suggest use the smallest possible offset size if no columns of
> > > > string type are defined,
> > > > but fallback to 4-byte if a string column goes into play?
> > > >
> > > > On Thu, May 20, 2021 at 6:59 PM Ilya Kasnacheev <
> > > ilya.kasnacheev@gmail.com
> > > > >
> > > > wrote:
> > > >
> > > > > Hello!
> > > > >
> > > > > I never said that you can predict string size. Strings are
> definitely
> > > > > varlen. You don't know string length when looking at object
> schema, I
> > > > don't
> > > > > even see why char-to-byte mapping is relevant here.
> > > > >
> > > > > What do you think about the approach where offsets use 1-2-4 bytes
> > > based
> > > > on
> > > > > overall varlen section size, which is known in advance as I assume?
> > > > >
> > > > > With compression, some optimizations may be possible since you can
> > > > compress
> > > > > blocks of data and then concatenate these compressed fragments. So
> > you
> > > > can
> > > > > say that "I want 40-th byte of 3rd fragment" but it sounds like an
> > > > overkill
> > > > > mostly.
> > > > >
> > > > > Regards,
> > > > > --
> > > > > Ilya Kasnacheev
> > > > >
> > > > >
> > > > > чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <
> > > andrey.mashenkov@gmail.com
> > > > >:
> > > > >
> > > > > > Hi Ilya,
> > > > > >
> > > > > > Not yet, we can't predict string size [1] as a character may be
> > > encoded
> > > > > in
> > > > > > 1-4 bytes.
> > > > > > So, we could either use a heuristic or serialize every string
> into
> > an
> > > > > array
> > > > > > at first then assemble a row and copy the array into the row
> > buffer.
> > > > > >
> > > > > > Good point, we can skip vartable for the first varlen field.
> > > > > > We have a similar ticket [2] for the case with a single varlen.
> > I'll
> > > > fix
> > > > > > the description to omit a first varlen offset.
> > > > > >
> > > > > > Agree, compression looks tricky and ineffective in this case.
> > > > > >
> > > > > > [1]
> > > > > >
> > > > > >
> > > > >
> > > >
> > >
> >
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> > > > > > [2] https://issues.apache.org/jira/browse/IGNITE-14746
> > > > > >
> > > > > > On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <
> > > > > ilya.kasnacheev@gmail.com
> > > > > > >
> > > > > > wrote:
> > > > > >
> > > > > > > Hello!
> > > > > > >
> > > > > > > How about:
> > > > > > >
> > > > > > > First, all fields for which we know their specific order and
> size
> > > go,
> > > > > > such
> > > > > > > as byte, short, int, long, boolean. This means that any short
> > field
> > > > > will
> > > > > > > take just 2 bytes with no padding.
> > > > > > > Then, all var-len fields go, such as nested object, strings,
> etc.
> > > > > > >
> > > > > > > After that, we know total object size already, right?
> > > > > > > If size <= 256, then all offsets are 1 byte unsigned.
> > > > > > > If size < 65k, then all offsets are 2 byte.
> > > > > > > Else, all offsets are 4 byte.
> > > > > > >
> > > > > > > We can count offsets starting from the first byle after
> constant
> > > > fields
> > > > > > > section and offsets section.
> > > > > > > For the first varlen field, the offset is always 0, so we may
> > skip
> > > > this
> > > > > > one
> > > > > > > and start with offset of the second var field.
> > > > > > >
> > > > > > > For compression it is trickier. I suggest not having any
> explicit
> > > > > support
> > > > > > > for compression right here, so that later on compression may
> use
> > a
> > > > > > > different object layout to be more efficient.
> > > > > > >
> > > > > > > Regards,
> > > > > > > --
> > > > > > > Ilya Kasnacheev
> > > > > > >
> > > > > > >
> > > > > > > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <
> > > > > andrey.mashenkov@gmail.com
> > > > > > >:
> > > > > > >
> > > > > > > > Hi Igniters,
> > > > > > > >
> > > > > > > > I've create a ticket [1] for large row support.
> > > > > > > >
> > > > > > > > We use 2-bytes offsets for varlen fields that are supposed to
> > be
> > > > > large
> > > > > > > > enough.
> > > > > > > > AFAIK, some users use multi-MB values and 64k per Row looks
> > like
> > > a
> > > > > > strong
> > > > > > > > limitation.
> > > > > > > >
> > > > > > > > So, we have either to increase offset_size up to 4-bytes or
> use
> > > > some
> > > > > > > > advanced mechanics for compression or adaptive offset_size.
> > > > > > > >
> > > > > > > > 1. Increasing offset size may add overhead for keys like
> next:
> > > > > > > > class Key {
> > > > > > > >    int id;
> > > > > > > >    String str; // Some short string code.
> > > > > > > > }
> > > > > > > >
> > > > > > > > 2. Compression will require table to be decompressed on every
> > > > varlen
> > > > > > > column
> > > > > > > > access, e.g. for comparison purposes while index scan.
> > > > > > > > Also, we may need to pre-calculate compressed table size to
> > avoid
> > > > > > buffer
> > > > > > > > copying (shrinking or extending) during row assembling.
> > > > > > > >
> > > > > > > > 3. Adaptive offset_size implies row size estimation.
> > > > > > > > We already do to reduce the probability of buffer expanding,
> > but
> > > we
> > > > > > need
> > > > > > > a
> > > > > > > > high margin for this purpose.
> > > > > > > > 'String' values size is a hard part as String character may
> be
> > > > > encoded
> > > > > > > into
> > > > > > > > 1-4 bytes depending on Charset.
> > > > > > > >
> > > > > > > > Usually, a user don't want to care about Column length
> > limitation
> > > > and
> > > > > > > chars
> > > > > > > > collation.
> > > > > > > > So, we can expect a Java default behavior will be used in
> most
> > > > cases:
> > > > > > > > 'unlimited' string size with up to 4-bytes characters
> support.
> > > > > > > >
> > > > > > > > Possible strategies
> > > > > > > > 3.1 Introduce 'Collation' for string and validate all the
> chars
> > > on
> > > > > row
> > > > > > > > assembling and rely on the user limited column length.
> > > > > > > > Thus, we can use varlen limits (+ collation for strings) to
> > > > estimate
> > > > > > row
> > > > > > > > size and pre-calculate offset_size to keep it within the
> > schema.
> > > > > > > > 3.2 Introduce more row flags for different offset sizes
> (byte,
> > > > short,
> > > > > > > int)
> > > > > > > > and calculate row size right before assembling for choosing
> > > > > appropriate
> > > > > > > > offset_size.
> > > > > > > > Heuristics for strings using collation is also applicable
> here
> > > and
> > > > > keep
> > > > > > > > algorithm complexity independent from the data length, but
> the
> > > > schema
> > > > > > > only.
> > > > > > > >
> > > > > > > > I like an approach '3.2' because we already estimate row
> size.
> > > > > > > > Any thoughts?
> > > > > > > >
> > > > > > > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > > > > > > >
> > > > > > > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > > > > > > andrey.mashenkov@gmail.com>
> > > > > > > > wrote:
> > > > > > > >
> > > > > > > > > Igniters,
> > > > > > > > > I've prepared PR [1] with Public Table API for final
> review.
> > > > > > > > >
> > > > > > > > > Main points
> > > > > > > > > There are 4 projection interfaces over Table for different
> > > > > use-cases
> > > > > > > > > (Plain record vs Key-Value and POJO vs Binary object)
> > declaring
> > > > > > > > synchronous
> > > > > > > > > and asynchronous methods.
> > > > > > > > > Async method returns IgniteFuture as there is no consensus
> on
> > > > > > > > IgniteFuture
> > > > > > > > > vs JDK CompletableFuture yet.
> > > > > > > > > API implementation is incomplete, it just an example of how
> > it
> > > > > could
> > > > > > be
> > > > > > > > > done and will be implemented in future tasks.
> > > > > > > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple
> > is
> > > > > just a
> > > > > > > > > dictionary representing a subset of columns, while Row is a
> > > > > > > schema-aware
> > > > > > > > > object containing key and value columns respectively to the
> > > data
> > > > > > > layout.
> > > > > > > > >
> > > > > > > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> > > > > > ptupitsyn@apache.org>
> > > > > > > > > wrote:
> > > > > > > > >
> > > > > > > > >> I see, thanks.
> > > > > > > > >>
> > > > > > > > >> Let's discuss the return type - Future is not the one to
> > use.
> > > > > > > > >> We should return CompletionStage, CompletableFuture, or
> > > > introduce
> > > > > > our
> > > > > > > > own
> > > > > > > > >> interface.
> > > > > > > > >> We agreed on the last one (custom interface) for thin
> > clients:
> > > > > > > > >>
> > > > > > > > >>
> > > > > > > >
> > > > > > >
> > > > > >
> > > > >
> > > >
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > > > > > > >>
> > > > > > > > >> I believe that for Ignite 3.0 we should have the
> following:
> > > > > > > > >> public interface IgniteFuture<T> extends Future<T>,
> > > > > > > CompletionStage<T> {
> > > > > > > > >>     // No-op.
> > > > > > > > >> }
> > > > > > > > >>
> > > > > > > > >> Thoughts?
> > > > > > > > >>
> > > > > > > > >>
> > > > > > > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > > > > > > >> andrey.mashenkov@gmail.com> wrote:
> > > > > > > > >>
> > > > > > > > >> > Pavel,
> > > > > > > > >> > There are 2 PR's for the ticket[1] with two different
> APIs
> > > > > > > suggested.
> > > > > > > > >> > Please, take a look at PR [2].
> > > > > > > > >> >
> > > > > > > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > > > > > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > > > > > > >> >
> > > > > > > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > > > > > > ptupitsyn@apache.org
> > > > > > > > >
> > > > > > > > >> > wrote:
> > > > > > > > >> >
> > > > > > > > >> > > Andrey, I can't find any async methods,
> > > > > > > > >> > > can you please check if the changes are pushed?
> > > > > > > > >> > >
> > > > > > > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > > > > > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > > > > > > >> > >
> > > > > > > > >> > > > Pavel, good point.
> > > > > > > > >> > > > Thanks. I've added async methods.
> > > > > > > > >> > > >
> > > > > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > > > > >> ptupitsyn@apache.org>
> > > > > > > > >> > > > wrote:
> > > > > > > > >> > > >
> > > > > > > > >> > > > > Andrey,
> > > > > > > > >> > > > >
> > > > > > > > >> > > > > What about corresponding async APIs, do we add
> them
> > > now
> > > > or
> > > > > > > > later?
> > > > > > > > >> > > > >
> > > > > > > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > > > > > >> > > > > andrey.mashenkov@gmail.com>
> > > > > > > > >> > > > > wrote:
> > > > > > > > >> > > > >
> > > > > > > > >> > > > > > Hi Igniters.
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > I've created a PR for Table access API [1].
> > > > > > > > >> > > > > > This is an initial version. So, any
> > > > > suggestions\objections
> > > > > > > are
> > > > > > > > >> > > > welcomed.
> > > > > > > > >> > > > > > Please, do not hesitate to write your comments
> > > and\or
> > > > > > > examples
> > > > > > > > >> to
> > > > > > > > >> > the
> > > > > > > > >> > > > PR.
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > Ignite-api module contains API classes, e.g.
> > > TableView
> > > > > > > classes
> > > > > > > > >> as
> > > > > > > > >> > > > > > projections for a table for different purposes.
> > > > > > > > >> > > > > > Ignite-table contains dummy implementation and
> > > Example
> > > > > > class
> > > > > > > > >> > > explained
> > > > > > > > >> > > > > how
> > > > > > > > >> > > > > > it is supposed to be used.
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > Also, I'm still waiting for any feedback for
> > Schema
> > > > > > > > >> configuration
> > > > > > > > >> > > > public
> > > > > > > > >> > > > > > API PR [2].
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > > > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey
> Mashenkov <
> > > > > > > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > > > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > > > > > > >> > > <
> > > > > > > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > > > > > >> > > > > <
> > > > > > > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > > > > >> > > > > > >> >> > <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> ptupitsyn@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > > > > > >> > > > > > >> >> > > > <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > ptupitsyn@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.mashenkov@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > vololo100@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
> > > > > > > > >> > > > > > >> >> > > > > <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> dmagda@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.kulichenko@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> vololo100@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.kulichenko@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > > > > > >> > > > > vololo100@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > dmagda@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.kulichenko@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 <
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > > > > > >> > > > dmagda@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.kulichenko@gmail.com
> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> Igniters,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > One
> > > > > > > > >> > > > > > of
> > > > > > > > >> > > > > > >> the
> > > > > > > > >> > > > > > >> >> > big
> > > > > > > > >> > > > > > >> >> > > > > > changes
> > > > > > > > >> > > > > > >> >> > > > > > > > > > proposed
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > for
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> the
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > > > > >> so-called
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> "schema-first
> > > > > > > > >> > > > > > >> >> > > > > > > approach".
> > > > > > > > >> > > > > > >> >> > > > > > > > To
> > > > > > > > >> > > > > > >> >> > > > > > > > > > add
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > started
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> writing
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > the
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >> >
> > > > > > > > >> > > IEP
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > for
> > > > > > > > >> > > > > > >> this
> > > > > > > > >> > > > > > >> >> > > change:
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > >
> > > > > > > > >> > > > > > >> >> > > > >
> > > > > > > > >> > > > > > >> >> > > >
> > > > > > > > >> > > > > > >> >> > >
> > > > > > > > >> > > > > > >> >> >
> > > > > > > > >> > > > > > >> >>
> > > > > > > > >> > > > > > >>
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > >
> > > > > > > > >> > > >
> > > > > > > > >> > >
> > > > > > > > >> >
> > > > > > > > >>
> > > > > > > >
> > > > > > >
> > > > > >
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > Please
> > > > > > > > >> > > > > > >> >> take a
> > > > > > > > >> > > > > > >> >> > > > look
> > > > > > > > >> > > > > > >> >> > > > > > and
> > > > > > > > >> > > > > > >> >> > > > > > > > let
> > > > > > > > >> > > > > > >> >> > > > > > > > > me
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > know
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > > > > > immediate
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> thoughts,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> suggestions,
> > > > > > > > >> > > > > > >> >> > or
> > > > > > > > >> > > > > > >> >> > > > > > > > objections.
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > -Val
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> Best
> > > > > > > > >> > > > > > regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> Ivan
> > > > > > > > >> > > > > > Pavlukhin
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > Best
> > > > > > > > >> > > > regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > Ivan
> > > > > > > > >> > > > > Pavlukhin
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > >>>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > >>
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > Best
> > > > > > > > regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > Ivan
> > > > > > > > Pavlukhin
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > Best
> > > > > > > regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > Andrey
> > > > > V.
> > > > > > > > >> Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best
> > > > > regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> Andrey
> > > V.
> > > > > > > > Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best
> regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V.
> > > > Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V.
> Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > > > --
> > > > > > > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > > > > > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > > >
> > > > > > > > >> > > > > > >> >> > > > > >
> > > > > > > > >> > > > > > >> >> > > > >
> > > > > > > > >> > > > > > >> >> > > > >
> > > > > > > > >> > > > > > >> >> > > > > --
> > > > > > > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > > > > >> > > > > > >> >> > > > >
> > > > > > > > >> > > > > > >> >> > > >
> > > > > > > > >> > > > > > >> >> > > >
> > > > > > > > >> > > > > > >> >> > > > --
> > > > > > > > >> > > > > > >> >> > > > Best regards,
> > > > > > > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > > > > > >> > > > > > >> >> > > >
> > > > > > > > >> > > > > > >> >> > >
> > > > > > > > >> > > > > > >> >> >
> > > > > > > > >> > > > > > >> >>
> > > > > > > > >> > > > > > >> >
> > > > > > > > >> > > > > > >>
> > > > > > > > >> > > > > > >
> > > > > > > > >> > > > > > >
> > > > > > > > >> > > > > > > --
> > > > > > > > >> > > > > > > Best regards,
> > > > > > > > >> > > > > > > Andrey V. Mashenkov
> > > > > > > > >> > > > > > >
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > > > --
> > > > > > > > >> > > > > > Best regards,
> > > > > > > > >> > > > > > Andrey V. Mashenkov
> > > > > > > > >> > > > > >
> > > > > > > > >> > > > >
> > > > > > > > >> > > >
> > > > > > > > >> > > >
> > > > > > > > >> > > > --
> > > > > > > > >> > > > Best regards,
> > > > > > > > >> > > > Andrey V. Mashenkov
> > > > > > > > >> > > >
> > > > > > > > >> > >
> > > > > > > > >> >
> > > > > > > > >> >
> > > > > > > > >> > --
> > > > > > > > >> > 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
> >
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Ilya Kasnacheev <il...@gmail.com>]

Hello!

This makes sense, Andrey.

I also think that we may skip 2-byte lengths.
If the variable length fields section is larger than 255 bytes then we may
just always use 4 byte lengths, because their length becomes irrelevant
after a few kb of data stored.

So we may just have 1-byte addressing for small objects and 4-byte
addressing for larger ones.

WDYT?

Regards,
-- 
Ilya Kasnacheev


чт, 10 июн. 2021 г. в 15:36, Andrey Mashenkov <an...@gmail.com>:

> Hi Ilya,
>
> Thanks for the answer. I like the idea with "re-packing".
> You suggest re-pack to larger sizes, that can cause up to 4 array copying,
> however, this could be improved.
>
> We can start with 4-bytes offset.
> Then once we have finish writing a chunk (key or value), we check if
> offsets fits into smaller type,
> then compact vartable and shift chunk data.
>
> If we will write 'sizes' instead 'offsets' or write relative offsets (e.g.
> from data block begin), then we'll not need to recalculate them. but just
> convert the types.
> We'll not need to create a new array for shifting the data.
>
> On Thu, Jun 10, 2021 at 12:40 PM Ilya Kasnacheev <
> ilya.kasnacheev@gmail.com>
> wrote:
>
> > Hello!
> >
> > If we have determined that next varstring is too long to fit in 1-2 bytes
> > index, we can re-pack the whole object from scratch with 2-4 bytes index.
> >
> > Such as:
> >
> > We write all fixlen fields in the beginning.
> > We start to write first varlen string. Accumulated len is <255 so we use
> > single byte length
> > We start to write second varlen string. Accumulated len is now >255 but
> > <64k so we re-pack the first varlen string with 2 byte length also.
> > We start to write third varlen (let's say it's byte[] blob). Accumulated
> > len is suddenly >64k so we re-pack already written varlen fields to use 4
> > byte lengths/offsets.
> >
> > The overhead here is not as great as you could expect. When reading, we
> > already know total varlen fields section length so we also know how many
> > bytes size offsets take.
> >
> > Regards,
> >
> > --
> > Ilya Kasnacheev
> >
> >
> > вт, 25 мая 2021 г. в 16:40, Andrey Mashenkov <andrey.mashenkov@gmail.com
> >:
> >
> > > >
> > > > I never said that you can predict string size.
> > >
> > > You suggest to use offsets use 1-2-4 bytes based on overall varlen
> > section
> > > size.
> > > Actually, we can't predict varlen section size if a string column
> defined
> > > before serializing strings.
> > >
> > > Do you suggest use the smallest possible offset size if no columns of
> > > string type are defined,
> > > but fallback to 4-byte if a string column goes into play?
> > >
> > > On Thu, May 20, 2021 at 6:59 PM Ilya Kasnacheev <
> > ilya.kasnacheev@gmail.com
> > > >
> > > wrote:
> > >
> > > > Hello!
> > > >
> > > > I never said that you can predict string size. Strings are definitely
> > > > varlen. You don't know string length when looking at object schema, I
> > > don't
> > > > even see why char-to-byte mapping is relevant here.
> > > >
> > > > What do you think about the approach where offsets use 1-2-4 bytes
> > based
> > > on
> > > > overall varlen section size, which is known in advance as I assume?
> > > >
> > > > With compression, some optimizations may be possible since you can
> > > compress
> > > > blocks of data and then concatenate these compressed fragments. So
> you
> > > can
> > > > say that "I want 40-th byte of 3rd fragment" but it sounds like an
> > > overkill
> > > > mostly.
> > > >
> > > > Regards,
> > > > --
> > > > Ilya Kasnacheev
> > > >
> > > >
> > > > чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <
> > andrey.mashenkov@gmail.com
> > > >:
> > > >
> > > > > Hi Ilya,
> > > > >
> > > > > Not yet, we can't predict string size [1] as a character may be
> > encoded
> > > > in
> > > > > 1-4 bytes.
> > > > > So, we could either use a heuristic or serialize every string into
> an
> > > > array
> > > > > at first then assemble a row and copy the array into the row
> buffer.
> > > > >
> > > > > Good point, we can skip vartable for the first varlen field.
> > > > > We have a similar ticket [2] for the case with a single varlen.
> I'll
> > > fix
> > > > > the description to omit a first varlen offset.
> > > > >
> > > > > Agree, compression looks tricky and ineffective in this case.
> > > > >
> > > > > [1]
> > > > >
> > > > >
> > > >
> > >
> >
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> > > > > [2] https://issues.apache.org/jira/browse/IGNITE-14746
> > > > >
> > > > > On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <
> > > > ilya.kasnacheev@gmail.com
> > > > > >
> > > > > wrote:
> > > > >
> > > > > > Hello!
> > > > > >
> > > > > > How about:
> > > > > >
> > > > > > First, all fields for which we know their specific order and size
> > go,
> > > > > such
> > > > > > as byte, short, int, long, boolean. This means that any short
> field
> > > > will
> > > > > > take just 2 bytes with no padding.
> > > > > > Then, all var-len fields go, such as nested object, strings, etc.
> > > > > >
> > > > > > After that, we know total object size already, right?
> > > > > > If size <= 256, then all offsets are 1 byte unsigned.
> > > > > > If size < 65k, then all offsets are 2 byte.
> > > > > > Else, all offsets are 4 byte.
> > > > > >
> > > > > > We can count offsets starting from the first byle after constant
> > > fields
> > > > > > section and offsets section.
> > > > > > For the first varlen field, the offset is always 0, so we may
> skip
> > > this
> > > > > one
> > > > > > and start with offset of the second var field.
> > > > > >
> > > > > > For compression it is trickier. I suggest not having any explicit
> > > > support
> > > > > > for compression right here, so that later on compression may use
> a
> > > > > > different object layout to be more efficient.
> > > > > >
> > > > > > Regards,
> > > > > > --
> > > > > > Ilya Kasnacheev
> > > > > >
> > > > > >
> > > > > > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <
> > > > andrey.mashenkov@gmail.com
> > > > > >:
> > > > > >
> > > > > > > Hi Igniters,
> > > > > > >
> > > > > > > I've create a ticket [1] for large row support.
> > > > > > >
> > > > > > > We use 2-bytes offsets for varlen fields that are supposed to
> be
> > > > large
> > > > > > > enough.
> > > > > > > AFAIK, some users use multi-MB values and 64k per Row looks
> like
> > a
> > > > > strong
> > > > > > > limitation.
> > > > > > >
> > > > > > > So, we have either to increase offset_size up to 4-bytes or use
> > > some
> > > > > > > advanced mechanics for compression or adaptive offset_size.
> > > > > > >
> > > > > > > 1. Increasing offset size may add overhead for keys like next:
> > > > > > > class Key {
> > > > > > >    int id;
> > > > > > >    String str; // Some short string code.
> > > > > > > }
> > > > > > >
> > > > > > > 2. Compression will require table to be decompressed on every
> > > varlen
> > > > > > column
> > > > > > > access, e.g. for comparison purposes while index scan.
> > > > > > > Also, we may need to pre-calculate compressed table size to
> avoid
> > > > > buffer
> > > > > > > copying (shrinking or extending) during row assembling.
> > > > > > >
> > > > > > > 3. Adaptive offset_size implies row size estimation.
> > > > > > > We already do to reduce the probability of buffer expanding,
> but
> > we
> > > > > need
> > > > > > a
> > > > > > > high margin for this purpose.
> > > > > > > 'String' values size is a hard part as String character may be
> > > > encoded
> > > > > > into
> > > > > > > 1-4 bytes depending on Charset.
> > > > > > >
> > > > > > > Usually, a user don't want to care about Column length
> limitation
> > > and
> > > > > > chars
> > > > > > > collation.
> > > > > > > So, we can expect a Java default behavior will be used in most
> > > cases:
> > > > > > > 'unlimited' string size with up to 4-bytes characters support.
> > > > > > >
> > > > > > > Possible strategies
> > > > > > > 3.1 Introduce 'Collation' for string and validate all the chars
> > on
> > > > row
> > > > > > > assembling and rely on the user limited column length.
> > > > > > > Thus, we can use varlen limits (+ collation for strings) to
> > > estimate
> > > > > row
> > > > > > > size and pre-calculate offset_size to keep it within the
> schema.
> > > > > > > 3.2 Introduce more row flags for different offset sizes (byte,
> > > short,
> > > > > > int)
> > > > > > > and calculate row size right before assembling for choosing
> > > > appropriate
> > > > > > > offset_size.
> > > > > > > Heuristics for strings using collation is also applicable here
> > and
> > > > keep
> > > > > > > algorithm complexity independent from the data length, but the
> > > schema
> > > > > > only.
> > > > > > >
> > > > > > > I like an approach '3.2' because we already estimate row size.
> > > > > > > Any thoughts?
> > > > > > >
> > > > > > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > > > > > >
> > > > > > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > > > > > andrey.mashenkov@gmail.com>
> > > > > > > wrote:
> > > > > > >
> > > > > > > > Igniters,
> > > > > > > > I've prepared PR [1] with Public Table API for final review.
> > > > > > > >
> > > > > > > > Main points
> > > > > > > > There are 4 projection interfaces over Table for different
> > > > use-cases
> > > > > > > > (Plain record vs Key-Value and POJO vs Binary object)
> declaring
> > > > > > > synchronous
> > > > > > > > and asynchronous methods.
> > > > > > > > Async method returns IgniteFuture as there is no consensus on
> > > > > > > IgniteFuture
> > > > > > > > vs JDK CompletableFuture yet.
> > > > > > > > API implementation is incomplete, it just an example of how
> it
> > > > could
> > > > > be
> > > > > > > > done and will be implemented in future tasks.
> > > > > > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple
> is
> > > > just a
> > > > > > > > dictionary representing a subset of columns, while Row is a
> > > > > > schema-aware
> > > > > > > > object containing key and value columns respectively to the
> > data
> > > > > > layout.
> > > > > > > >
> > > > > > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> > > > > ptupitsyn@apache.org>
> > > > > > > > wrote:
> > > > > > > >
> > > > > > > >> I see, thanks.
> > > > > > > >>
> > > > > > > >> Let's discuss the return type - Future is not the one to
> use.
> > > > > > > >> We should return CompletionStage, CompletableFuture, or
> > > introduce
> > > > > our
> > > > > > > own
> > > > > > > >> interface.
> > > > > > > >> We agreed on the last one (custom interface) for thin
> clients:
> > > > > > > >>
> > > > > > > >>
> > > > > > >
> > > > > >
> > > > >
> > > >
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > > > > > >>
> > > > > > > >> I believe that for Ignite 3.0 we should have the following:
> > > > > > > >> public interface IgniteFuture<T> extends Future<T>,
> > > > > > CompletionStage<T> {
> > > > > > > >>     // No-op.
> > > > > > > >> }
> > > > > > > >>
> > > > > > > >> Thoughts?
> > > > > > > >>
> > > > > > > >>
> > > > > > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > > > > > >> andrey.mashenkov@gmail.com> wrote:
> > > > > > > >>
> > > > > > > >> > Pavel,
> > > > > > > >> > There are 2 PR's for the ticket[1] with two different APIs
> > > > > > suggested.
> > > > > > > >> > Please, take a look at PR [2].
> > > > > > > >> >
> > > > > > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > > > > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > > > > > >> >
> > > > > > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > > > > > ptupitsyn@apache.org
> > > > > > > >
> > > > > > > >> > wrote:
> > > > > > > >> >
> > > > > > > >> > > Andrey, I can't find any async methods,
> > > > > > > >> > > can you please check if the changes are pushed?
> > > > > > > >> > >
> > > > > > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > > > > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > > > > > >> > >
> > > > > > > >> > > > Pavel, good point.
> > > > > > > >> > > > Thanks. I've added async methods.
> > > > > > > >> > > >
> > > > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > > > >> ptupitsyn@apache.org>
> > > > > > > >> > > > wrote:
> > > > > > > >> > > >
> > > > > > > >> > > > > Andrey,
> > > > > > > >> > > > >
> > > > > > > >> > > > > What about corresponding async APIs, do we add them
> > now
> > > or
> > > > > > > later?
> > > > > > > >> > > > >
> > > > > > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > > > > >> > > > > andrey.mashenkov@gmail.com>
> > > > > > > >> > > > > wrote:
> > > > > > > >> > > > >
> > > > > > > >> > > > > > Hi Igniters.
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > I've created a PR for Table access API [1].
> > > > > > > >> > > > > > This is an initial version. So, any
> > > > suggestions\objections
> > > > > > are
> > > > > > > >> > > > welcomed.
> > > > > > > >> > > > > > Please, do not hesitate to write your comments
> > and\or
> > > > > > examples
> > > > > > > >> to
> > > > > > > >> > the
> > > > > > > >> > > > PR.
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > Ignite-api module contains API classes, e.g.
> > TableView
> > > > > > classes
> > > > > > > >> as
> > > > > > > >> > > > > > projections for a table for different purposes.
> > > > > > > >> > > > > > Ignite-table contains dummy implementation and
> > Example
> > > > > class
> > > > > > > >> > > explained
> > > > > > > >> > > > > how
> > > > > > > >> > > > > > it is supposed to be used.
> > > > > > > >> > > > > >
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > Also, I'm still waiting for any feedback for
> Schema
> > > > > > > >> configuration
> > > > > > > >> > > > public
> > > > > > > >> > > > > > API PR [2].
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > > > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > > > > > >> > > <
> > > > > > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > > > > >> > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > > > >> > > > > > >> >> > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > > > > >> > > > > > >> >> > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > ptupitsyn@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.mashenkov@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > vololo100@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
> > > > > > > >> > > > > > >> >> > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> vololo100@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.kulichenko@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > > vololo100@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > dmagda@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.kulichenko@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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > dmagda@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.kulichenko@gmail.com
> > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >> >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> Igniters,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > One
> > > > > > > >> > > > > > of
> > > > > > > >> > > > > > >> the
> > > > > > > >> > > > > > >> >> > big
> > > > > > > >> > > > > > >> >> > > > > > changes
> > > > > > > >> > > > > > >> >> > > > > > > > > > proposed
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > for
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > > > > >> so-called
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> "schema-first
> > > > > > > >> > > > > > >> >> > > > > > > approach".
> > > > > > > >> > > > > > >> >> > > > > > > > To
> > > > > > > >> > > > > > >> >> > > > > > > > > > add
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > started
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> writing
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > the
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >> >
> > > > > > > >> > > IEP
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > for
> > > > > > > >> > > > > > >> this
> > > > > > > >> > > > > > >> >> > > change:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >> >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > >
> > > > > > > >> > > > > > >> >> > > > > >
> > > > > > > >> > > > > > >> >> > > > >
> > > > > > > >> > > > > > >> >> > > >
> > > > > > > >> > > > > > >> >> > >
> > > > > > > >> > > > > > >> >> >
> > > > > > > >> > > > > > >> >>
> > > > > > > >> > > > > > >>
> > > > > > > >> > > > > >
> > > > > > > >> > > > >
> > > > > > > >> > > >
> > > > > > > >> > >
> > > > > > > >> >
> > > > > > > >>
> > > > > > >
> > > > > >
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > Please
> > > > > > > >> > > > > > >> >> take a
> > > > > > > >> > > > > > >> >> > > > look
> > > > > > > >> > > > > > >> >> > > > > > and
> > > > > > > >> > > > > > >> >> > > > > > > > let
> > > > > > > >> > > > > > >> >> > > > > > > > > me
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > know
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > immediate
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> thoughts,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> suggestions,
> > > > > > > >> > > > > > >> >> > or
> > > > > > > >> > > > > > >> >> > > > > > > > objections.
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > -Val
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >> >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> Best
> > > > > > > >> > > > > > regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> Ivan
> > > > > > > >> > > > > > Pavlukhin
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > Best
> > > > > > > >> > > > regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > Ivan
> > > > > > > >> > > > > Pavlukhin
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > Best
> > > > > > > regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > Ivan
> > > > > > > Pavlukhin
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> Best
> > > > > > regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > Andrey
> > > > V.
> > > > > > > >> Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best
> > > > regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey
> > V.
> > > > > > > Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V.
> > > Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > --
> > > > > > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > > > > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > >
> > > > > > > >> > > > > > >> >> > > > > >
> > > > > > > >> > > > > > >> >> > > > >
> > > > > > > >> > > > > > >> >> > > > >
> > > > > > > >> > > > > > >> >> > > > > --
> > > > > > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > > > >> > > > > > >> >> > > > >
> > > > > > > >> > > > > > >> >> > > >
> > > > > > > >> > > > > > >> >> > > >
> > > > > > > >> > > > > > >> >> > > > --
> > > > > > > >> > > > > > >> >> > > > Best regards,
> > > > > > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > > > > >> > > > > > >> >> > > >
> > > > > > > >> > > > > > >> >> > >
> > > > > > > >> > > > > > >> >> >
> > > > > > > >> > > > > > >> >>
> > > > > > > >> > > > > > >> >
> > > > > > > >> > > > > > >>
> > > > > > > >> > > > > > >
> > > > > > > >> > > > > > >
> > > > > > > >> > > > > > > --
> > > > > > > >> > > > > > > Best regards,
> > > > > > > >> > > > > > > Andrey V. Mashenkov
> > > > > > > >> > > > > > >
> > > > > > > >> > > > > >
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > --
> > > > > > > >> > > > > > Best regards,
> > > > > > > >> > > > > > Andrey V. Mashenkov
> > > > > > > >> > > > > >
> > > > > > > >> > > > >
> > > > > > > >> > > >
> > > > > > > >> > > >
> > > > > > > >> > > > --
> > > > > > > >> > > > Best regards,
> > > > > > > >> > > > Andrey V. Mashenkov
> > > > > > > >> > > >
> > > > > > > >> > >
> > > > > > > >> >
> > > > > > > >> >
> > > > > > > >> > --
> > > > > > > >> > 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
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Hi Ilya,

Thanks for the answer. I like the idea with "re-packing".
You suggest re-pack to larger sizes, that can cause up to 4 array copying,
however, this could be improved.

We can start with 4-bytes offset.
Then once we have finish writing a chunk (key or value), we check if
offsets fits into smaller type,
then compact vartable and shift chunk data.

If we will write 'sizes' instead 'offsets' or write relative offsets (e.g.
from data block begin), then we'll not need to recalculate them. but just
convert the types.
We'll not need to create a new array for shifting the data.

On Thu, Jun 10, 2021 at 12:40 PM Ilya Kasnacheev <il...@gmail.com>
wrote:

> Hello!
>
> If we have determined that next varstring is too long to fit in 1-2 bytes
> index, we can re-pack the whole object from scratch with 2-4 bytes index.
>
> Such as:
>
> We write all fixlen fields in the beginning.
> We start to write first varlen string. Accumulated len is <255 so we use
> single byte length
> We start to write second varlen string. Accumulated len is now >255 but
> <64k so we re-pack the first varlen string with 2 byte length also.
> We start to write third varlen (let's say it's byte[] blob). Accumulated
> len is suddenly >64k so we re-pack already written varlen fields to use 4
> byte lengths/offsets.
>
> The overhead here is not as great as you could expect. When reading, we
> already know total varlen fields section length so we also know how many
> bytes size offsets take.
>
> Regards,
>
> --
> Ilya Kasnacheev
>
>
> вт, 25 мая 2021 г. в 16:40, Andrey Mashenkov <an...@gmail.com>:
>
> > >
> > > I never said that you can predict string size.
> >
> > You suggest to use offsets use 1-2-4 bytes based on overall varlen
> section
> > size.
> > Actually, we can't predict varlen section size if a string column defined
> > before serializing strings.
> >
> > Do you suggest use the smallest possible offset size if no columns of
> > string type are defined,
> > but fallback to 4-byte if a string column goes into play?
> >
> > On Thu, May 20, 2021 at 6:59 PM Ilya Kasnacheev <
> ilya.kasnacheev@gmail.com
> > >
> > wrote:
> >
> > > Hello!
> > >
> > > I never said that you can predict string size. Strings are definitely
> > > varlen. You don't know string length when looking at object schema, I
> > don't
> > > even see why char-to-byte mapping is relevant here.
> > >
> > > What do you think about the approach where offsets use 1-2-4 bytes
> based
> > on
> > > overall varlen section size, which is known in advance as I assume?
> > >
> > > With compression, some optimizations may be possible since you can
> > compress
> > > blocks of data and then concatenate these compressed fragments. So you
> > can
> > > say that "I want 40-th byte of 3rd fragment" but it sounds like an
> > overkill
> > > mostly.
> > >
> > > Regards,
> > > --
> > > Ilya Kasnacheev
> > >
> > >
> > > чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <
> andrey.mashenkov@gmail.com
> > >:
> > >
> > > > Hi Ilya,
> > > >
> > > > Not yet, we can't predict string size [1] as a character may be
> encoded
> > > in
> > > > 1-4 bytes.
> > > > So, we could either use a heuristic or serialize every string into an
> > > array
> > > > at first then assemble a row and copy the array into the row buffer.
> > > >
> > > > Good point, we can skip vartable for the first varlen field.
> > > > We have a similar ticket [2] for the case with a single varlen. I'll
> > fix
> > > > the description to omit a first varlen offset.
> > > >
> > > > Agree, compression looks tricky and ineffective in this case.
> > > >
> > > > [1]
> > > >
> > > >
> > >
> >
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> > > > [2] https://issues.apache.org/jira/browse/IGNITE-14746
> > > >
> > > > On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <
> > > ilya.kasnacheev@gmail.com
> > > > >
> > > > wrote:
> > > >
> > > > > Hello!
> > > > >
> > > > > How about:
> > > > >
> > > > > First, all fields for which we know their specific order and size
> go,
> > > > such
> > > > > as byte, short, int, long, boolean. This means that any short field
> > > will
> > > > > take just 2 bytes with no padding.
> > > > > Then, all var-len fields go, such as nested object, strings, etc.
> > > > >
> > > > > After that, we know total object size already, right?
> > > > > If size <= 256, then all offsets are 1 byte unsigned.
> > > > > If size < 65k, then all offsets are 2 byte.
> > > > > Else, all offsets are 4 byte.
> > > > >
> > > > > We can count offsets starting from the first byle after constant
> > fields
> > > > > section and offsets section.
> > > > > For the first varlen field, the offset is always 0, so we may skip
> > this
> > > > one
> > > > > and start with offset of the second var field.
> > > > >
> > > > > For compression it is trickier. I suggest not having any explicit
> > > support
> > > > > for compression right here, so that later on compression may use a
> > > > > different object layout to be more efficient.
> > > > >
> > > > > Regards,
> > > > > --
> > > > > Ilya Kasnacheev
> > > > >
> > > > >
> > > > > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <
> > > andrey.mashenkov@gmail.com
> > > > >:
> > > > >
> > > > > > Hi Igniters,
> > > > > >
> > > > > > I've create a ticket [1] for large row support.
> > > > > >
> > > > > > We use 2-bytes offsets for varlen fields that are supposed to be
> > > large
> > > > > > enough.
> > > > > > AFAIK, some users use multi-MB values and 64k per Row looks like
> a
> > > > strong
> > > > > > limitation.
> > > > > >
> > > > > > So, we have either to increase offset_size up to 4-bytes or use
> > some
> > > > > > advanced mechanics for compression or adaptive offset_size.
> > > > > >
> > > > > > 1. Increasing offset size may add overhead for keys like next:
> > > > > > class Key {
> > > > > >    int id;
> > > > > >    String str; // Some short string code.
> > > > > > }
> > > > > >
> > > > > > 2. Compression will require table to be decompressed on every
> > varlen
> > > > > column
> > > > > > access, e.g. for comparison purposes while index scan.
> > > > > > Also, we may need to pre-calculate compressed table size to avoid
> > > > buffer
> > > > > > copying (shrinking or extending) during row assembling.
> > > > > >
> > > > > > 3. Adaptive offset_size implies row size estimation.
> > > > > > We already do to reduce the probability of buffer expanding, but
> we
> > > > need
> > > > > a
> > > > > > high margin for this purpose.
> > > > > > 'String' values size is a hard part as String character may be
> > > encoded
> > > > > into
> > > > > > 1-4 bytes depending on Charset.
> > > > > >
> > > > > > Usually, a user don't want to care about Column length limitation
> > and
> > > > > chars
> > > > > > collation.
> > > > > > So, we can expect a Java default behavior will be used in most
> > cases:
> > > > > > 'unlimited' string size with up to 4-bytes characters support.
> > > > > >
> > > > > > Possible strategies
> > > > > > 3.1 Introduce 'Collation' for string and validate all the chars
> on
> > > row
> > > > > > assembling and rely on the user limited column length.
> > > > > > Thus, we can use varlen limits (+ collation for strings) to
> > estimate
> > > > row
> > > > > > size and pre-calculate offset_size to keep it within the schema.
> > > > > > 3.2 Introduce more row flags for different offset sizes (byte,
> > short,
> > > > > int)
> > > > > > and calculate row size right before assembling for choosing
> > > appropriate
> > > > > > offset_size.
> > > > > > Heuristics for strings using collation is also applicable here
> and
> > > keep
> > > > > > algorithm complexity independent from the data length, but the
> > schema
> > > > > only.
> > > > > >
> > > > > > I like an approach '3.2' because we already estimate row size.
> > > > > > Any thoughts?
> > > > > >
> > > > > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > > > > >
> > > > > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > > > > andrey.mashenkov@gmail.com>
> > > > > > wrote:
> > > > > >
> > > > > > > Igniters,
> > > > > > > I've prepared PR [1] with Public Table API for final review.
> > > > > > >
> > > > > > > Main points
> > > > > > > There are 4 projection interfaces over Table for different
> > > use-cases
> > > > > > > (Plain record vs Key-Value and POJO vs Binary object) declaring
> > > > > > synchronous
> > > > > > > and asynchronous methods.
> > > > > > > Async method returns IgniteFuture as there is no consensus on
> > > > > > IgniteFuture
> > > > > > > vs JDK CompletableFuture yet.
> > > > > > > API implementation is incomplete, it just an example of how it
> > > could
> > > > be
> > > > > > > done and will be implemented in future tasks.
> > > > > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is
> > > just a
> > > > > > > dictionary representing a subset of columns, while Row is a
> > > > > schema-aware
> > > > > > > object containing key and value columns respectively to the
> data
> > > > > layout.
> > > > > > >
> > > > > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> > > > ptupitsyn@apache.org>
> > > > > > > wrote:
> > > > > > >
> > > > > > >> I see, thanks.
> > > > > > >>
> > > > > > >> Let's discuss the return type - Future is not the one to use.
> > > > > > >> We should return CompletionStage, CompletableFuture, or
> > introduce
> > > > our
> > > > > > own
> > > > > > >> interface.
> > > > > > >> We agreed on the last one (custom interface) for thin clients:
> > > > > > >>
> > > > > > >>
> > > > > >
> > > > >
> > > >
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > > > > >>
> > > > > > >> I believe that for Ignite 3.0 we should have the following:
> > > > > > >> public interface IgniteFuture<T> extends Future<T>,
> > > > > CompletionStage<T> {
> > > > > > >>     // No-op.
> > > > > > >> }
> > > > > > >>
> > > > > > >> Thoughts?
> > > > > > >>
> > > > > > >>
> > > > > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > > > > >> andrey.mashenkov@gmail.com> wrote:
> > > > > > >>
> > > > > > >> > Pavel,
> > > > > > >> > There are 2 PR's for the ticket[1] with two different APIs
> > > > > suggested.
> > > > > > >> > Please, take a look at PR [2].
> > > > > > >> >
> > > > > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > > > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > > > > >> >
> > > > > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > > > > ptupitsyn@apache.org
> > > > > > >
> > > > > > >> > wrote:
> > > > > > >> >
> > > > > > >> > > Andrey, I can't find any async methods,
> > > > > > >> > > can you please check if the changes are pushed?
> > > > > > >> > >
> > > > > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > > > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > > > > >> > >
> > > > > > >> > > > Pavel, good point.
> > > > > > >> > > > Thanks. I've added async methods.
> > > > > > >> > > >
> > > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > > >> ptupitsyn@apache.org>
> > > > > > >> > > > wrote:
> > > > > > >> > > >
> > > > > > >> > > > > Andrey,
> > > > > > >> > > > >
> > > > > > >> > > > > What about corresponding async APIs, do we add them
> now
> > or
> > > > > > later?
> > > > > > >> > > > >
> > > > > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > > > >> > > > > andrey.mashenkov@gmail.com>
> > > > > > >> > > > > wrote:
> > > > > > >> > > > >
> > > > > > >> > > > > > Hi Igniters.
> > > > > > >> > > > > >
> > > > > > >> > > > > > I've created a PR for Table access API [1].
> > > > > > >> > > > > > This is an initial version. So, any
> > > suggestions\objections
> > > > > are
> > > > > > >> > > > welcomed.
> > > > > > >> > > > > > Please, do not hesitate to write your comments
> and\or
> > > > > examples
> > > > > > >> to
> > > > > > >> > the
> > > > > > >> > > > PR.
> > > > > > >> > > > > >
> > > > > > >> > > > > > Ignite-api module contains API classes, e.g.
> TableView
> > > > > classes
> > > > > > >> as
> > > > > > >> > > > > > projections for a table for different purposes.
> > > > > > >> > > > > > Ignite-table contains dummy implementation and
> Example
> > > > class
> > > > > > >> > > explained
> > > > > > >> > > > > how
> > > > > > >> > > > > > it is supposed to be used.
> > > > > > >> > > > > >
> > > > > > >> > > > > >
> > > > > > >> > > > > > Also, I'm still waiting for any feedback for Schema
> > > > > > >> configuration
> > > > > > >> > > > public
> > > > > > >> > > > > > API PR [2].
> > > > > > >> > > > > >
> > > > > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > > > >> > > > > >
> > > > > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > > > > >> > > <
> > > > > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > > > >> > > > > <
> > > > > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > > >> > > > > > >> >> > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > > > >> > > > > > >> >> > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> ptupitsyn@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.mashenkov@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > vololo100@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
> > > > > > >> > > > > > >> >> > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> vololo100@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.kulichenko@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > > vololo100@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > dmagda@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.kulichenko@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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > dmagda@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.kulichenko@gmail.com
> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> Igniters,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > One
> > > > > > >> > > > > > of
> > > > > > >> > > > > > >> the
> > > > > > >> > > > > > >> >> > big
> > > > > > >> > > > > > >> >> > > > > > changes
> > > > > > >> > > > > > >> >> > > > > > > > > > proposed
> > > > > > >> > > > > > >> >> > > > > > > > > > > > for
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > > > > >> so-called
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> "schema-first
> > > > > > >> > > > > > >> >> > > > > > > approach".
> > > > > > >> > > > > > >> >> > > > > > > > To
> > > > > > >> > > > > > >> >> > > > > > > > > > add
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > started
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> writing
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > the
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >> >
> > > > > > >> > > IEP
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > for
> > > > > > >> > > > > > >> this
> > > > > > >> > > > > > >> >> > > change:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > >
> > > > > > >> > > > > > >> >> > > > > >
> > > > > > >> > > > > > >> >> > > > >
> > > > > > >> > > > > > >> >> > > >
> > > > > > >> > > > > > >> >> > >
> > > > > > >> > > > > > >> >> >
> > > > > > >> > > > > > >> >>
> > > > > > >> > > > > > >>
> > > > > > >> > > > > >
> > > > > > >> > > > >
> > > > > > >> > > >
> > > > > > >> > >
> > > > > > >> >
> > > > > > >>
> > > > > >
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > Please
> > > > > > >> > > > > > >> >> take a
> > > > > > >> > > > > > >> >> > > > look
> > > > > > >> > > > > > >> >> > > > > > and
> > > > > > >> > > > > > >> >> > > > > > > > let
> > > > > > >> > > > > > >> >> > > > > > > > > me
> > > > > > >> > > > > > >> >> > > > > > > > > > > > know
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > immediate
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> thoughts,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> suggestions,
> > > > > > >> > > > > > >> >> > or
> > > > > > >> > > > > > >> >> > > > > > > > objections.
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > -Val
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> Best
> > > > > > >> > > > > > regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> Ivan
> > > > > > >> > > > > > Pavlukhin
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > Best
> > > > > > >> > > > regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > Ivan
> > > > > > >> > > > > Pavlukhin
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> Best
> > > > > > regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> Ivan
> > > > > > Pavlukhin
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best
> > > > > regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> Andrey
> > > V.
> > > > > > >> Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best
> > > regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey
> V.
> > > > > > Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V.
> > Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > --
> > > > > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > > > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > >
> > > > > > >> > > > > > >> >> > > > > >
> > > > > > >> > > > > > >> >> > > > >
> > > > > > >> > > > > > >> >> > > > >
> > > > > > >> > > > > > >> >> > > > > --
> > > > > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > > >> > > > > > >> >> > > > >
> > > > > > >> > > > > > >> >> > > >
> > > > > > >> > > > > > >> >> > > >
> > > > > > >> > > > > > >> >> > > > --
> > > > > > >> > > > > > >> >> > > > Best regards,
> > > > > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > > > >> > > > > > >> >> > > >
> > > > > > >> > > > > > >> >> > >
> > > > > > >> > > > > > >> >> >
> > > > > > >> > > > > > >> >>
> > > > > > >> > > > > > >> >
> > > > > > >> > > > > > >>
> > > > > > >> > > > > > >
> > > > > > >> > > > > > >
> > > > > > >> > > > > > > --
> > > > > > >> > > > > > > Best regards,
> > > > > > >> > > > > > > Andrey V. Mashenkov
> > > > > > >> > > > > > >
> > > > > > >> > > > > >
> > > > > > >> > > > > >
> > > > > > >> > > > > > --
> > > > > > >> > > > > > Best regards,
> > > > > > >> > > > > > Andrey V. Mashenkov
> > > > > > >> > > > > >
> > > > > > >> > > > >
> > > > > > >> > > >
> > > > > > >> > > >
> > > > > > >> > > > --
> > > > > > >> > > > Best regards,
> > > > > > >> > > > Andrey V. Mashenkov
> > > > > > >> > > >
> > > > > > >> > >
> > > > > > >> >
> > > > > > >> >
> > > > > > >> > --
> > > > > > >> > 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

Re: IEP-54: Schema-first approach for 3.0

[Ilya Kasnacheev <il...@gmail.com>]

Hello!

If we have determined that next varstring is too long to fit in 1-2 bytes
index, we can re-pack the whole object from scratch with 2-4 bytes index.

Such as:

We write all fixlen fields in the beginning.
We start to write first varlen string. Accumulated len is <255 so we use
single byte length
We start to write second varlen string. Accumulated len is now >255 but
<64k so we re-pack the first varlen string with 2 byte length also.
We start to write third varlen (let's say it's byte[] blob). Accumulated
len is suddenly >64k so we re-pack already written varlen fields to use 4
byte lengths/offsets.

The overhead here is not as great as you could expect. When reading, we
already know total varlen fields section length so we also know how many
bytes size offsets take.

Regards,

-- 
Ilya Kasnacheev


вт, 25 мая 2021 г. в 16:40, Andrey Mashenkov <an...@gmail.com>:

> >
> > I never said that you can predict string size.
>
> You suggest to use offsets use 1-2-4 bytes based on overall varlen section
> size.
> Actually, we can't predict varlen section size if a string column defined
> before serializing strings.
>
> Do you suggest use the smallest possible offset size if no columns of
> string type are defined,
> but fallback to 4-byte if a string column goes into play?
>
> On Thu, May 20, 2021 at 6:59 PM Ilya Kasnacheev <ilya.kasnacheev@gmail.com
> >
> wrote:
>
> > Hello!
> >
> > I never said that you can predict string size. Strings are definitely
> > varlen. You don't know string length when looking at object schema, I
> don't
> > even see why char-to-byte mapping is relevant here.
> >
> > What do you think about the approach where offsets use 1-2-4 bytes based
> on
> > overall varlen section size, which is known in advance as I assume?
> >
> > With compression, some optimizations may be possible since you can
> compress
> > blocks of data and then concatenate these compressed fragments. So you
> can
> > say that "I want 40-th byte of 3rd fragment" but it sounds like an
> overkill
> > mostly.
> >
> > Regards,
> > --
> > Ilya Kasnacheev
> >
> >
> > чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <andrey.mashenkov@gmail.com
> >:
> >
> > > Hi Ilya,
> > >
> > > Not yet, we can't predict string size [1] as a character may be encoded
> > in
> > > 1-4 bytes.
> > > So, we could either use a heuristic or serialize every string into an
> > array
> > > at first then assemble a row and copy the array into the row buffer.
> > >
> > > Good point, we can skip vartable for the first varlen field.
> > > We have a similar ticket [2] for the case with a single varlen. I'll
> fix
> > > the description to omit a first varlen offset.
> > >
> > > Agree, compression looks tricky and ineffective in this case.
> > >
> > > [1]
> > >
> > >
> >
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> > > [2] https://issues.apache.org/jira/browse/IGNITE-14746
> > >
> > > On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <
> > ilya.kasnacheev@gmail.com
> > > >
> > > wrote:
> > >
> > > > Hello!
> > > >
> > > > How about:
> > > >
> > > > First, all fields for which we know their specific order and size go,
> > > such
> > > > as byte, short, int, long, boolean. This means that any short field
> > will
> > > > take just 2 bytes with no padding.
> > > > Then, all var-len fields go, such as nested object, strings, etc.
> > > >
> > > > After that, we know total object size already, right?
> > > > If size <= 256, then all offsets are 1 byte unsigned.
> > > > If size < 65k, then all offsets are 2 byte.
> > > > Else, all offsets are 4 byte.
> > > >
> > > > We can count offsets starting from the first byle after constant
> fields
> > > > section and offsets section.
> > > > For the first varlen field, the offset is always 0, so we may skip
> this
> > > one
> > > > and start with offset of the second var field.
> > > >
> > > > For compression it is trickier. I suggest not having any explicit
> > support
> > > > for compression right here, so that later on compression may use a
> > > > different object layout to be more efficient.
> > > >
> > > > Regards,
> > > > --
> > > > Ilya Kasnacheev
> > > >
> > > >
> > > > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <
> > andrey.mashenkov@gmail.com
> > > >:
> > > >
> > > > > Hi Igniters,
> > > > >
> > > > > I've create a ticket [1] for large row support.
> > > > >
> > > > > We use 2-bytes offsets for varlen fields that are supposed to be
> > large
> > > > > enough.
> > > > > AFAIK, some users use multi-MB values and 64k per Row looks like a
> > > strong
> > > > > limitation.
> > > > >
> > > > > So, we have either to increase offset_size up to 4-bytes or use
> some
> > > > > advanced mechanics for compression or adaptive offset_size.
> > > > >
> > > > > 1. Increasing offset size may add overhead for keys like next:
> > > > > class Key {
> > > > >    int id;
> > > > >    String str; // Some short string code.
> > > > > }
> > > > >
> > > > > 2. Compression will require table to be decompressed on every
> varlen
> > > > column
> > > > > access, e.g. for comparison purposes while index scan.
> > > > > Also, we may need to pre-calculate compressed table size to avoid
> > > buffer
> > > > > copying (shrinking or extending) during row assembling.
> > > > >
> > > > > 3. Adaptive offset_size implies row size estimation.
> > > > > We already do to reduce the probability of buffer expanding, but we
> > > need
> > > > a
> > > > > high margin for this purpose.
> > > > > 'String' values size is a hard part as String character may be
> > encoded
> > > > into
> > > > > 1-4 bytes depending on Charset.
> > > > >
> > > > > Usually, a user don't want to care about Column length limitation
> and
> > > > chars
> > > > > collation.
> > > > > So, we can expect a Java default behavior will be used in most
> cases:
> > > > > 'unlimited' string size with up to 4-bytes characters support.
> > > > >
> > > > > Possible strategies
> > > > > 3.1 Introduce 'Collation' for string and validate all the chars on
> > row
> > > > > assembling and rely on the user limited column length.
> > > > > Thus, we can use varlen limits (+ collation for strings) to
> estimate
> > > row
> > > > > size and pre-calculate offset_size to keep it within the schema.
> > > > > 3.2 Introduce more row flags for different offset sizes (byte,
> short,
> > > > int)
> > > > > and calculate row size right before assembling for choosing
> > appropriate
> > > > > offset_size.
> > > > > Heuristics for strings using collation is also applicable here and
> > keep
> > > > > algorithm complexity independent from the data length, but the
> schema
> > > > only.
> > > > >
> > > > > I like an approach '3.2' because we already estimate row size.
> > > > > Any thoughts?
> > > > >
> > > > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > > > >
> > > > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > > > andrey.mashenkov@gmail.com>
> > > > > wrote:
> > > > >
> > > > > > Igniters,
> > > > > > I've prepared PR [1] with Public Table API for final review.
> > > > > >
> > > > > > Main points
> > > > > > There are 4 projection interfaces over Table for different
> > use-cases
> > > > > > (Plain record vs Key-Value and POJO vs Binary object) declaring
> > > > > synchronous
> > > > > > and asynchronous methods.
> > > > > > Async method returns IgniteFuture as there is no consensus on
> > > > > IgniteFuture
> > > > > > vs JDK CompletableFuture yet.
> > > > > > API implementation is incomplete, it just an example of how it
> > could
> > > be
> > > > > > done and will be implemented in future tasks.
> > > > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is
> > just a
> > > > > > dictionary representing a subset of columns, while Row is a
> > > > schema-aware
> > > > > > object containing key and value columns respectively to the data
> > > > layout.
> > > > > >
> > > > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> > > ptupitsyn@apache.org>
> > > > > > wrote:
> > > > > >
> > > > > >> I see, thanks.
> > > > > >>
> > > > > >> Let's discuss the return type - Future is not the one to use.
> > > > > >> We should return CompletionStage, CompletableFuture, or
> introduce
> > > our
> > > > > own
> > > > > >> interface.
> > > > > >> We agreed on the last one (custom interface) for thin clients:
> > > > > >>
> > > > > >>
> > > > >
> > > >
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > > > >>
> > > > > >> I believe that for Ignite 3.0 we should have the following:
> > > > > >> public interface IgniteFuture<T> extends Future<T>,
> > > > CompletionStage<T> {
> > > > > >>     // No-op.
> > > > > >> }
> > > > > >>
> > > > > >> Thoughts?
> > > > > >>
> > > > > >>
> > > > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > > > >> andrey.mashenkov@gmail.com> wrote:
> > > > > >>
> > > > > >> > Pavel,
> > > > > >> > There are 2 PR's for the ticket[1] with two different APIs
> > > > suggested.
> > > > > >> > Please, take a look at PR [2].
> > > > > >> >
> > > > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > > > >> >
> > > > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > > > ptupitsyn@apache.org
> > > > > >
> > > > > >> > wrote:
> > > > > >> >
> > > > > >> > > Andrey, I can't find any async methods,
> > > > > >> > > can you please check if the changes are pushed?
> > > > > >> > >
> > > > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > > > >> > >
> > > > > >> > > > Pavel, good point.
> > > > > >> > > > Thanks. I've added async methods.
> > > > > >> > > >
> > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > >> ptupitsyn@apache.org>
> > > > > >> > > > wrote:
> > > > > >> > > >
> > > > > >> > > > > Andrey,
> > > > > >> > > > >
> > > > > >> > > > > What about corresponding async APIs, do we add them now
> or
> > > > > later?
> > > > > >> > > > >
> > > > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > > >> > > > > andrey.mashenkov@gmail.com>
> > > > > >> > > > > wrote:
> > > > > >> > > > >
> > > > > >> > > > > > Hi Igniters.
> > > > > >> > > > > >
> > > > > >> > > > > > I've created a PR for Table access API [1].
> > > > > >> > > > > > This is an initial version. So, any
> > suggestions\objections
> > > > are
> > > > > >> > > > welcomed.
> > > > > >> > > > > > Please, do not hesitate to write your comments and\or
> > > > examples
> > > > > >> to
> > > > > >> > the
> > > > > >> > > > PR.
> > > > > >> > > > > >
> > > > > >> > > > > > Ignite-api module contains API classes, e.g. TableView
> > > > classes
> > > > > >> as
> > > > > >> > > > > > projections for a table for different purposes.
> > > > > >> > > > > > Ignite-table contains dummy implementation and Example
> > > class
> > > > > >> > > explained
> > > > > >> > > > > how
> > > > > >> > > > > > it is supposed to be used.
> > > > > >> > > > > >
> > > > > >> > > > > >
> > > > > >> > > > > > Also, I'm still waiting for any feedback for Schema
> > > > > >> configuration
> > > > > >> > > > public
> > > > > >> > > > > > API PR [2].
> > > > > >> > > > > >
> > > > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > > >> > > > > >
> > > > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > > > >> > > <
> > > > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > > >> > > > > <
> > > > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > >> > > > > > >> >> > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > > >> > > > > > >> >> > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > >> > > > > > >> >> > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > vololo100@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
> > > > > >> > > > > > >> >> > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> vololo100@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.kulichenko@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > > vololo100@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > dmagda@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.kulichenko@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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > dmagda@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.kulichenko@gmail.com>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> Igniters,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > One
> > > > > >> > > > > > of
> > > > > >> > > > > > >> the
> > > > > >> > > > > > >> >> > big
> > > > > >> > > > > > >> >> > > > > > changes
> > > > > >> > > > > > >> >> > > > > > > > > > proposed
> > > > > >> > > > > > >> >> > > > > > > > > > > > for
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > > > > >> so-called
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> "schema-first
> > > > > >> > > > > > >> >> > > > > > > approach".
> > > > > >> > > > > > >> >> > > > > > > > To
> > > > > >> > > > > > >> >> > > > > > > > > > add
> > > > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > started
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> writing
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > the
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >> >
> > > > > >> > > IEP
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > for
> > > > > >> > > > > > >> this
> > > > > >> > > > > > >> >> > > change:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > >
> > > > > >> > > > > > >> >> > > > > > >
> > > > > >> > > > > > >> >> > > > > >
> > > > > >> > > > > > >> >> > > > >
> > > > > >> > > > > > >> >> > > >
> > > > > >> > > > > > >> >> > >
> > > > > >> > > > > > >> >> >
> > > > > >> > > > > > >> >>
> > > > > >> > > > > > >>
> > > > > >> > > > > >
> > > > > >> > > > >
> > > > > >> > > >
> > > > > >> > >
> > > > > >> >
> > > > > >>
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > Please
> > > > > >> > > > > > >> >> take a
> > > > > >> > > > > > >> >> > > > look
> > > > > >> > > > > > >> >> > > > > > and
> > > > > >> > > > > > >> >> > > > > > > > let
> > > > > >> > > > > > >> >> > > > > > > > > me
> > > > > >> > > > > > >> >> > > > > > > > > > > > know
> > > > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > immediate
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> thoughts,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> suggestions,
> > > > > >> > > > > > >> >> > or
> > > > > >> > > > > > >> >> > > > > > > > objections.
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > -Val
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> Best
> > > > > >> > > > > > regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> Ivan
> > > > > >> > > > > > Pavlukhin
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > Best
> > > > > >> > > > regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > Ivan
> > > > > >> > > > > Pavlukhin
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best
> > > > > regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan
> > > > > Pavlukhin
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best
> > > > regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey
> > V.
> > > > > >> Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best
> > regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V.
> > > > > Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V.
> Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > --
> > > > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > >
> > > > > >> > > > > > >> >> > > > > > >
> > > > > >> > > > > > >> >> > > > > >
> > > > > >> > > > > > >> >> > > > >
> > > > > >> > > > > > >> >> > > > >
> > > > > >> > > > > > >> >> > > > > --
> > > > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > >> > > > > > >> >> > > > >
> > > > > >> > > > > > >> >> > > >
> > > > > >> > > > > > >> >> > > >
> > > > > >> > > > > > >> >> > > > --
> > > > > >> > > > > > >> >> > > > Best regards,
> > > > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > > >> > > > > > >> >> > > >
> > > > > >> > > > > > >> >> > >
> > > > > >> > > > > > >> >> >
> > > > > >> > > > > > >> >>
> > > > > >> > > > > > >> >
> > > > > >> > > > > > >>
> > > > > >> > > > > > >
> > > > > >> > > > > > >
> > > > > >> > > > > > > --
> > > > > >> > > > > > > Best regards,
> > > > > >> > > > > > > Andrey V. Mashenkov
> > > > > >> > > > > > >
> > > > > >> > > > > >
> > > > > >> > > > > >
> > > > > >> > > > > > --
> > > > > >> > > > > > Best regards,
> > > > > >> > > > > > Andrey V. Mashenkov
> > > > > >> > > > > >
> > > > > >> > > > >
> > > > > >> > > >
> > > > > >> > > >
> > > > > >> > > > --
> > > > > >> > > > Best regards,
> > > > > >> > > > Andrey V. Mashenkov
> > > > > >> > > >
> > > > > >> > >
> > > > > >> >
> > > > > >> >
> > > > > >> > --
> > > > > >> > 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
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

>
> I never said that you can predict string size.

You suggest to use offsets use 1-2-4 bytes based on overall varlen section
size.
Actually, we can't predict varlen section size if a string column defined
before serializing strings.

Do you suggest use the smallest possible offset size if no columns of
string type are defined,
but fallback to 4-byte if a string column goes into play?

On Thu, May 20, 2021 at 6:59 PM Ilya Kasnacheev <il...@gmail.com>
wrote:

> Hello!
>
> I never said that you can predict string size. Strings are definitely
> varlen. You don't know string length when looking at object schema, I don't
> even see why char-to-byte mapping is relevant here.
>
> What do you think about the approach where offsets use 1-2-4 bytes based on
> overall varlen section size, which is known in advance as I assume?
>
> With compression, some optimizations may be possible since you can compress
> blocks of data and then concatenate these compressed fragments. So you can
> say that "I want 40-th byte of 3rd fragment" but it sounds like an overkill
> mostly.
>
> Regards,
> --
> Ilya Kasnacheev
>
>
> чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <an...@gmail.com>:
>
> > Hi Ilya,
> >
> > Not yet, we can't predict string size [1] as a character may be encoded
> in
> > 1-4 bytes.
> > So, we could either use a heuristic or serialize every string into an
> array
> > at first then assemble a row and copy the array into the row buffer.
> >
> > Good point, we can skip vartable for the first varlen field.
> > We have a similar ticket [2] for the case with a single varlen. I'll fix
> > the description to omit a first varlen offset.
> >
> > Agree, compression looks tricky and ineffective in this case.
> >
> > [1]
> >
> >
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> > [2] https://issues.apache.org/jira/browse/IGNITE-14746
> >
> > On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <
> ilya.kasnacheev@gmail.com
> > >
> > wrote:
> >
> > > Hello!
> > >
> > > How about:
> > >
> > > First, all fields for which we know their specific order and size go,
> > such
> > > as byte, short, int, long, boolean. This means that any short field
> will
> > > take just 2 bytes with no padding.
> > > Then, all var-len fields go, such as nested object, strings, etc.
> > >
> > > After that, we know total object size already, right?
> > > If size <= 256, then all offsets are 1 byte unsigned.
> > > If size < 65k, then all offsets are 2 byte.
> > > Else, all offsets are 4 byte.
> > >
> > > We can count offsets starting from the first byle after constant fields
> > > section and offsets section.
> > > For the first varlen field, the offset is always 0, so we may skip this
> > one
> > > and start with offset of the second var field.
> > >
> > > For compression it is trickier. I suggest not having any explicit
> support
> > > for compression right here, so that later on compression may use a
> > > different object layout to be more efficient.
> > >
> > > Regards,
> > > --
> > > Ilya Kasnacheev
> > >
> > >
> > > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <
> andrey.mashenkov@gmail.com
> > >:
> > >
> > > > Hi Igniters,
> > > >
> > > > I've create a ticket [1] for large row support.
> > > >
> > > > We use 2-bytes offsets for varlen fields that are supposed to be
> large
> > > > enough.
> > > > AFAIK, some users use multi-MB values and 64k per Row looks like a
> > strong
> > > > limitation.
> > > >
> > > > So, we have either to increase offset_size up to 4-bytes or use some
> > > > advanced mechanics for compression or adaptive offset_size.
> > > >
> > > > 1. Increasing offset size may add overhead for keys like next:
> > > > class Key {
> > > >    int id;
> > > >    String str; // Some short string code.
> > > > }
> > > >
> > > > 2. Compression will require table to be decompressed on every varlen
> > > column
> > > > access, e.g. for comparison purposes while index scan.
> > > > Also, we may need to pre-calculate compressed table size to avoid
> > buffer
> > > > copying (shrinking or extending) during row assembling.
> > > >
> > > > 3. Adaptive offset_size implies row size estimation.
> > > > We already do to reduce the probability of buffer expanding, but we
> > need
> > > a
> > > > high margin for this purpose.
> > > > 'String' values size is a hard part as String character may be
> encoded
> > > into
> > > > 1-4 bytes depending on Charset.
> > > >
> > > > Usually, a user don't want to care about Column length limitation and
> > > chars
> > > > collation.
> > > > So, we can expect a Java default behavior will be used in most cases:
> > > > 'unlimited' string size with up to 4-bytes characters support.
> > > >
> > > > Possible strategies
> > > > 3.1 Introduce 'Collation' for string and validate all the chars on
> row
> > > > assembling and rely on the user limited column length.
> > > > Thus, we can use varlen limits (+ collation for strings) to estimate
> > row
> > > > size and pre-calculate offset_size to keep it within the schema.
> > > > 3.2 Introduce more row flags for different offset sizes (byte, short,
> > > int)
> > > > and calculate row size right before assembling for choosing
> appropriate
> > > > offset_size.
> > > > Heuristics for strings using collation is also applicable here and
> keep
> > > > algorithm complexity independent from the data length, but the schema
> > > only.
> > > >
> > > > I like an approach '3.2' because we already estimate row size.
> > > > Any thoughts?
> > > >
> > > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > > >
> > > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > > andrey.mashenkov@gmail.com>
> > > > wrote:
> > > >
> > > > > Igniters,
> > > > > I've prepared PR [1] with Public Table API for final review.
> > > > >
> > > > > Main points
> > > > > There are 4 projection interfaces over Table for different
> use-cases
> > > > > (Plain record vs Key-Value and POJO vs Binary object) declaring
> > > > synchronous
> > > > > and asynchronous methods.
> > > > > Async method returns IgniteFuture as there is no consensus on
> > > > IgniteFuture
> > > > > vs JDK CompletableFuture yet.
> > > > > API implementation is incomplete, it just an example of how it
> could
> > be
> > > > > done and will be implemented in future tasks.
> > > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is
> just a
> > > > > dictionary representing a subset of columns, while Row is a
> > > schema-aware
> > > > > object containing key and value columns respectively to the data
> > > layout.
> > > > >
> > > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> > ptupitsyn@apache.org>
> > > > > wrote:
> > > > >
> > > > >> I see, thanks.
> > > > >>
> > > > >> Let's discuss the return type - Future is not the one to use.
> > > > >> We should return CompletionStage, CompletableFuture, or introduce
> > our
> > > > own
> > > > >> interface.
> > > > >> We agreed on the last one (custom interface) for thin clients:
> > > > >>
> > > > >>
> > > >
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > > >>
> > > > >> I believe that for Ignite 3.0 we should have the following:
> > > > >> public interface IgniteFuture<T> extends Future<T>,
> > > CompletionStage<T> {
> > > > >>     // No-op.
> > > > >> }
> > > > >>
> > > > >> Thoughts?
> > > > >>
> > > > >>
> > > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > > >> andrey.mashenkov@gmail.com> wrote:
> > > > >>
> > > > >> > Pavel,
> > > > >> > There are 2 PR's for the ticket[1] with two different APIs
> > > suggested.
> > > > >> > Please, take a look at PR [2].
> > > > >> >
> > > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > > >> >
> > > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > > ptupitsyn@apache.org
> > > > >
> > > > >> > wrote:
> > > > >> >
> > > > >> > > Andrey, I can't find any async methods,
> > > > >> > > can you please check if the changes are pushed?
> > > > >> > >
> > > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > > >> > >
> > > > >> > > > Pavel, good point.
> > > > >> > > > Thanks. I've added async methods.
> > > > >> > > >
> > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > >> ptupitsyn@apache.org>
> > > > >> > > > wrote:
> > > > >> > > >
> > > > >> > > > > Andrey,
> > > > >> > > > >
> > > > >> > > > > What about corresponding async APIs, do we add them now or
> > > > later?
> > > > >> > > > >
> > > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > >> > > > > andrey.mashenkov@gmail.com>
> > > > >> > > > > wrote:
> > > > >> > > > >
> > > > >> > > > > > Hi Igniters.
> > > > >> > > > > >
> > > > >> > > > > > I've created a PR for Table access API [1].
> > > > >> > > > > > This is an initial version. So, any
> suggestions\objections
> > > are
> > > > >> > > > welcomed.
> > > > >> > > > > > Please, do not hesitate to write your comments and\or
> > > examples
> > > > >> to
> > > > >> > the
> > > > >> > > > PR.
> > > > >> > > > > >
> > > > >> > > > > > Ignite-api module contains API classes, e.g. TableView
> > > classes
> > > > >> as
> > > > >> > > > > > projections for a table for different purposes.
> > > > >> > > > > > Ignite-table contains dummy implementation and Example
> > class
> > > > >> > > explained
> > > > >> > > > > how
> > > > >> > > > > > it is supposed to be used.
> > > > >> > > > > >
> > > > >> > > > > >
> > > > >> > > > > > Also, I'm still waiting for any feedback for Schema
> > > > >> configuration
> > > > >> > > > public
> > > > >> > > > > > API PR [2].
> > > > >> > > > > >
> > > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > >> > > > > >
> > > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > > >> > > <
> > > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > >> > > > > <
> > > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > >> > > > > > >> >> > <
> > > > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > >> > > > > > >> >> > > > <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > >> > > > > > >> >> > > > > > > > <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > vololo100@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
> > > > >> > > > > > >> >> > > > > <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > >> vololo100@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.kulichenko@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> > > > > vololo100@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > dmagda@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.kulichenko@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 <
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> > > > dmagda@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.kulichenko@gmail.com>
> > > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> Igniters,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > One
> > > > >> > > > > > of
> > > > >> > > > > > >> the
> > > > >> > > > > > >> >> > big
> > > > >> > > > > > >> >> > > > > > changes
> > > > >> > > > > > >> >> > > > > > > > > > proposed
> > > > >> > > > > > >> >> > > > > > > > > > > > for
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > >> so-called
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> "schema-first
> > > > >> > > > > > >> >> > > > > > > approach".
> > > > >> > > > > > >> >> > > > > > > > To
> > > > >> > > > > > >> >> > > > > > > > > > add
> > > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > started
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> writing
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > the
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >> >
> > > > >> > > IEP
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > for
> > > > >> > > > > > >> this
> > > > >> > > > > > >> >> > > change:
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > >
> > > > >> > > > > > >> >> > > > > > >
> > > > >> > > > > > >> >> > > > > >
> > > > >> > > > > > >> >> > > > >
> > > > >> > > > > > >> >> > > >
> > > > >> > > > > > >> >> > >
> > > > >> > > > > > >> >> >
> > > > >> > > > > > >> >>
> > > > >> > > > > > >>
> > > > >> > > > > >
> > > > >> > > > >
> > > > >> > > >
> > > > >> > >
> > > > >> >
> > > > >>
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > Please
> > > > >> > > > > > >> >> take a
> > > > >> > > > > > >> >> > > > look
> > > > >> > > > > > >> >> > > > > > and
> > > > >> > > > > > >> >> > > > > > > > let
> > > > >> > > > > > >> >> > > > > > > > > me
> > > > >> > > > > > >> >> > > > > > > > > > > > know
> > > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > immediate
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> thoughts,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> suggestions,
> > > > >> > > > > > >> >> > or
> > > > >> > > > > > >> >> > > > > > > > objections.
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > -Val
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> Best
> > > > >> > > > > > regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> Ivan
> > > > >> > > > > > Pavlukhin
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > Best
> > > > >> > > > regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > Ivan
> > > > >> > > > > Pavlukhin
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best
> > > > regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan
> > > > Pavlukhin
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best
> > > regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey
> V.
> > > > >> Mashenkov
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best
> regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V.
> > > > Mashenkov
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> > > > > > >> >> > > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > >> > > > > > >> >> > > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > > > --
> > > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > >> > > > > > >> >> > > > > > > > >
> > > > >> > > > > > >> >> > > > > > > >
> > > > >> > > > > > >> >> > > > > > >
> > > > >> > > > > > >> >> > > > > >
> > > > >> > > > > > >> >> > > > >
> > > > >> > > > > > >> >> > > > >
> > > > >> > > > > > >> >> > > > > --
> > > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > >> > > > > > >> >> > > > >
> > > > >> > > > > > >> >> > > >
> > > > >> > > > > > >> >> > > >
> > > > >> > > > > > >> >> > > > --
> > > > >> > > > > > >> >> > > > Best regards,
> > > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > >> > > > > > >> >> > > >
> > > > >> > > > > > >> >> > >
> > > > >> > > > > > >> >> >
> > > > >> > > > > > >> >>
> > > > >> > > > > > >> >
> > > > >> > > > > > >>
> > > > >> > > > > > >
> > > > >> > > > > > >
> > > > >> > > > > > > --
> > > > >> > > > > > > Best regards,
> > > > >> > > > > > > Andrey V. Mashenkov
> > > > >> > > > > > >
> > > > >> > > > > >
> > > > >> > > > > >
> > > > >> > > > > > --
> > > > >> > > > > > Best regards,
> > > > >> > > > > > Andrey V. Mashenkov
> > > > >> > > > > >
> > > > >> > > > >
> > > > >> > > >
> > > > >> > > >
> > > > >> > > > --
> > > > >> > > > Best regards,
> > > > >> > > > Andrey V. Mashenkov
> > > > >> > > >
> > > > >> > >
> > > > >> >
> > > > >> >
> > > > >> > --
> > > > >> > 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

Re: IEP-54: Schema-first approach for 3.0

[Ilya Kasnacheev <il...@gmail.com>]

Hello!

I never said that you can predict string size. Strings are definitely
varlen. You don't know string length when looking at object schema, I don't
even see why char-to-byte mapping is relevant here.

What do you think about the approach where offsets use 1-2-4 bytes based on
overall varlen section size, which is known in advance as I assume?

With compression, some optimizations may be possible since you can compress
blocks of data and then concatenate these compressed fragments. So you can
say that "I want 40-th byte of 3rd fragment" but it sounds like an overkill
mostly.

Regards,
-- 
Ilya Kasnacheev


чт, 20 мая 2021 г. в 18:23, Andrey Mashenkov <an...@gmail.com>:

> Hi Ilya,
>
> Not yet, we can't predict string size [1] as a character may be encoded in
> 1-4 bytes.
> So, we could either use a heuristic or serialize every string into an array
> at first then assemble a row and copy the array into the row buffer.
>
> Good point, we can skip vartable for the first varlen field.
> We have a similar ticket [2] for the case with a single varlen. I'll fix
> the description to omit a first varlen offset.
>
> Agree, compression looks tricky and ineffective in this case.
>
> [1]
>
> https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
> [2] https://issues.apache.org/jira/browse/IGNITE-14746
>
> On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <ilya.kasnacheev@gmail.com
> >
> wrote:
>
> > Hello!
> >
> > How about:
> >
> > First, all fields for which we know their specific order and size go,
> such
> > as byte, short, int, long, boolean. This means that any short field will
> > take just 2 bytes with no padding.
> > Then, all var-len fields go, such as nested object, strings, etc.
> >
> > After that, we know total object size already, right?
> > If size <= 256, then all offsets are 1 byte unsigned.
> > If size < 65k, then all offsets are 2 byte.
> > Else, all offsets are 4 byte.
> >
> > We can count offsets starting from the first byle after constant fields
> > section and offsets section.
> > For the first varlen field, the offset is always 0, so we may skip this
> one
> > and start with offset of the second var field.
> >
> > For compression it is trickier. I suggest not having any explicit support
> > for compression right here, so that later on compression may use a
> > different object layout to be more efficient.
> >
> > Regards,
> > --
> > Ilya Kasnacheev
> >
> >
> > ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <andrey.mashenkov@gmail.com
> >:
> >
> > > Hi Igniters,
> > >
> > > I've create a ticket [1] for large row support.
> > >
> > > We use 2-bytes offsets for varlen fields that are supposed to be large
> > > enough.
> > > AFAIK, some users use multi-MB values and 64k per Row looks like a
> strong
> > > limitation.
> > >
> > > So, we have either to increase offset_size up to 4-bytes or use some
> > > advanced mechanics for compression or adaptive offset_size.
> > >
> > > 1. Increasing offset size may add overhead for keys like next:
> > > class Key {
> > >    int id;
> > >    String str; // Some short string code.
> > > }
> > >
> > > 2. Compression will require table to be decompressed on every varlen
> > column
> > > access, e.g. for comparison purposes while index scan.
> > > Also, we may need to pre-calculate compressed table size to avoid
> buffer
> > > copying (shrinking or extending) during row assembling.
> > >
> > > 3. Adaptive offset_size implies row size estimation.
> > > We already do to reduce the probability of buffer expanding, but we
> need
> > a
> > > high margin for this purpose.
> > > 'String' values size is a hard part as String character may be encoded
> > into
> > > 1-4 bytes depending on Charset.
> > >
> > > Usually, a user don't want to care about Column length limitation and
> > chars
> > > collation.
> > > So, we can expect a Java default behavior will be used in most cases:
> > > 'unlimited' string size with up to 4-bytes characters support.
> > >
> > > Possible strategies
> > > 3.1 Introduce 'Collation' for string and validate all the chars on row
> > > assembling and rely on the user limited column length.
> > > Thus, we can use varlen limits (+ collation for strings) to estimate
> row
> > > size and pre-calculate offset_size to keep it within the schema.
> > > 3.2 Introduce more row flags for different offset sizes (byte, short,
> > int)
> > > and calculate row size right before assembling for choosing appropriate
> > > offset_size.
> > > Heuristics for strings using collation is also applicable here and keep
> > > algorithm complexity independent from the data length, but the schema
> > only.
> > >
> > > I like an approach '3.2' because we already estimate row size.
> > > Any thoughts?
> > >
> > > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> > >
> > > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > > andrey.mashenkov@gmail.com>
> > > wrote:
> > >
> > > > Igniters,
> > > > I've prepared PR [1] with Public Table API for final review.
> > > >
> > > > Main points
> > > > There are 4 projection interfaces over Table for different use-cases
> > > > (Plain record vs Key-Value and POJO vs Binary object) declaring
> > > synchronous
> > > > and asynchronous methods.
> > > > Async method returns IgniteFuture as there is no consensus on
> > > IgniteFuture
> > > > vs JDK CompletableFuture yet.
> > > > API implementation is incomplete, it just an example of how it could
> be
> > > > done and will be implemented in future tasks.
> > > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is just a
> > > > dictionary representing a subset of columns, while Row is a
> > schema-aware
> > > > object containing key and value columns respectively to the data
> > layout.
> > > >
> > > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <
> ptupitsyn@apache.org>
> > > > wrote:
> > > >
> > > >> I see, thanks.
> > > >>
> > > >> Let's discuss the return type - Future is not the one to use.
> > > >> We should return CompletionStage, CompletableFuture, or introduce
> our
> > > own
> > > >> interface.
> > > >> We agreed on the last one (custom interface) for thin clients:
> > > >>
> > > >>
> > >
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > > >>
> > > >> I believe that for Ignite 3.0 we should have the following:
> > > >> public interface IgniteFuture<T> extends Future<T>,
> > CompletionStage<T> {
> > > >>     // No-op.
> > > >> }
> > > >>
> > > >> Thoughts?
> > > >>
> > > >>
> > > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > > >> andrey.mashenkov@gmail.com> wrote:
> > > >>
> > > >> > Pavel,
> > > >> > There are 2 PR's for the ticket[1] with two different APIs
> > suggested.
> > > >> > Please, take a look at PR [2].
> > > >> >
> > > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > > >> > [2] https://github.com/apache/ignite-3/pull/69
> > > >> >
> > > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> > ptupitsyn@apache.org
> > > >
> > > >> > wrote:
> > > >> >
> > > >> > > Andrey, I can't find any async methods,
> > > >> > > can you please check if the changes are pushed?
> > > >> > >
> > > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > >> > > andrey.mashenkov@gmail.com> wrote:
> > > >> > >
> > > >> > > > Pavel, good point.
> > > >> > > > Thanks. I've added async methods.
> > > >> > > >
> > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > >> ptupitsyn@apache.org>
> > > >> > > > wrote:
> > > >> > > >
> > > >> > > > > Andrey,
> > > >> > > > >
> > > >> > > > > What about corresponding async APIs, do we add them now or
> > > later?
> > > >> > > > >
> > > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > >> > > > > andrey.mashenkov@gmail.com>
> > > >> > > > > wrote:
> > > >> > > > >
> > > >> > > > > > Hi Igniters.
> > > >> > > > > >
> > > >> > > > > > I've created a PR for Table access API [1].
> > > >> > > > > > This is an initial version. So, any suggestions\objections
> > are
> > > >> > > > welcomed.
> > > >> > > > > > Please, do not hesitate to write your comments and\or
> > examples
> > > >> to
> > > >> > the
> > > >> > > > PR.
> > > >> > > > > >
> > > >> > > > > > Ignite-api module contains API classes, e.g. TableView
> > classes
> > > >> as
> > > >> > > > > > projections for a table for different purposes.
> > > >> > > > > > Ignite-table contains dummy implementation and Example
> class
> > > >> > > explained
> > > >> > > > > how
> > > >> > > > > > it is supposed to be used.
> > > >> > > > > >
> > > >> > > > > >
> > > >> > > > > > Also, I'm still waiting for any feedback for Schema
> > > >> configuration
> > > >> > > > public
> > > >> > > > > > API PR [2].
> > > >> > > > > >
> > > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > >> > > > > >
> > > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > >> > > <
> > > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > >> > > > > <
> > > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > >> > > > > > >> >> > > > > > > isapego@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 <
> > > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > >> > > > > > >> >> > <
> > > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > > >> > > > > > >> >> > > > <
> > > >> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > >> > > > > > >> >> > > > > > > > <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> vololo100@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
> > > >> > > > > > >> >> > > > > <
> > > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > >> vololo100@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.kulichenko@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> > > > > vololo100@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > dmagda@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.kulichenko@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 <
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> > > > dmagda@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.kulichenko@gmail.com>
> > > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> Igniters,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > One
> > > >> > > > > > of
> > > >> > > > > > >> the
> > > >> > > > > > >> >> > big
> > > >> > > > > > >> >> > > > > > changes
> > > >> > > > > > >> >> > > > > > > > > > proposed
> > > >> > > > > > >> >> > > > > > > > > > > > for
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > >> so-called
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> "schema-first
> > > >> > > > > > >> >> > > > > > > approach".
> > > >> > > > > > >> >> > > > > > > > To
> > > >> > > > > > >> >> > > > > > > > > > add
> > > >> > > > > > >> >> > > > > > > > > > > > > more
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > started
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> writing
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > the
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >> >
> > > >> > > IEP
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > for
> > > >> > > > > > >> this
> > > >> > > > > > >> >> > > change:
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > >
> > > >> > > > > > >> >> > > > > > > >
> > > >> > > > > > >> >> > > > > > >
> > > >> > > > > > >> >> > > > > >
> > > >> > > > > > >> >> > > > >
> > > >> > > > > > >> >> > > >
> > > >> > > > > > >> >> > >
> > > >> > > > > > >> >> >
> > > >> > > > > > >> >>
> > > >> > > > > > >>
> > > >> > > > > >
> > > >> > > > >
> > > >> > > >
> > > >> > >
> > > >> >
> > > >>
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > Please
> > > >> > > > > > >> >> take a
> > > >> > > > > > >> >> > > > look
> > > >> > > > > > >> >> > > > > > and
> > > >> > > > > > >> >> > > > > > > > let
> > > >> > > > > > >> >> > > > > > > > > me
> > > >> > > > > > >> >> > > > > > > > > > > > know
> > > >> > > > > > >> >> > > > > > > > > > > > > if
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > immediate
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> thoughts,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> suggestions,
> > > >> > > > > > >> >> > or
> > > >> > > > > > >> >> > > > > > > > objections.
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > -Val
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> Best
> > > >> > > > > > regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> Ivan
> > > >> > > > > > Pavlukhin
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > Best
> > > >> > > > regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > Ivan
> > > >> > > > > Pavlukhin
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best
> > > regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan
> > > Pavlukhin
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best
> > regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V.
> > > >> Mashenkov
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V.
> > > Mashenkov
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> > > > > > >> >> > > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > >> > > > > > >> >> > > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > >
> > > >> > > > > > >> >> > > > > > > > > --
> > > >> > > > > > >> >> > > > > > > > > Best regards,
> > > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > >> > > > > > >> >> > > > > > > > >
> > > >> > > > > > >> >> > > > > > > >
> > > >> > > > > > >> >> > > > > > >
> > > >> > > > > > >> >> > > > > >
> > > >> > > > > > >> >> > > > >
> > > >> > > > > > >> >> > > > >
> > > >> > > > > > >> >> > > > > --
> > > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > >> > > > > > >> >> > > > >
> > > >> > > > > > >> >> > > >
> > > >> > > > > > >> >> > > >
> > > >> > > > > > >> >> > > > --
> > > >> > > > > > >> >> > > > Best regards,
> > > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > > >> > > > > > >> >> > > >
> > > >> > > > > > >> >> > >
> > > >> > > > > > >> >> >
> > > >> > > > > > >> >>
> > > >> > > > > > >> >
> > > >> > > > > > >>
> > > >> > > > > > >
> > > >> > > > > > >
> > > >> > > > > > > --
> > > >> > > > > > > Best regards,
> > > >> > > > > > > Andrey V. Mashenkov
> > > >> > > > > > >
> > > >> > > > > >
> > > >> > > > > >
> > > >> > > > > > --
> > > >> > > > > > Best regards,
> > > >> > > > > > Andrey V. Mashenkov
> > > >> > > > > >
> > > >> > > > >
> > > >> > > >
> > > >> > > >
> > > >> > > > --
> > > >> > > > Best regards,
> > > >> > > > Andrey V. Mashenkov
> > > >> > > >
> > > >> > >
> > > >> >
> > > >> >
> > > >> > --
> > > >> > Best regards,
> > > >> > Andrey V. Mashenkov
> > > >> >
> > > >>
> > > >
> > > >
> > > > --
> > > > Best regards,
> > > > Andrey V. Mashenkov
> > > >
> > >
> > >
> > > --
> > > Best regards,
> > > Andrey V. Mashenkov
> > >
> >
>
>
> --
> Best regards,
> Andrey V. Mashenkov
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Hi Ilya,

Not yet, we can't predict string size [1] as a character may be encoded in
1-4 bytes.
So, we could either use a heuristic or serialize every string into an array
at first then assemble a row and copy the array into the row buffer.

Good point, we can skip vartable for the first varlen field.
We have a similar ticket [2] for the case with a single varlen. I'll fix
the description to omit a first varlen offset.

Agree, compression looks tricky and ineffective in this case.

[1]
https://stackoverflow.com/questions/4385623/bytes-of-a-string-in-java/4385653
[2] https://issues.apache.org/jira/browse/IGNITE-14746

On Thu, May 20, 2021 at 5:58 PM Ilya Kasnacheev <il...@gmail.com>
wrote:

> Hello!
>
> How about:
>
> First, all fields for which we know their specific order and size go, such
> as byte, short, int, long, boolean. This means that any short field will
> take just 2 bytes with no padding.
> Then, all var-len fields go, such as nested object, strings, etc.
>
> After that, we know total object size already, right?
> If size <= 256, then all offsets are 1 byte unsigned.
> If size < 65k, then all offsets are 2 byte.
> Else, all offsets are 4 byte.
>
> We can count offsets starting from the first byle after constant fields
> section and offsets section.
> For the first varlen field, the offset is always 0, so we may skip this one
> and start with offset of the second var field.
>
> For compression it is trickier. I suggest not having any explicit support
> for compression right here, so that later on compression may use a
> different object layout to be more efficient.
>
> Regards,
> --
> Ilya Kasnacheev
>
>
> ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <an...@gmail.com>:
>
> > Hi Igniters,
> >
> > I've create a ticket [1] for large row support.
> >
> > We use 2-bytes offsets for varlen fields that are supposed to be large
> > enough.
> > AFAIK, some users use multi-MB values and 64k per Row looks like a strong
> > limitation.
> >
> > So, we have either to increase offset_size up to 4-bytes or use some
> > advanced mechanics for compression or adaptive offset_size.
> >
> > 1. Increasing offset size may add overhead for keys like next:
> > class Key {
> >    int id;
> >    String str; // Some short string code.
> > }
> >
> > 2. Compression will require table to be decompressed on every varlen
> column
> > access, e.g. for comparison purposes while index scan.
> > Also, we may need to pre-calculate compressed table size to avoid buffer
> > copying (shrinking or extending) during row assembling.
> >
> > 3. Adaptive offset_size implies row size estimation.
> > We already do to reduce the probability of buffer expanding, but we need
> a
> > high margin for this purpose.
> > 'String' values size is a hard part as String character may be encoded
> into
> > 1-4 bytes depending on Charset.
> >
> > Usually, a user don't want to care about Column length limitation and
> chars
> > collation.
> > So, we can expect a Java default behavior will be used in most cases:
> > 'unlimited' string size with up to 4-bytes characters support.
> >
> > Possible strategies
> > 3.1 Introduce 'Collation' for string and validate all the chars on row
> > assembling and rely on the user limited column length.
> > Thus, we can use varlen limits (+ collation for strings) to estimate row
> > size and pre-calculate offset_size to keep it within the schema.
> > 3.2 Introduce more row flags for different offset sizes (byte, short,
> int)
> > and calculate row size right before assembling for choosing appropriate
> > offset_size.
> > Heuristics for strings using collation is also applicable here and keep
> > algorithm complexity independent from the data length, but the schema
> only.
> >
> > I like an approach '3.2' because we already estimate row size.
> > Any thoughts?
> >
> > [1] https://issues.apache.org/jira/browse/IGNITE-14743
> >
> > On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> > andrey.mashenkov@gmail.com>
> > wrote:
> >
> > > Igniters,
> > > I've prepared PR [1] with Public Table API for final review.
> > >
> > > Main points
> > > There are 4 projection interfaces over Table for different use-cases
> > > (Plain record vs Key-Value and POJO vs Binary object) declaring
> > synchronous
> > > and asynchronous methods.
> > > Async method returns IgniteFuture as there is no consensus on
> > IgniteFuture
> > > vs JDK CompletableFuture yet.
> > > API implementation is incomplete, it just an example of how it could be
> > > done and will be implemented in future tasks.
> > > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is just a
> > > dictionary representing a subset of columns, while Row is a
> schema-aware
> > > object containing key and value columns respectively to the data
> layout.
> > >
> > > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <pt...@apache.org>
> > > wrote:
> > >
> > >> I see, thanks.
> > >>
> > >> Let's discuss the return type - Future is not the one to use.
> > >> We should return CompletionStage, CompletableFuture, or introduce our
> > own
> > >> interface.
> > >> We agreed on the last one (custom interface) for thin clients:
> > >>
> > >>
> >
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> > >>
> > >> I believe that for Ignite 3.0 we should have the following:
> > >> public interface IgniteFuture<T> extends Future<T>,
> CompletionStage<T> {
> > >>     // No-op.
> > >> }
> > >>
> > >> Thoughts?
> > >>
> > >>
> > >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> > >> andrey.mashenkov@gmail.com> wrote:
> > >>
> > >> > Pavel,
> > >> > There are 2 PR's for the ticket[1] with two different APIs
> suggested.
> > >> > Please, take a look at PR [2].
> > >> >
> > >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > >> > [2] https://github.com/apache/ignite-3/pull/69
> > >> >
> > >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <
> ptupitsyn@apache.org
> > >
> > >> > wrote:
> > >> >
> > >> > > Andrey, I can't find any async methods,
> > >> > > can you please check if the changes are pushed?
> > >> > >
> > >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > >> > > andrey.mashenkov@gmail.com> wrote:
> > >> > >
> > >> > > > Pavel, good point.
> > >> > > > Thanks. I've added async methods.
> > >> > > >
> > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > >> ptupitsyn@apache.org>
> > >> > > > wrote:
> > >> > > >
> > >> > > > > Andrey,
> > >> > > > >
> > >> > > > > What about corresponding async APIs, do we add them now or
> > later?
> > >> > > > >
> > >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > >> > > > > andrey.mashenkov@gmail.com>
> > >> > > > > wrote:
> > >> > > > >
> > >> > > > > > Hi Igniters.
> > >> > > > > >
> > >> > > > > > I've created a PR for Table access API [1].
> > >> > > > > > This is an initial version. So, any suggestions\objections
> are
> > >> > > > welcomed.
> > >> > > > > > Please, do not hesitate to write your comments and\or
> examples
> > >> to
> > >> > the
> > >> > > > PR.
> > >> > > > > >
> > >> > > > > > Ignite-api module contains API classes, e.g. TableView
> classes
> > >> as
> > >> > > > > > projections for a table for different purposes.
> > >> > > > > > Ignite-table contains dummy implementation and Example class
> > >> > > explained
> > >> > > > > how
> > >> > > > > > it is supposed to be used.
> > >> > > > > >
> > >> > > > > >
> > >> > > > > > Also, I'm still waiting for any feedback for Schema
> > >> configuration
> > >> > > > public
> > >> > > > > > API PR [2].
> > >> > > > > >
> > >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > >> > > > > >
> > >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > >> > > <
> > >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > >> > > > > <
> > >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > >> > > > > > >> >> > > > > > > isapego@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 <
> > >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > >> > > > > > >> >> > <
> > >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > >> > > > > > >> >> > > > > > > > > > > isapego@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
> > >> > > > > > >> >> > > > <
> > >> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > >> > > > > > >> >> > > > > > > > <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > >> > > > > > >> >> > > > > <
> > >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > >> vololo100@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.kulichenko@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> > > > > vololo100@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> dmagda@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.kulichenko@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 <
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> > > > dmagda@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.kulichenko@gmail.com>
> > >> > > > > > >> >> > > > > > > > > > > > > wrote:
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> Igniters,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > One
> > >> > > > > > of
> > >> > > > > > >> the
> > >> > > > > > >> >> > big
> > >> > > > > > >> >> > > > > > changes
> > >> > > > > > >> >> > > > > > > > > > proposed
> > >> > > > > > >> >> > > > > > > > > > > > for
> > >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > >> so-called
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> "schema-first
> > >> > > > > > >> >> > > > > > > approach".
> > >> > > > > > >> >> > > > > > > > To
> > >> > > > > > >> >> > > > > > > > > > add
> > >> > > > > > >> >> > > > > > > > > > > > > more
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > started
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> writing
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > the
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >> >
> > >> > > IEP
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > for
> > >> > > > > > >> this
> > >> > > > > > >> >> > > change:
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > >
> > >> > > > > > >> >> > > > > > > >
> > >> > > > > > >> >> > > > > > >
> > >> > > > > > >> >> > > > > >
> > >> > > > > > >> >> > > > >
> > >> > > > > > >> >> > > >
> > >> > > > > > >> >> > >
> > >> > > > > > >> >> >
> > >> > > > > > >> >>
> > >> > > > > > >>
> > >> > > > > >
> > >> > > > >
> > >> > > >
> > >> > >
> > >> >
> > >>
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > Please
> > >> > > > > > >> >> take a
> > >> > > > > > >> >> > > > look
> > >> > > > > > >> >> > > > > > and
> > >> > > > > > >> >> > > > > > > > let
> > >> > > > > > >> >> > > > > > > > > me
> > >> > > > > > >> >> > > > > > > > > > > > know
> > >> > > > > > >> >> > > > > > > > > > > > > if
> > >> > > > > > >> >> > > > > > > > > > > > > > > > there
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > immediate
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> thoughts,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> suggestions,
> > >> > > > > > >> >> > or
> > >> > > > > > >> >> > > > > > > > objections.
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > -Val
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> Best
> > >> > > > > > regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> Ivan
> > >> > > > > > Pavlukhin
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > Best
> > >> > > > regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > Ivan
> > >> > > > > Pavlukhin
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best
> > regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan
> > Pavlukhin
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best
> regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V.
> > >> Mashenkov
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V.
> > Mashenkov
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > >> > > > > > >> >> > > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > > > Best regards,
> > >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > >> > > > > > >> >> > > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > >
> > >> > > > > > >> >> > > > > > > > >
> > >> > > > > > >> >> > > > > > > > >
> > >> > > > > > >> >> > > > > > > > > --
> > >> > > > > > >> >> > > > > > > > > Best regards,
> > >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > >> > > > > > >> >> > > > > > > > >
> > >> > > > > > >> >> > > > > > > >
> > >> > > > > > >> >> > > > > > >
> > >> > > > > > >> >> > > > > >
> > >> > > > > > >> >> > > > >
> > >> > > > > > >> >> > > > >
> > >> > > > > > >> >> > > > > --
> > >> > > > > > >> >> > > > > Живи с улыбкой! :D
> > >> > > > > > >> >> > > > >
> > >> > > > > > >> >> > > >
> > >> > > > > > >> >> > > >
> > >> > > > > > >> >> > > > --
> > >> > > > > > >> >> > > > Best regards,
> > >> > > > > > >> >> > > > Andrey V. Mashenkov
> > >> > > > > > >> >> > > >
> > >> > > > > > >> >> > >
> > >> > > > > > >> >> >
> > >> > > > > > >> >>
> > >> > > > > > >> >
> > >> > > > > > >>
> > >> > > > > > >
> > >> > > > > > >
> > >> > > > > > > --
> > >> > > > > > > Best regards,
> > >> > > > > > > Andrey V. Mashenkov
> > >> > > > > > >
> > >> > > > > >
> > >> > > > > >
> > >> > > > > > --
> > >> > > > > > Best regards,
> > >> > > > > > Andrey V. Mashenkov
> > >> > > > > >
> > >> > > > >
> > >> > > >
> > >> > > >
> > >> > > > --
> > >> > > > Best regards,
> > >> > > > Andrey V. Mashenkov
> > >> > > >
> > >> > >
> > >> >
> > >> >
> > >> > --
> > >> > Best regards,
> > >> > Andrey V. Mashenkov
> > >> >
> > >>
> > >
> > >
> > > --
> > > Best regards,
> > > Andrey V. Mashenkov
> > >
> >
> >
> > --
> > Best regards,
> > Andrey V. Mashenkov
> >
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Ilya Kasnacheev <il...@gmail.com>]

Hello!

How about:

First, all fields for which we know their specific order and size go, such
as byte, short, int, long, boolean. This means that any short field will
take just 2 bytes with no padding.
Then, all var-len fields go, such as nested object, strings, etc.

After that, we know total object size already, right?
If size <= 256, then all offsets are 1 byte unsigned.
If size < 65k, then all offsets are 2 byte.
Else, all offsets are 4 byte.

We can count offsets starting from the first byle after constant fields
section and offsets section.
For the first varlen field, the offset is always 0, so we may skip this one
and start with offset of the second var field.

For compression it is trickier. I suggest not having any explicit support
for compression right here, so that later on compression may use a
different object layout to be more efficient.

Regards,
-- 
Ilya Kasnacheev


ср, 19 мая 2021 г. в 16:43, Andrey Mashenkov <an...@gmail.com>:

> Hi Igniters,
>
> I've create a ticket [1] for large row support.
>
> We use 2-bytes offsets for varlen fields that are supposed to be large
> enough.
> AFAIK, some users use multi-MB values and 64k per Row looks like a strong
> limitation.
>
> So, we have either to increase offset_size up to 4-bytes or use some
> advanced mechanics for compression or adaptive offset_size.
>
> 1. Increasing offset size may add overhead for keys like next:
> class Key {
>    int id;
>    String str; // Some short string code.
> }
>
> 2. Compression will require table to be decompressed on every varlen column
> access, e.g. for comparison purposes while index scan.
> Also, we may need to pre-calculate compressed table size to avoid buffer
> copying (shrinking or extending) during row assembling.
>
> 3. Adaptive offset_size implies row size estimation.
> We already do to reduce the probability of buffer expanding, but we need a
> high margin for this purpose.
> 'String' values size is a hard part as String character may be encoded into
> 1-4 bytes depending on Charset.
>
> Usually, a user don't want to care about Column length limitation and chars
> collation.
> So, we can expect a Java default behavior will be used in most cases:
> 'unlimited' string size with up to 4-bytes characters support.
>
> Possible strategies
> 3.1 Introduce 'Collation' for string and validate all the chars on row
> assembling and rely on the user limited column length.
> Thus, we can use varlen limits (+ collation for strings) to estimate row
> size and pre-calculate offset_size to keep it within the schema.
> 3.2 Introduce more row flags for different offset sizes (byte, short, int)
> and calculate row size right before assembling for choosing appropriate
> offset_size.
> Heuristics for strings using collation is also applicable here and keep
> algorithm complexity independent from the data length, but the schema only.
>
> I like an approach '3.2' because we already estimate row size.
> Any thoughts?
>
> [1] https://issues.apache.org/jira/browse/IGNITE-14743
>
> On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <
> andrey.mashenkov@gmail.com>
> wrote:
>
> > Igniters,
> > I've prepared PR [1] with Public Table API for final review.
> >
> > Main points
> > There are 4 projection interfaces over Table for different use-cases
> > (Plain record vs Key-Value and POJO vs Binary object) declaring
> synchronous
> > and asynchronous methods.
> > Async method returns IgniteFuture as there is no consensus on
> IgniteFuture
> > vs JDK CompletableFuture yet.
> > API implementation is incomplete, it just an example of how it could be
> > done and will be implemented in future tasks.
> > Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is just a
> > dictionary representing a subset of columns, while Row is a schema-aware
> > object containing key and value columns respectively to the data layout.
> >
> > On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <pt...@apache.org>
> > wrote:
> >
> >> I see, thanks.
> >>
> >> Let's discuss the return type - Future is not the one to use.
> >> We should return CompletionStage, CompletableFuture, or introduce our
> own
> >> interface.
> >> We agreed on the last one (custom interface) for thin clients:
> >>
> >>
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
> >>
> >> I believe that for Ignite 3.0 we should have the following:
> >> public interface IgniteFuture<T> extends Future<T>, CompletionStage<T> {
> >>     // No-op.
> >> }
> >>
> >> Thoughts?
> >>
> >>
> >> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> >> andrey.mashenkov@gmail.com> wrote:
> >>
> >> > Pavel,
> >> > There are 2 PR's for the ticket[1] with two different APIs  suggested.
> >> > Please, take a look at PR [2].
> >> >
> >> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> >> > [2] https://github.com/apache/ignite-3/pull/69
> >> >
> >> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <ptupitsyn@apache.org
> >
> >> > wrote:
> >> >
> >> > > Andrey, I can't find any async methods,
> >> > > can you please check if the changes are pushed?
> >> > >
> >> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> >> > > andrey.mashenkov@gmail.com> wrote:
> >> > >
> >> > > > Pavel, good point.
> >> > > > Thanks. I've added async methods.
> >> > > >
> >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> >> ptupitsyn@apache.org>
> >> > > > wrote:
> >> > > >
> >> > > > > Andrey,
> >> > > > >
> >> > > > > What about corresponding async APIs, do we add them now or
> later?
> >> > > > >
> >> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> >> > > > > andrey.mashenkov@gmail.com>
> >> > > > > wrote:
> >> > > > >
> >> > > > > > Hi Igniters.
> >> > > > > >
> >> > > > > > I've created a PR for Table access API [1].
> >> > > > > > This is an initial version. So, any suggestions\objections are
> >> > > > welcomed.
> >> > > > > > Please, do not hesitate to write your comments and\or examples
> >> to
> >> > the
> >> > > > PR.
> >> > > > > >
> >> > > > > > Ignite-api module contains API classes, e.g. TableView classes
> >> as
> >> > > > > > projections for a table for different purposes.
> >> > > > > > Ignite-table contains dummy implementation and Example class
> >> > > explained
> >> > > > > how
> >> > > > > > it is supposed to be used.
> >> > > > > >
> >> > > > > >
> >> > > > > > Also, I'm still waiting for any feedback for Schema
> >> configuration
> >> > > > public
> >> > > > > > API PR [2].
> >> > > > > >
> >> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> >> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> >> > > > > >
> >> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> >> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> >> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> >> > > <
> >> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> >> > > > > <
> >> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> >> > > > > > >> >> > > > > > > isapego@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 <
> >> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> >> > > > > > >> >> > <
> >> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> >> > > > > > >> >> > > > > > > > > > > isapego@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
> >> > > > > > >> >> > > > <
> >> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> >> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> >> > > > > > >> >> > > > > > > > <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> >> > > > > > >> >> > > > > <
> >> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> >> vololo100@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.kulichenko@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 <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >> > > > > vololo100@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 <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >> > > > dmagda@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.kulichenko@gmail.com>
> >> > > > > > >> >> > > > > > > > > > > > > wrote:
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> Igniters,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > One
> >> > > > > > of
> >> > > > > > >> the
> >> > > > > > >> >> > big
> >> > > > > > >> >> > > > > > changes
> >> > > > > > >> >> > > > > > > > > > proposed
> >> > > > > > >> >> > > > > > > > > > > > for
> >> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >> so-called
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> "schema-first
> >> > > > > > >> >> > > > > > > approach".
> >> > > > > > >> >> > > > > > > > To
> >> > > > > > >> >> > > > > > > > > > add
> >> > > > > > >> >> > > > > > > > > > > > > more
> >> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > started
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> writing
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > the
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >> >
> >> > > IEP
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > for
> >> > > > > > >> this
> >> > > > > > >> >> > > change:
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > >
> >> > > > > > >> >> > > > > > > > >
> >> > > > > > >> >> > > > > > > >
> >> > > > > > >> >> > > > > > >
> >> > > > > > >> >> > > > > >
> >> > > > > > >> >> > > > >
> >> > > > > > >> >> > > >
> >> > > > > > >> >> > >
> >> > > > > > >> >> >
> >> > > > > > >> >>
> >> > > > > > >>
> >> > > > > >
> >> > > > >
> >> > > >
> >> > >
> >> >
> >>
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > Please
> >> > > > > > >> >> take a
> >> > > > > > >> >> > > > look
> >> > > > > > >> >> > > > > > and
> >> > > > > > >> >> > > > > > > > let
> >> > > > > > >> >> > > > > > > > > me
> >> > > > > > >> >> > > > > > > > > > > > know
> >> > > > > > >> >> > > > > > > > > > > > > if
> >> > > > > > >> >> > > > > > > > > > > > > > > > there
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> immediate
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> thoughts,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> suggestions,
> >> > > > > > >> >> > or
> >> > > > > > >> >> > > > > > > > objections.
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > -Val
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> --
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> Best
> >> > > > > > regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> Ivan
> >> > > > > > Pavlukhin
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> Best
> >> > > > regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> Ivan
> >> > > > > Pavlukhin
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best
> regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan
> Pavlukhin
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V.
> >> Mashenkov
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V.
> Mashenkov
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> >> > > > > > >> >> > > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> >> > > > > > >> >> > > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> >> > > > > > >> >> > > > > > > > > > >
> >> > > > > > >> >> > > > > > > > > >
> >> > > > > > >> >> > > > > > > > >
> >> > > > > > >> >> > > > > > > > >
> >> > > > > > >> >> > > > > > > > > --
> >> > > > > > >> >> > > > > > > > > Best regards,
> >> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> >> > > > > > >> >> > > > > > > > >
> >> > > > > > >> >> > > > > > > >
> >> > > > > > >> >> > > > > > >
> >> > > > > > >> >> > > > > >
> >> > > > > > >> >> > > > >
> >> > > > > > >> >> > > > >
> >> > > > > > >> >> > > > > --
> >> > > > > > >> >> > > > > Живи с улыбкой! :D
> >> > > > > > >> >> > > > >
> >> > > > > > >> >> > > >
> >> > > > > > >> >> > > >
> >> > > > > > >> >> > > > --
> >> > > > > > >> >> > > > Best regards,
> >> > > > > > >> >> > > > Andrey V. Mashenkov
> >> > > > > > >> >> > > >
> >> > > > > > >> >> > >
> >> > > > > > >> >> >
> >> > > > > > >> >>
> >> > > > > > >> >
> >> > > > > > >>
> >> > > > > > >
> >> > > > > > >
> >> > > > > > > --
> >> > > > > > > Best regards,
> >> > > > > > > Andrey V. Mashenkov
> >> > > > > > >
> >> > > > > >
> >> > > > > >
> >> > > > > > --
> >> > > > > > Best regards,
> >> > > > > > Andrey V. Mashenkov
> >> > > > > >
> >> > > > >
> >> > > >
> >> > > >
> >> > > > --
> >> > > > Best regards,
> >> > > > Andrey V. Mashenkov
> >> > > >
> >> > >
> >> >
> >> >
> >> > --
> >> > Best regards,
> >> > Andrey V. Mashenkov
> >> >
> >>
> >
> >
> > --
> > Best regards,
> > Andrey V. Mashenkov
> >
>
>
> --
> Best regards,
> Andrey V. Mashenkov
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Hi Igniters,

I've create a ticket [1] for large row support.

We use 2-bytes offsets for varlen fields that are supposed to be large
enough.
AFAIK, some users use multi-MB values and 64k per Row looks like a strong
limitation.

So, we have either to increase offset_size up to 4-bytes or use some
advanced mechanics for compression or adaptive offset_size.

1. Increasing offset size may add overhead for keys like next:
class Key {
   int id;
   String str; // Some short string code.
}

2. Compression will require table to be decompressed on every varlen column
access, e.g. for comparison purposes while index scan.
Also, we may need to pre-calculate compressed table size to avoid buffer
copying (shrinking or extending) during row assembling.

3. Adaptive offset_size implies row size estimation.
We already do to reduce the probability of buffer expanding, but we need a
high margin for this purpose.
'String' values size is a hard part as String character may be encoded into
1-4 bytes depending on Charset.

Usually, a user don't want to care about Column length limitation and chars
collation.
So, we can expect a Java default behavior will be used in most cases:
'unlimited' string size with up to 4-bytes characters support.

Possible strategies
3.1 Introduce 'Collation' for string and validate all the chars on row
assembling and rely on the user limited column length.
Thus, we can use varlen limits (+ collation for strings) to estimate row
size and pre-calculate offset_size to keep it within the schema.
3.2 Introduce more row flags for different offset sizes (byte, short, int)
and calculate row size right before assembling for choosing appropriate
offset_size.
Heuristics for strings using collation is also applicable here and keep
algorithm complexity independent from the data length, but the schema only.

I like an approach '3.2' because we already estimate row size.
Any thoughts?

[1] https://issues.apache.org/jira/browse/IGNITE-14743

On Fri, Mar 19, 2021 at 7:25 PM Andrey Mashenkov <an...@gmail.com>
wrote:

> Igniters,
> I've prepared PR [1] with Public Table API for final review.
>
> Main points
> There are 4 projection interfaces over Table for different use-cases
> (Plain record vs Key-Value and POJO vs Binary object) declaring synchronous
> and asynchronous methods.
> Async method returns IgniteFuture as there is no consensus on IgniteFuture
> vs JDK CompletableFuture yet.
> API implementation is incomplete, it just an example of how it could be
> done and will be implemented in future tasks.
> Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is just a
> dictionary representing a subset of columns, while Row is a schema-aware
> object containing key and value columns respectively to the data layout.
>
> On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <pt...@apache.org>
> wrote:
>
>> I see, thanks.
>>
>> Let's discuss the return type - Future is not the one to use.
>> We should return CompletionStage, CompletableFuture, or introduce our own
>> interface.
>> We agreed on the last one (custom interface) for thin clients:
>>
>> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
>>
>> I believe that for Ignite 3.0 we should have the following:
>> public interface IgniteFuture<T> extends Future<T>, CompletionStage<T> {
>>     // No-op.
>> }
>>
>> Thoughts?
>>
>>
>> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
>> andrey.mashenkov@gmail.com> wrote:
>>
>> > Pavel,
>> > There are 2 PR's for the ticket[1] with two different APIs  suggested.
>> > Please, take a look at PR [2].
>> >
>> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
>> > [2] https://github.com/apache/ignite-3/pull/69
>> >
>> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <pt...@apache.org>
>> > wrote:
>> >
>> > > Andrey, I can't find any async methods,
>> > > can you please check if the changes are pushed?
>> > >
>> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
>> > > andrey.mashenkov@gmail.com> wrote:
>> > >
>> > > > Pavel, good point.
>> > > > Thanks. I've added async methods.
>> > > >
>> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
>> ptupitsyn@apache.org>
>> > > > wrote:
>> > > >
>> > > > > Andrey,
>> > > > >
>> > > > > What about corresponding async APIs, do we add them now or later?
>> > > > >
>> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
>> > > > > andrey.mashenkov@gmail.com>
>> > > > > wrote:
>> > > > >
>> > > > > > Hi Igniters.
>> > > > > >
>> > > > > > I've created a PR for Table access API [1].
>> > > > > > This is an initial version. So, any suggestions\objections are
>> > > > welcomed.
>> > > > > > Please, do not hesitate to write your comments and\or examples
>> to
>> > the
>> > > > PR.
>> > > > > >
>> > > > > > Ignite-api module contains API classes, e.g. TableView classes
>> as
>> > > > > > projections for a table for different purposes.
>> > > > > > Ignite-table contains dummy implementation and Example class
>> > > explained
>> > > > > how
>> > > > > > it is supposed to be used.
>> > > > > >
>> > > > > >
>> > > > > > Also, I'm still waiting for any feedback for Schema
>> configuration
>> > > > public
>> > > > > > API PR [2].
>> > > > > >
>> > > > > > [1] https://github.com/apache/ignite-3/pull/33
>> > > > > > [2] https://github.com/apache/ignite-3/pull/2
>> > > > > >
>> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
>> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
>> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
>> > > <
>> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
>> > > > > <
>> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
>> > > > > > >> >> > > > > > > isapego@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 <
>> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
>> > > > > > >> >> > <
>> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
>> > > > > > >> >> > > > > > > > > > > isapego@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
>> > > > > > >> >> > > > <
>> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
>> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
>> > > > > > >> >> > > > > > > > <
>> > > > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
>> > > > > > >> >> > > > > <
>> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
>> vololo100@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.kulichenko@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 <
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
>> > > > > vololo100@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 <
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
>> > > > dmagda@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.kulichenko@gmail.com>
>> > > > > > >> >> > > > > > > > > > > > > wrote:
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> Igniters,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > One
>> > > > > > of
>> > > > > > >> the
>> > > > > > >> >> > big
>> > > > > > >> >> > > > > > changes
>> > > > > > >> >> > > > > > > > > > proposed
>> > > > > > >> >> > > > > > > > > > > > for
>> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
>> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
>> so-called
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> "schema-first
>> > > > > > >> >> > > > > > > approach".
>> > > > > > >> >> > > > > > > > To
>> > > > > > >> >> > > > > > > > > > add
>> > > > > > >> >> > > > > > > > > > > > > more
>> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > started
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> writing
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > the
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >> >
>> > > IEP
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > for
>> > > > > > >> this
>> > > > > > >> >> > > change:
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > >
>> > > > > > >> >> > > > > > > > >
>> > > > > > >> >> > > > > > > >
>> > > > > > >> >> > > > > > >
>> > > > > > >> >> > > > > >
>> > > > > > >> >> > > > >
>> > > > > > >> >> > > >
>> > > > > > >> >> > >
>> > > > > > >> >> >
>> > > > > > >> >>
>> > > > > > >>
>> > > > > >
>> > > > >
>> > > >
>> > >
>> >
>> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > Please
>> > > > > > >> >> take a
>> > > > > > >> >> > > > look
>> > > > > > >> >> > > > > > and
>> > > > > > >> >> > > > > > > > let
>> > > > > > >> >> > > > > > > > > me
>> > > > > > >> >> > > > > > > > > > > > know
>> > > > > > >> >> > > > > > > > > > > > > if
>> > > > > > >> >> > > > > > > > > > > > > > > > there
>> > > > > > >> >> > > > > > > > > > > > > > > > > > are
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> thoughts,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> suggestions,
>> > > > > > >> >> > or
>> > > > > > >> >> > > > > > > > objections.
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > -Val
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> --
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> Best
>> > > > > > regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> Ivan
>> > > > > > Pavlukhin
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best
>> > > > regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
>> > > > > Pavlukhin
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V.
>> Mashenkov
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
>> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
>> > > > > > >> >> > > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
>> > > > > > >> >> > > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > > > --
>> > > > > > >> >> > > > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
>> > > > > > >> >> > > > > > > > > > >
>> > > > > > >> >> > > > > > > > > >
>> > > > > > >> >> > > > > > > > >
>> > > > > > >> >> > > > > > > > >
>> > > > > > >> >> > > > > > > > > --
>> > > > > > >> >> > > > > > > > > Best regards,
>> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
>> > > > > > >> >> > > > > > > > >
>> > > > > > >> >> > > > > > > >
>> > > > > > >> >> > > > > > >
>> > > > > > >> >> > > > > >
>> > > > > > >> >> > > > >
>> > > > > > >> >> > > > >
>> > > > > > >> >> > > > > --
>> > > > > > >> >> > > > > Живи с улыбкой! :D
>> > > > > > >> >> > > > >
>> > > > > > >> >> > > >
>> > > > > > >> >> > > >
>> > > > > > >> >> > > > --
>> > > > > > >> >> > > > Best regards,
>> > > > > > >> >> > > > Andrey V. Mashenkov
>> > > > > > >> >> > > >
>> > > > > > >> >> > >
>> > > > > > >> >> >
>> > > > > > >> >>
>> > > > > > >> >
>> > > > > > >>
>> > > > > > >
>> > > > > > >
>> > > > > > > --
>> > > > > > > Best regards,
>> > > > > > > Andrey V. Mashenkov
>> > > > > > >
>> > > > > >
>> > > > > >
>> > > > > > --
>> > > > > > Best regards,
>> > > > > > Andrey V. Mashenkov
>> > > > > >
>> > > > >
>> > > >
>> > > >
>> > > > --
>> > > > Best regards,
>> > > > Andrey V. Mashenkov
>> > > >
>> > >
>> >
>> >
>> > --
>> > Best regards,
>> > Andrey V. Mashenkov
>> >
>>
>
>
> --
> Best regards,
> Andrey V. Mashenkov
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Igniters,
I've prepared PR [1] with Public Table API for final review.

Main points
There are 4 projection interfaces over Table for different use-cases (Plain
record vs Key-Value and POJO vs Binary object) declaring synchronous and
asynchronous methods.
Async method returns IgniteFuture as there is no consensus on IgniteFuture
vs JDK CompletableFuture yet.
API implementation is incomplete, it just an example of how it could be
done and will be implemented in future tasks.
Tuple/TupleAssembler renamed to Row/RowAssembler. Now Tuple is just a
dictionary representing a subset of columns, while Row is a schema-aware
object containing key and value columns respectively to the data layout.

On Wed, Mar 17, 2021 at 11:26 AM Pavel Tupitsyn <pt...@apache.org>
wrote:

> I see, thanks.
>
> Let's discuss the return type - Future is not the one to use.
> We should return CompletionStage, CompletableFuture, or introduce our own
> interface.
> We agreed on the last one (custom interface) for thin clients:
>
> http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html
>
> I believe that for Ignite 3.0 we should have the following:
> public interface IgniteFuture<T> extends Future<T>, CompletionStage<T> {
>     // No-op.
> }
>
> Thoughts?
>
>
> On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
> andrey.mashenkov@gmail.com> wrote:
>
> > Pavel,
> > There are 2 PR's for the ticket[1] with two different APIs  suggested.
> > Please, take a look at PR [2].
> >
> > [1] https://issues.apache.org/jira/browse/IGNITE-14035
> > [2] https://github.com/apache/ignite-3/pull/69
> >
> > On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <pt...@apache.org>
> > wrote:
> >
> > > Andrey, I can't find any async methods,
> > > can you please check if the changes are pushed?
> > >
> > > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > > andrey.mashenkov@gmail.com> wrote:
> > >
> > > > Pavel, good point.
> > > > Thanks. I've added async methods.
> > > >
> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <ptupitsyn@apache.org
> >
> > > > wrote:
> > > >
> > > > > Andrey,
> > > > >
> > > > > What about corresponding async APIs, do we add them now or later?
> > > > >
> > > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > > andrey.mashenkov@gmail.com>
> > > > > wrote:
> > > > >
> > > > > > Hi Igniters.
> > > > > >
> > > > > > I've created a PR for Table access API [1].
> > > > > > This is an initial version. So, any suggestions\objections are
> > > > welcomed.
> > > > > > Please, do not hesitate to write your comments and\or examples to
> > the
> > > > PR.
> > > > > >
> > > > > > Ignite-api module contains API classes, e.g. TableView classes as
> > > > > > projections for a table for different purposes.
> > > > > > Ignite-table contains dummy implementation and Example class
> > > explained
> > > > > how
> > > > > > it is supposed to be used.
> > > > > >
> > > > > >
> > > > > > Also, I'm still waiting for any feedback for Schema configuration
> > > > public
> > > > > > API PR [2].
> > > > > >
> > > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > > >
> > > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > > <
> > > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > > <
> > > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > > >> >> > > > > > > isapego@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 <
> > > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > > >> >> > <
> > > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > > > >> >> > > > > > > > > > > isapego@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
> > > > > > >> >> > > > <
> > > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > > >> >> > > > > > > > <
> > > > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > > > > > >> >> > > > > <
> > > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> vololo100@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.kulichenko@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 <
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > vololo100@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 <
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > dmagda@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.kulichenko@gmail.com>
> > > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> Igniters,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > One
> > > > > > of
> > > > > > >> the
> > > > > > >> >> > big
> > > > > > >> >> > > > > > changes
> > > > > > >> >> > > > > > > > > > proposed
> > > > > > >> >> > > > > > > > > > > > for
> > > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> "schema-first
> > > > > > >> >> > > > > > > approach".
> > > > > > >> >> > > > > > > > To
> > > > > > >> >> > > > > > > > > > add
> > > > > > >> >> > > > > > > > > > > > > more
> > > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > started
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> writing
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > the
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >
> > > IEP
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > for
> > > > > > >> this
> > > > > > >> >> > > change:
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > >
> > > > > > >> >> > > > > > > > > >
> > > > > > >> >> > > > > > > > >
> > > > > > >> >> > > > > > > >
> > > > > > >> >> > > > > > >
> > > > > > >> >> > > > > >
> > > > > > >> >> > > > >
> > > > > > >> >> > > >
> > > > > > >> >> > >
> > > > > > >> >> >
> > > > > > >> >>
> > > > > > >>
> > > > > >
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > Please
> > > > > > >> >> take a
> > > > > > >> >> > > > look
> > > > > > >> >> > > > > > and
> > > > > > >> >> > > > > > > > let
> > > > > > >> >> > > > > > > > > me
> > > > > > >> >> > > > > > > > > > > > know
> > > > > > >> >> > > > > > > > > > > > > if
> > > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> thoughts,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> suggestions,
> > > > > > >> >> > or
> > > > > > >> >> > > > > > > > objections.
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > -Val
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> >> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> --
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> Best
> > > > > > regards,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> Ivan
> > > > > > Pavlukhin
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best
> > > > regards,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
> > > > > Pavlukhin
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V.
> Mashenkov
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> >> > > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > >
> > > > > > >> >> > > > > > > > > > > --
> > > > > > >> >> > > > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > > >> >> > > > > > > > > > >
> > > > > > >> >> > > > > > > > > >
> > > > > > >> >> > > > > > > > >
> > > > > > >> >> > > > > > > > >
> > > > > > >> >> > > > > > > > > --
> > > > > > >> >> > > > > > > > > Best regards,
> > > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > > >> >> > > > > > > > >
> > > > > > >> >> > > > > > > >
> > > > > > >> >> > > > > > >
> > > > > > >> >> > > > > >
> > > > > > >> >> > > > >
> > > > > > >> >> > > > >
> > > > > > >> >> > > > > --
> > > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > > >> >> > > > >
> > > > > > >> >> > > >
> > > > > > >> >> > > >
> > > > > > >> >> > > > --
> > > > > > >> >> > > > Best regards,
> > > > > > >> >> > > > Andrey V. Mashenkov
> > > > > > >> >> > > >
> > > > > > >> >> > >
> > > > > > >> >> >
> > > > > > >> >>
> > > > > > >> >
> > > > > > >>
> > > > > > >
> > > > > > >
> > > > > > > --
> > > > > > > Best regards,
> > > > > > > Andrey V. Mashenkov
> > > > > > >
> > > > > >
> > > > > >
> > > > > > --
> > > > > > Best regards,
> > > > > > Andrey V. Mashenkov
> > > > > >
> > > > >
> > > >
> > > >
> > > > --
> > > > Best regards,
> > > > Andrey V. Mashenkov
> > > >
> > >
> >
> >
> > --
> > Best regards,
> > Andrey V. Mashenkov
> >
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Pavel Tupitsyn <pt...@apache.org>]

I see, thanks.

Let's discuss the return type - Future is not the one to use.
We should return CompletionStage, CompletableFuture, or introduce our own
interface.
We agreed on the last one (custom interface) for thin clients:
http://apache-ignite-developers.2346864.n4.nabble.com/IEP-51-Java-Thin-Client-Async-API-td48900.html

I believe that for Ignite 3.0 we should have the following:
public interface IgniteFuture<T> extends Future<T>, CompletionStage<T> {
    // No-op.
}

Thoughts?


On Wed, Mar 17, 2021 at 11:16 AM Andrey Mashenkov <
andrey.mashenkov@gmail.com> wrote:

> Pavel,
> There are 2 PR's for the ticket[1] with two different APIs  suggested.
> Please, take a look at PR [2].
>
> [1] https://issues.apache.org/jira/browse/IGNITE-14035
> [2] https://github.com/apache/ignite-3/pull/69
>
> On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <pt...@apache.org>
> wrote:
>
> > Andrey, I can't find any async methods,
> > can you please check if the changes are pushed?
> >
> > On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> > andrey.mashenkov@gmail.com> wrote:
> >
> > > Pavel, good point.
> > > Thanks. I've added async methods.
> > >
> > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <pt...@apache.org>
> > > wrote:
> > >
> > > > Andrey,
> > > >
> > > > What about corresponding async APIs, do we add them now or later?
> > > >
> > > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > > andrey.mashenkov@gmail.com>
> > > > wrote:
> > > >
> > > > > Hi Igniters.
> > > > >
> > > > > I've created a PR for Table access API [1].
> > > > > This is an initial version. So, any suggestions\objections are
> > > welcomed.
> > > > > Please, do not hesitate to write your comments and\or examples to
> the
> > > PR.
> > > > >
> > > > > Ignite-api module contains API classes, e.g. TableView classes as
> > > > > projections for a table for different purposes.
> > > > > Ignite-table contains dummy implementation and Example class
> > explained
> > > > how
> > > > > it is supposed to be used.
> > > > >
> > > > >
> > > > > Also, I'm still waiting for any feedback for Schema configuration
> > > public
> > > > > API PR [2].
> > > > >
> > > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > > [2] https://github.com/apache/ignite-3/pull/2
> > > > >
> > > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> > <
> > > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > > <
> > > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > >> >> > > > > > > isapego@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 <
> > > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > > >> >> > <
> > > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > > >> >> > > > > > > > > > > isapego@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
> > > > > >> >> > > > <
> > > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > > >> >> > > > > > > > <
> > > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > > > > >> >> > > > > <
> > > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > vololo100@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 <
> > > > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > dmagda@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.kulichenko@gmail.com>
> > > > > >> >> > > > > > > > > > > > > wrote:
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> Igniters,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > One
> > > > > of
> > > > > >> the
> > > > > >> >> > big
> > > > > >> >> > > > > > changes
> > > > > >> >> > > > > > > > > > proposed
> > > > > >> >> > > > > > > > > > > > for
> > > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> "schema-first
> > > > > >> >> > > > > > > approach".
> > > > > >> >> > > > > > > > To
> > > > > >> >> > > > > > > > > > add
> > > > > >> >> > > > > > > > > > > > > more
> > > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > started
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > writing
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > the
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > IEP
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > for
> > > > > >> this
> > > > > >> >> > > change:
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > >
> > > > > >> >> > > > > > > > > >
> > > > > >> >> > > > > > > > >
> > > > > >> >> > > > > > > >
> > > > > >> >> > > > > > >
> > > > > >> >> > > > > >
> > > > > >> >> > > > >
> > > > > >> >> > > >
> > > > > >> >> > >
> > > > > >> >> >
> > > > > >> >>
> > > > > >>
> > > > >
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > Please
> > > > > >> >> take a
> > > > > >> >> > > > look
> > > > > >> >> > > > > > and
> > > > > >> >> > > > > > > > let
> > > > > >> >> > > > > > > > > me
> > > > > >> >> > > > > > > > > > > > know
> > > > > >> >> > > > > > > > > > > > > if
> > > > > >> >> > > > > > > > > > > > > > > > there
> > > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> thoughts,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> suggestions,
> > > > > >> >> > or
> > > > > >> >> > > > > > > > objections.
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > -Val
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> --
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Best
> > > > > regards,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Ivan
> > > > > Pavlukhin
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best
> > > regards,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
> > > > Pavlukhin
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > >
> > > > > >> >> > > > > > > > > > >
> > > > > >> >> > > > > > > > > > >
> > > > > >> >> > > > > > > > > > > --
> > > > > >> >> > > > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > > > >
> > > > > >> >> > > > > > > > > >
> > > > > >> >> > > > > > > > >
> > > > > >> >> > > > > > > > >
> > > > > >> >> > > > > > > > > --
> > > > > >> >> > > > > > > > > Best regards,
> > > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > > >> >> > > > > > > > >
> > > > > >> >> > > > > > > >
> > > > > >> >> > > > > > >
> > > > > >> >> > > > > >
> > > > > >> >> > > > >
> > > > > >> >> > > > >
> > > > > >> >> > > > > --
> > > > > >> >> > > > > Живи с улыбкой! :D
> > > > > >> >> > > > >
> > > > > >> >> > > >
> > > > > >> >> > > >
> > > > > >> >> > > > --
> > > > > >> >> > > > Best regards,
> > > > > >> >> > > > Andrey V. Mashenkov
> > > > > >> >> > > >
> > > > > >> >> > >
> > > > > >> >> >
> > > > > >> >>
> > > > > >> >
> > > > > >>
> > > > > >
> > > > > >
> > > > > > --
> > > > > > Best regards,
> > > > > > Andrey V. Mashenkov
> > > > > >
> > > > >
> > > > >
> > > > > --
> > > > > Best regards,
> > > > > Andrey V. Mashenkov
> > > > >
> > > >
> > >
> > >
> > > --
> > > Best regards,
> > > Andrey V. Mashenkov
> > >
> >
>
>
> --
> Best regards,
> Andrey V. Mashenkov
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Pavel,
There are 2 PR's for the ticket[1] with two different APIs  suggested.
Please, take a look at PR [2].

[1] https://issues.apache.org/jira/browse/IGNITE-14035
[2] https://github.com/apache/ignite-3/pull/69

On Wed, Mar 17, 2021 at 11:11 AM Pavel Tupitsyn <pt...@apache.org>
wrote:

> Andrey, I can't find any async methods,
> can you please check if the changes are pushed?
>
> On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
> andrey.mashenkov@gmail.com> wrote:
>
> > Pavel, good point.
> > Thanks. I've added async methods.
> >
> > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <pt...@apache.org>
> > wrote:
> >
> > > Andrey,
> > >
> > > What about corresponding async APIs, do we add them now or later?
> > >
> > > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > > andrey.mashenkov@gmail.com>
> > > wrote:
> > >
> > > > Hi Igniters.
> > > >
> > > > I've created a PR for Table access API [1].
> > > > This is an initial version. So, any suggestions\objections are
> > welcomed.
> > > > Please, do not hesitate to write your comments and\or examples to the
> > PR.
> > > >
> > > > Ignite-api module contains API classes, e.g. TableView classes as
> > > > projections for a table for different purposes.
> > > > Ignite-table contains dummy implementation and Example class
> explained
> > > how
> > > > it is supposed to be used.
> > > >
> > > >
> > > > Also, I'm still waiting for any feedback for Schema configuration
> > public
> > > > API PR [2].
> > > >
> > > > [1] https://github.com/apache/ignite-3/pull/33
> > > > [2] https://github.com/apache/ignite-3/pull/2
> > > >
> > > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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
> <
> > > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > > <
> > > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > >> >> > > > > > > isapego@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 <
> > > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > > >> >> > <
> > > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > > >> >> > > > > > > > > > > isapego@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
> > > > >> >> > > > <
> > > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > > >> >> > > > > > > > <
> > > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > > > >> >> > > > > <
> > > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > > >> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > vololo100@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 <
> > > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > dmagda@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.kulichenko@gmail.com>
> > > > >> >> > > > > > > > > > > > > wrote:
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> Igniters,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > One
> > > > of
> > > > >> the
> > > > >> >> > big
> > > > >> >> > > > > > changes
> > > > >> >> > > > > > > > > > proposed
> > > > >> >> > > > > > > > > > > > for
> > > > >> >> > > > > > > > > > > > > > > > Ignite
> > > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > > >> >> > > > > > > > > > > > > > > > > > > is
> > > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> "schema-first
> > > > >> >> > > > > > > approach".
> > > > >> >> > > > > > > > To
> > > > >> >> > > > > > > > > > add
> > > > >> >> > > > > > > > > > > > > more
> > > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > started
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > writing
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > the
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> IEP
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > for
> > > > >> this
> > > > >> >> > > change:
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > >
> > > > >> >> > > > > > > > > > >
> > > > >> >> > > > > > > > > >
> > > > >> >> > > > > > > > >
> > > > >> >> > > > > > > >
> > > > >> >> > > > > > >
> > > > >> >> > > > > >
> > > > >> >> > > > >
> > > > >> >> > > >
> > > > >> >> > >
> > > > >> >> >
> > > > >> >>
> > > > >>
> > > >
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > Please
> > > > >> >> take a
> > > > >> >> > > > look
> > > > >> >> > > > > > and
> > > > >> >> > > > > > > > let
> > > > >> >> > > > > > > > > me
> > > > >> >> > > > > > > > > > > > know
> > > > >> >> > > > > > > > > > > > > if
> > > > >> >> > > > > > > > > > > > > > > > there
> > > > >> >> > > > > > > > > > > > > > > > > > are
> > > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> thoughts,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> suggestions,
> > > > >> >> > or
> > > > >> >> > > > > > > > objections.
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > -Val
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> --
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Best
> > > > regards,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Ivan
> > > > Pavlukhin
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best
> > regards,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
> > > Pavlukhin
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > > > > > >
> > > > >> >> > > > > > > > > > > >
> > > > >> >> > > > > > > > > > >
> > > > >> >> > > > > > > > > > >
> > > > >> >> > > > > > > > > > > --
> > > > >> >> > > > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > > > >
> > > > >> >> > > > > > > > > >
> > > > >> >> > > > > > > > >
> > > > >> >> > > > > > > > >
> > > > >> >> > > > > > > > > --
> > > > >> >> > > > > > > > > Best regards,
> > > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > > >> >> > > > > > > > >
> > > > >> >> > > > > > > >
> > > > >> >> > > > > > >
> > > > >> >> > > > > >
> > > > >> >> > > > >
> > > > >> >> > > > >
> > > > >> >> > > > > --
> > > > >> >> > > > > Живи с улыбкой! :D
> > > > >> >> > > > >
> > > > >> >> > > >
> > > > >> >> > > >
> > > > >> >> > > > --
> > > > >> >> > > > Best regards,
> > > > >> >> > > > Andrey V. Mashenkov
> > > > >> >> > > >
> > > > >> >> > >
> > > > >> >> >
> > > > >> >>
> > > > >> >
> > > > >>
> > > > >
> > > > >
> > > > > --
> > > > > Best regards,
> > > > > Andrey V. Mashenkov
> > > > >
> > > >
> > > >
> > > > --
> > > > Best regards,
> > > > Andrey V. Mashenkov
> > > >
> > >
> >
> >
> > --
> > Best regards,
> > Andrey V. Mashenkov
> >
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Pavel Tupitsyn <pt...@apache.org>]

Andrey, I can't find any async methods,
can you please check if the changes are pushed?

On Tue, Mar 16, 2021 at 10:06 PM Andrey Mashenkov <
andrey.mashenkov@gmail.com> wrote:

> Pavel, good point.
> Thanks. I've added async methods.
>
> On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <pt...@apache.org>
> wrote:
>
> > Andrey,
> >
> > What about corresponding async APIs, do we add them now or later?
> >
> > On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> > andrey.mashenkov@gmail.com>
> > wrote:
> >
> > > Hi Igniters.
> > >
> > > I've created a PR for Table access API [1].
> > > This is an initial version. So, any suggestions\objections are
> welcomed.
> > > Please, do not hesitate to write your comments and\or examples to the
> PR.
> > >
> > > Ignite-api module contains API classes, e.g. TableView classes as
> > > projections for a table for different purposes.
> > > Ignite-table contains dummy implementation and Example class explained
> > how
> > > it is supposed to be used.
> > >
> > >
> > > Also, I'm still waiting for any feedback for Schema configuration
> public
> > > API PR [2].
> > >
> > > [1] https://github.com/apache/ignite-3/pull/33
> > > [2] https://github.com/apache/ignite-3/pull/2
> > >
> > > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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 <
> > > >> >> > > > > ptupitsyn@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.mashenkov@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
> > <
> > > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > > >> >> > > > > > > isapego@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 <
> > > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > > >> >> > <
> > > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > > >> >> > > > > > > > > > > isapego@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
> > > >> >> > > > <
> > > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > > >> >> > > > > > > > <
> > > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > > >> >> > > > > <
> > > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > > >> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > vololo100@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 <
> > > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> dmagda@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.kulichenko@gmail.com>
> > > >> >> > > > > > > > > > > > > wrote:
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> Igniters,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> One
> > > of
> > > >> the
> > > >> >> > big
> > > >> >> > > > > > changes
> > > >> >> > > > > > > > > > proposed
> > > >> >> > > > > > > > > > > > for
> > > >> >> > > > > > > > > > > > > > > > Ignite
> > > >> >> > > > > > > > > > > > > > > > > > 3.0
> > > >> >> > > > > > > > > > > > > > > > > > > is
> > > >> >> > > > > > > > > > > > > > > > > > > > > the
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> "schema-first
> > > >> >> > > > > > > approach".
> > > >> >> > > > > > > > To
> > > >> >> > > > > > > > > > add
> > > >> >> > > > > > > > > > > > > more
> > > >> >> > > > > > > > > > > > > > > > > clarity,
> > > >> >> > > > > > > > > > > > > > > > > > > > I've
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > started
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > writing
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> the
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > IEP
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> for
> > > >> this
> > > >> >> > > change:
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > >
> > > >> >> > > > > > > > > > >
> > > >> >> > > > > > > > > >
> > > >> >> > > > > > > > >
> > > >> >> > > > > > > >
> > > >> >> > > > > > >
> > > >> >> > > > > >
> > > >> >> > > > >
> > > >> >> > > >
> > > >> >> > >
> > > >> >> >
> > > >> >>
> > > >>
> > >
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > Please
> > > >> >> take a
> > > >> >> > > > look
> > > >> >> > > > > > and
> > > >> >> > > > > > > > let
> > > >> >> > > > > > > > > me
> > > >> >> > > > > > > > > > > > know
> > > >> >> > > > > > > > > > > > > if
> > > >> >> > > > > > > > > > > > > > > > there
> > > >> >> > > > > > > > > > > > > > > > > > are
> > > >> >> > > > > > > > > > > > > > > > > > > > any
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> thoughts,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> suggestions,
> > > >> >> > or
> > > >> >> > > > > > > > objections.
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > -Val
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> --
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Best
> > > regards,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Ivan
> > > Pavlukhin
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best
> regards,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
> > Pavlukhin
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
> > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > > > --
> > > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > > > --
> > > >> >> > > > > > > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > > > --
> > > >> >> > > > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > > > > > >
> > > >> >> > > > > > > > > > > >
> > > >> >> > > > > > > > > > >
> > > >> >> > > > > > > > > > >
> > > >> >> > > > > > > > > > > --
> > > >> >> > > > > > > > > > > Best regards,
> > > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > > > >
> > > >> >> > > > > > > > > >
> > > >> >> > > > > > > > >
> > > >> >> > > > > > > > >
> > > >> >> > > > > > > > > --
> > > >> >> > > > > > > > > Best regards,
> > > >> >> > > > > > > > > Andrey V. Mashenkov
> > > >> >> > > > > > > > >
> > > >> >> > > > > > > >
> > > >> >> > > > > > >
> > > >> >> > > > > >
> > > >> >> > > > >
> > > >> >> > > > >
> > > >> >> > > > > --
> > > >> >> > > > > Живи с улыбкой! :D
> > > >> >> > > > >
> > > >> >> > > >
> > > >> >> > > >
> > > >> >> > > > --
> > > >> >> > > > Best regards,
> > > >> >> > > > Andrey V. Mashenkov
> > > >> >> > > >
> > > >> >> > >
> > > >> >> >
> > > >> >>
> > > >> >
> > > >>
> > > >
> > > >
> > > > --
> > > > Best regards,
> > > > Andrey V. Mashenkov
> > > >
> > >
> > >
> > > --
> > > Best regards,
> > > Andrey V. Mashenkov
> > >
> >
>
>
> --
> Best regards,
> Andrey V. Mashenkov
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

Pavel, good point.
Thanks. I've added async methods.

On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <pt...@apache.org> wrote:

> Andrey,
>
> What about corresponding async APIs, do we add them now or later?
>
> On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <
> andrey.mashenkov@gmail.com>
> wrote:
>
> > Hi Igniters.
> >
> > I've created a PR for Table access API [1].
> > This is an initial version. So, any suggestions\objections are welcomed.
> > Please, do not hesitate to write your comments and\or examples to the PR.
> >
> > Ignite-api module contains API classes, e.g. TableView classes as
> > projections for a table for different purposes.
> > Ignite-table contains dummy implementation and Example class explained
> how
> > it is supposed to be used.
> >
> >
> > Also, I'm still waiting for any feedback for Schema configuration public
> > API PR [2].
> >
> > [1] https://github.com/apache/ignite-3/pull/33
> > [2] https://github.com/apache/ignite-3/pull/2
> >
> > On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> > andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> > >> >> ptupitsyn@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.goncharuk@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.mashenkov@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 <
> > >> >> > > > > ptupitsyn@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.mashenkov@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
> <
> > >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> > >> >> > > > > > > isapego@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 <
> > >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> > >> >> > <
> > >> >> > > > > > > > > > > > ptupitsyn@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 <
> > >> >> > > > > > > > > > > isapego@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
> > >> >> > > > <
> > >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> > >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> > >> >> > > > > > > > <
> > >> >> > > > > > > > > > > > > > > > > > vololo100@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
> > >> >> > > > > <
> > >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> > >> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> vololo100@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 <
> > >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> dmagda@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.kulichenko@gmail.com>
> > >> >> > > > > > > > > > > > > wrote:
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> Igniters,
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > One
> > of
> > >> the
> > >> >> > big
> > >> >> > > > > > changes
> > >> >> > > > > > > > > > proposed
> > >> >> > > > > > > > > > > > for
> > >> >> > > > > > > > > > > > > > > > Ignite
> > >> >> > > > > > > > > > > > > > > > > > 3.0
> > >> >> > > > > > > > > > > > > > > > > > > is
> > >> >> > > > > > > > > > > > > > > > > > > > > the
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > so-called
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> "schema-first
> > >> >> > > > > > > approach".
> > >> >> > > > > > > > To
> > >> >> > > > > > > > > > add
> > >> >> > > > > > > > > > > > > more
> > >> >> > > > > > > > > > > > > > > > > clarity,
> > >> >> > > > > > > > > > > > > > > > > > > > I've
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > started
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > writing
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > the
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > IEP
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > > for
> > >> this
> > >> >> > > change:
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > >
> > >> >> > > > > > > > > > > >
> > >> >> > > > > > > > > > >
> > >> >> > > > > > > > > >
> > >> >> > > > > > > > >
> > >> >> > > > > > > >
> > >> >> > > > > > >
> > >> >> > > > > >
> > >> >> > > > >
> > >> >> > > >
> > >> >> > >
> > >> >> >
> > >> >>
> > >>
> >
> https://cwiki.apache.org/confluence/display/IGNITE/IEP-54%3A+Schema-first+Approach
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > Please
> > >> >> take a
> > >> >> > > > look
> > >> >> > > > > > and
> > >> >> > > > > > > > let
> > >> >> > > > > > > > > me
> > >> >> > > > > > > > > > > > know
> > >> >> > > > > > > > > > > > > if
> > >> >> > > > > > > > > > > > > > > > there
> > >> >> > > > > > > > > > > > > > > > > > are
> > >> >> > > > > > > > > > > > > > > > > > > > any
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> immediate
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> thoughts,
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> suggestions,
> > >> >> > or
> > >> >> > > > > > > > objections.
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> -Val
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> --
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Best
> > regards,
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >> Ivan
> > Pavlukhin
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > --
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Best regards,
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > > Ivan
> Pavlukhin
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>> >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >>
> > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > --
> > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > > > > > > > > > > > > > Ivan Pavlukhin
> > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > > > --
> > >> >> > > > > > > > > > > > > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > > > --
> > >> >> > > > > > > > > > > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > > > --
> > >> >> > > > > > > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > >
> > >> >> > > > > > > > > > > > > --
> > >> >> > > > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > > > > > >
> > >> >> > > > > > > > > > > >
> > >> >> > > > > > > > > > >
> > >> >> > > > > > > > > > >
> > >> >> > > > > > > > > > > --
> > >> >> > > > > > > > > > > Best regards,
> > >> >> > > > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > > > >
> > >> >> > > > > > > > > >
> > >> >> > > > > > > > >
> > >> >> > > > > > > > >
> > >> >> > > > > > > > > --
> > >> >> > > > > > > > > Best regards,
> > >> >> > > > > > > > > Andrey V. Mashenkov
> > >> >> > > > > > > > >
> > >> >> > > > > > > >
> > >> >> > > > > > >
> > >> >> > > > > >
> > >> >> > > > >
> > >> >> > > > >
> > >> >> > > > > --
> > >> >> > > > > Живи с улыбкой! :D
> > >> >> > > > >
> > >> >> > > >
> > >> >> > > >
> > >> >> > > > --
> > >> >> > > > Best regards,
> > >> >> > > > Andrey V. Mashenkov
> > >> >> > > >
> > >> >> > >
> > >> >> >
> > >> >>
> > >> >
> > >>
> > >
> > >
> > > --
> > > Best regards,
> > > Andrey V. Mashenkov
> > >
> >
> >
> > --
> > Best regards,
> > Andrey V. Mashenkov
> >
>


-- 
Best regards,
Andrey V. Mashenkov

Re: IEP-54: Schema-first approach for 3.0

[Pavel Tupitsyn <pt...@apache.org>]

Andrey,

What about corresponding async APIs, do we add them now or later?

On Thu, Mar 11, 2021 at 8:11 PM Andrey Mashenkov <an...@gmail.com>
wrote:

> Hi Igniters.
>
> I've created a PR for Table access API [1].
> This is an initial version. So, any suggestions\objections are welcomed.
> Please, do not hesitate to write your comments and\or examples to the PR.
>
> Ignite-api module contains API classes, e.g. TableView classes as
> projections for a table for different purposes.
> Ignite-table contains dummy implementation and Example class explained how
> it is supposed to be used.
>
>
> Also, I'm still waiting for any feedback for Schema configuration public
> API PR [2].
>
> [1] https://github.com/apache/ignite-3/pull/33
> [2] https://github.com/apache/ignite-3/pull/2
>
> On Wed, Jan 20, 2021 at 6:05 PM Andrey Mashenkov <
> andrey.mashenkov@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> >> >> ptupitsyn@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.goncharuk@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.mashenkov@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 <
> >> >> > > > > ptupitsyn@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.mashenkov@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 <
> >> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> >> >> > > > > > > isapego@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 <
> >> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> >> >> > <
> >> >> > > > > > > > > > > > ptupitsyn@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 <
> >> >> > > > > > > > > > > isapego@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
> >> >> > > > <
> >> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> >> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> >> >> > > > > > > > <
> >> >> > > > > > > > > > > > > > > > > > vololo100@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
> >> >> > > > > <
> >> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> >> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> >> >> > > > > > > > > > > > > > > > > > > > > > > >>> vololo100@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 <
> >> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> >> > > > > > > > > > > > > > > > > > > > > > > >>> dmagda@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.kulichenko@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
>

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

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 <an...@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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
>> >> ptupitsyn@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.goncharuk@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.mashenkov@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 <
>> >> > > > > ptupitsyn@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.mashenkov@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 <
>> >> > > > > > > ptupitsyn@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.mashenkov@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 <
>> >> > > > > > > isapego@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 <
>> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
>> >> > <
>> >> > > > > > > > > > > > ptupitsyn@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 <
>> >> > > > > > > > > > > isapego@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
>> >> > > > <
>> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
>> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
>> >> > > > > > > > <
>> >> > > > > > > > > > > > > > > > > > vololo100@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
>> >> > > > > <
>> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
>> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
>> >> > > > > > > > > > > > > > > > > > > > > > > >>> vololo100@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 <
>> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
>> >> > > > > > > > > > > > > > > > > > > > > > > >>> dmagda@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.kulichenko@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

Re: IEP-54: Schema-first approach for 3.0

[Andrey Mashenkov <an...@gmail.com>]

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.goncharuk@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.goncharuk@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.cherkasov@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.kulichenko@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.cherkasov@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.mashenkov@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.gerzhedowich@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.goncharuk@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 <
> >> ptupitsyn@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.goncharuk@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.mashenkov@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 <
> >> > > > > ptupitsyn@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.mashenkov@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 <
> >> > > > > > > ptupitsyn@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.mashenkov@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 <
> >> > > > > > > isapego@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 <
> >> > > > > > > > > > ptupitsyn@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.mashenkov@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
> >> > <
> >> > > > > > > > > > > > ptupitsyn@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 <
> >> > > > > > > > > > > isapego@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
> >> > > > <
> >> > > > > > > > > > > > > > ptupitsyn@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.mashenkov@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 <
> >> > > > > > > > > > > > > dmagda@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.mashenkov@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
> >> > > > > > > > <
> >> > > > > > > > > > > > > > > > > > vololo100@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
> >> > > > > <
> >> > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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.goncharuk@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 <
> >> > > > > > > > > > > > > > > > > > > > > vololo100@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.kulichenko@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 <
> >> > > > > > > > > > > > > > > > > > > > > > > >>> vololo100@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 <
> >> > > > > > > > > > > > > > > > > > > > dmagda@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.kulichenko@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 <
> >> > > > > > > > > > > > > > > > > > > > > > > >>> dmagda@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.kulichenko@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