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

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
>