IEP-54: Schema-first approach for 3.0

[StephanieSy]

That's the same case for me!. I've just downgraded my typescript version and
everything starts working. How did you notice that the typescript's version
was the problem?



--
Sent from: http://apache-ignite-developers.2346864.n4.nabble.com/

[Andrew Mashenkov]

Hi Igniters,

I and Alex Scherbakov had a discussion on how we could write rows in a more
compact way.
Many thanks to Alex for his ideas and critics.
So, in a long-read below I want to share some thoughts.

Motivation.

In Ignite 3.0 we will have versioned schema and most of the meta info will
be stored in the schema.
This approach gives lesser overheard on row size comparing to BinatyObject
in Ignite 2.0,
but I see we can still save up to 5-25% in some use cases that look
promising.

Apparently, there always is a trade-off between row footprint, field access
performance, and code complexity.
We won't fight to the death for every single byte, but for a relatively low
row footprint overhead.
but still can have different formats/technics for writing compact meta
(sizes, offsets ...) to cover common use cases.

Description.

Ignite table/index operations (but not only them) performance correlates
with the key size.
Because of this, we recommend having the smallest keys as possible, and
small keys like long, UUID, or short strings are widely used.

Value size may differ and depends on the use case. AFAIK some user needs
MB+ sized values.
I don't know if any corner cases take place in production, such as 100+
varlen short columns (especially short) or huge values, or keys > 64kb.
and if they are relevant to Ignite goals and target auditory.

Below I use the term 'chunk' meaning a key or value byte sequence.

Points and technics to save few bytes:
* Chunk size.
If the key is a single long value then using a single byte instead of short
may reduce overhead twice (25% -> 12%).

* Vartable item size (varlen column offset or varlen column size).
Here we can save noticeable amount of byte if the user has many short
varlen columns.
E.g. 10 short strings of 10 bytes (100 in total) can save 10%.

* Using varlen column sizes instead of offsets.
We can use items of 'byte' even if total chunk size do not fit into a byte.
E.g. if the user has 30 strings each of 10 chars (300 bytes in total) then
using 'sizes' of byte (instead of short) here we could save 10%.
This increases complexity (up to linear) to column offset calculation, but
I think we shouldn't bother about performance impact here.
Because CPU is cheap here: vartable items resides locally and in most cases
(32-64) varlen column sizes can fit into one cache line
and calculations can be effectively vectorized.

* Use 'varInt' format for sizes.
Shortly: VarInt format implies we use a sign bit as a flag if a data spans
over more bytes or not.
So, positive byte means byte value. A negative byte means value spans for
more bytes and we have to drop the sign bit and concat the rest 7-bits with
the next byte.
Thus, if a number fits a smaller type then we can use lesser bytes to store
it.
Total chunk size calculation may be a bit tricky

* Strings size precalculation.
The problem is we need to analyze characters to estimate string size before
start key/value serialization.
We can estimate sizes for long strings though, e.g. check symbol-by-symbol
for strings of 64-255, as char[63] will always fit byte[255] and char[256]
will never fit byte[255].
(with varInt format 32-127 bounds can be used).

There are other more restrictive ways:

* Varlen table (vartable) size of byte.
Does one need more than 255 varlen columns? E.g. Oracle has a limit of 1000
total columns.
Actually, the impact is low enough, we can save a byte per-varlen column.
Moreover, we already have optimization to skip the first varlen offset (or
last varlen length).
So, we will not write a vartable for a single varlen column in a chunk.

* Restrict varlen sizes to 64kb and introduce BLOB type for varlength >
64kb.
This allows excluding cases with items of 'int' in vartable. Therefore,
reduces the number of flags, chunk reader/writer implementations, and
overall code complexity.
I'd suggest discussing BLOB type in a separate thread and implements
separately.
Shortly, we can store BLOB 'uuid' in a row instead, and store BLOB content
in separate storage. RowAssembler can write row bytes and pairs
('uuid','content') separately to different arrays. The transport protocol
should be aware of BLOBs.

* Alex idea. We can have 2 varlen tables for small (len of < 255 bytes) and
large varlens (len of < 64k) with byte and short offsets correspondingly.
It is assumed varlen columns are sorted by their types (e.g. shorter first).
Thus can be effective if the user have a number of small varlens and a
larger one. The larger one will force us to use longer vartable items.
The drawback is a user must define max-length constraint for varlens
columns at a schema declaration step to turn on optimization for columns of
short types.
Because column order is defined in the schema, we can't resort to columns
for row in runtime and apply optimization for short values of long-type
columns.
E.g. user defines VARCHAR(1024) column in a schema and pass a short value
of 10 chars, we can't use first vartable item for that string as a second
vartable must be used with 10% overhead.

IMHO: user won't bother about String sizes (localize string size estimation
is hard) and will not get any benefits in many cases.
Life-schema concept which is designed for automatic schema management,
de-facto will become a semi-automatic, as every Ignite user desire a max
performance.

So, questions are:
1. Do we want to support varlen columns number >255?
2. Are we ok with the BLOB idea and max varlen size of 64kb?
3. Are we ok with varInt for chunk (and/or vartable) size?
4. What about the idea with 2 vartables? Will we prefer optimization based
on schema rather than row content?


Any other use cases or ideas or thoughts?

On Wed, May 26, 2021 at 3:00 PM StephanieSy <[hidden email]> wrote:

> That's the same case for me!. I've just downgraded my typescript version
> and
> everything starts working. How did you notice that the typescript's version
> was the problem?
>
>
>
> --
> Sent from: http://apache-ignite-developers.2346864.n4.nabble.com/
>

--
Best regards,
Andrey V. Mashenkov

[Ilya Kasnacheev]

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 <[hidden email]>:

> >
> > 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 <[hidden email]
> >
> 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 <[hidden email]
> >:
> >
> > > 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 <
> > [hidden email]
> > > >
> > > 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 <
> > [hidden email]
> > > >:
> > > >
> > > > > 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 <
> > > > > [hidden email]>
> > > > > 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 <
> > > [hidden email]>
> > > > > > 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 <
> > > > > >> [hidden email]> 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 <
> > > > [hidden email]
> > > > > >
> > > > > >> > 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 <
> > > > > >> > > [hidden email]> wrote:
> > > > > >> > >
> > > > > >> > > > Pavel, good point.
> > > > > >> > > > Thanks. I've added async methods.
> > > > > >> > > >
> > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > >> [hidden email]>
> > > > > >> > > > 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 <
> > > > > >> > > > > [hidden email]>
> > > > > >> > > > > 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 <
> > > > > >> > > > > > [hidden email]>
> > > > > >> > > > > > 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 <
> > > > > >> > > > > > > [hidden email]> 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 <
> > > > > >> > > > > > [hidden email]
> > > > > >> > > > > > >> >:
> > > > > >> > > > > > >>
> > > > > >> > > > > > >> > 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 <
> > > > > >> > > > > > >> > [hidden email]>:
> > > > > >> > > > > > >> >
> > > > > >> > > > > > >> >> 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 <
> > > > > >> > > > > > >> >> [hidden email]>:
> > > > > >> > > > > > >> >>
> > > > > >> > > > > > >> >> > 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 <
> > > > > >> > > > > > >> >> > [hidden email]> 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
> > <
> > > > > >> > > > > > >> >> > [hidden email]
> > > > > >> > > > > > >> >> > > >:
> > > > > >> > > > > > >> >> > >
> > > > > >> > > > > > >> >> > > > 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 Юрий <
> > > > > >> > > > > > >> [hidden email]>
> > > > > >> > > > > > >> >> > > 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 <
> > > > > >> > > > > > >> >> > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > >:
> > > > > >> > > > > > >> >> > > > >
> > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > >> > > > > > >> >> [hidden email]
> > > > > >> > > > > > >> >> > >:
> > > > > >> > > > > > >> >> > > > > >
> > > > > >> > > > > > >> >> > > > > > > > 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
> > > > > >> > <
> > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > 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
> > > > > >> > <
> > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > >:
> > > > > >> > > > > > >> >> > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > >> > > <
> > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > >> > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > 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
> > > > > >> > > > > <
> > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > 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
> > > > > >> > > > > > >> <
> > > > > >> > > > > > >> >> > > > > > > > > > > >
> [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> > [hidden email]
> > > > > >> > > >
> > > > > >> > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > [hidden email]
> > > > > >> > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > [hidden email]
> > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > 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
> > > > > >> > > > > > >> >> > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> 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
> > > > > >> > > > > > >> >> > > > > > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> [hidden email]>
> > > > > >> > > > > > >> >> > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > > > >> >> > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > > > > >> > > > > > >> >> [hidden email]
> > > > > >> > > > > > >> >> > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > >> [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > 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
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > >:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >
> > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >:
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >>
> > > > > >> > > > > 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
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> >
> > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > >> > > > > > >> >> > > > > > > > >
> > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> > > > > >> > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > > >> 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 <
> > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >>>
> >
> > >
> > > >
> > > > >>
> > > > > >> >> >
> > > > > >> > > > > > >> >> > > > > > > > > [hidden email]>
> > > > > >> > > > > > >> >> > > > > > > > > > > > > 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
>

[Andrew Mashenkov]

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 <[hidden email]>
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 <[hidden email]>:
>
> > >
> > > 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 <
> [hidden email]
> > >
> > 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 <
> [hidden email]
> > >:
> > >
> > > > 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 <
> > > [hidden email]
> > > > >
> > > > 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 <
> > > [hidden email]
> > > > >:
> > > > >
> > > > > > 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 <
> > > > > > [hidden email]>
> > > > > > 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 <
> > > > [hidden email]>
> > > > > > > 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 <
> > > > > > >> [hidden email]> 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 <
> > > > > [hidden email]
> > > > > > >
> > > > > > >> > 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 <
> > > > > > >> > > [hidden email]> wrote:
> > > > > > >> > >
> > > > > > >> > > > Pavel, good point.
> > > > > > >> > > > Thanks. I've added async methods.
> > > > > > >> > > >
> > > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > > >> [hidden email]>
> > > > > > >> > > > 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 <
> > > > > > >> > > > > [hidden email]>
> > > > > > >> > > > > 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 <
> > > > > > >> > > > > > [hidden email]>
> > > > > > >> > > > > > 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
> <
> > > > > > >> > > > > > > [hidden email]> 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 <
> > > > > > >> > > > > > [hidden email]
> > > > > > >> > > > > > >> >:
> > > > > > >> > > > > > >>
> > > > > > >> > > > > > >> > 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
> <
> > > > > > >> > > > > > >> > [hidden email]>:
> > > > > > >> > > > > > >> >
> > > > > > >> > > > > > >> >> 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 <
> > > > > > >> > > > > > >> >> [hidden email]>:
> > > > > > >> > > > > > >> >>
> > > > > > >> > > > > > >> >> > 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 <
> > > > > > >> > > > > > >> >> > [hidden email]> 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
> > > <
> > > > > > >> > > > > > >> >> > [hidden email]
> > > > > > >> > > > > > >> >> > > >:
> > > > > > >> > > > > > >> >> > >
> > > > > > >> > > > > > >> >> > > > 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 Юрий <
> > > > > > >> > > > > > >> [hidden email]>
> > > > > > >> > > > > > >> >> > > 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 <
> > > > > > >> > > > > > >> >> > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > >:
> > > > > > >> > > > > > >> >> > > > >
> > > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > > >> > > > > > >> >> [hidden email]
> > > > > > >> > > > > > >> >> > >:
> > > > > > >> > > > > > >> >> > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > 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
> > > > > > >> > <
> > > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > 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
> > > > > > >> > <
> > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > >:
> > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > > >> > > <
> > > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > > >> > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > 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
> > > > > > >> > > > > <
> > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > 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
> > > > > > >> > > > > > >> <
> > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > 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
> > > > > > >> > > > > > >> >> > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > > >> > > > > > >> >> > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > > >> > > > > > >> >> > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> > [hidden email]
> > > > > > >> > > >
> > > > > > >> > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > 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
> > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > [hidden email]
> > > > > > >> > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > 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
> > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > [hidden email]
> > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> 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
> > > > > > >> > > > > > >> >> > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > 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
> > > > > > >> > > > > > >> >> > > > > > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> [hidden email]>
> > > > > > >> > > > > > >> >> > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > > > >> >> > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > > > > >> > > > > > >> >> [hidden email]
> > > > > > >> > > > > > >> >> > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > >> [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > 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
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > >:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >
> > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >:
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >>
> > > > > > >> > > > > 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
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> >
> > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > > > > > >> > > > [hidden email]>
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > > >> 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 <
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >>>
> > >
> > > >
> > > > >
> > > > > >>
> > > > > > >> >> >
> > > > > > >> > > > > > >> >> > > > > > > > > [hidden email]
> >
> > > > > > >> > > > > > >> >> > > > > > > > > > > > > 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

[Ilya Kasnacheev]

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 <[hidden email]>:

> 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 <
> [hidden email]>
> 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 <[hidden email]
> >:
> >
> > > >
> > > > 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 <
> > [hidden email]
> > > >
> > > 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 <
> > [hidden email]
> > > >:
> > > >
> > > > > 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 <
> > > > [hidden email]
> > > > > >
> > > > > 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 <
> > > > [hidden email]
> > > > > >:
> > > > > >
> > > > > > > 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 <
> > > > > > > [hidden email]>
> > > > > > > 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 <
> > > > > [hidden email]>
> > > > > > > > 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 <
> > > > > > > >> [hidden email]> 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 <
> > > > > > [hidden email]
> > > > > > > >
> > > > > > > >> > 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 <
> > > > > > > >> > > [hidden email]> wrote:
> > > > > > > >> > >
> > > > > > > >> > > > Pavel, good point.
> > > > > > > >> > > > Thanks. I've added async methods.
> > > > > > > >> > > >
> > > > > > > >> > > > On Fri, Mar 12, 2021 at 2:29 PM Pavel Tupitsyn <
> > > > > > > >> [hidden email]>
> > > > > > > >> > > > 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 <
> > > > > > > >> > > > > [hidden email]>
> > > > > > > >> > > > > 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 <
> > > > > > > >> > > > > > [hidden email]>
> > > > > > > >> > > > > > 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
> > <
> > > > > > > >> > > > > > > [hidden email]> 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 <
> > > > > > > >> > > > > > [hidden email]
> > > > > > > >> > > > > > >> >:
> > > > > > > >> > > > > > >>
> > > > > > > >> > > > > > >> > 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
> > <
> > > > > > > >> > > > > > >> > [hidden email]>:
> > > > > > > >> > > > > > >> >
> > > > > > > >> > > > > > >> >> 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 <
> > > > > > > >> > > > > > >> >> [hidden email]>:
> > > > > > > >> > > > > > >> >>
> > > > > > > >> > > > > > >> >> > 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 <
> > > > > > > >> > > > > > >> >> > [hidden email]> 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
> > > > <
> > > > > > > >> > > > > > >> >> > [hidden email]
> > > > > > > >> > > > > > >> >> > > >:
> > > > > > > >> > > > > > >> >> > >
> > > > > > > >> > > > > > >> >> > > > 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 Юрий <
> > > > > > > >> > > > > > >> [hidden email]>
> > > > > > > >> > > > > > >> >> > > 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 <
> > > > > > > >> > > > > > >> >> > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > >:
> > > > > > > >> > > > > > >> >> > > > >
> > > > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > > > >> > > > > > >> >> [hidden email]
> > > > > > > >> > > > > > >> >> > >:
> > > > > > > >> > > > > > >> >> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > 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
> > > > > > > >> > <
> > > > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > 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
> > > > > > > >> > <
> > > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > >:
> > > > > > > >> > > > > > >> >> > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > > > >> > > <
> > > > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > 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
> > > > > > > >> > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > >
> [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > 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
> > > > > > > >> > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > 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
> > > > > > > >> > > > > > >> <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > 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
> > > > > > > >> > > > > > >> >> > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > > > >> > > > > > >> >> > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > 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
> > > > > > > >> > > > > > >> >> > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > >
> > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > >> > [hidden email]
> > > > > > > >> > > >
> > > > > > > >> > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > 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
> > > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > [hidden email]
> > > > > > > >> > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> 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
> > > > > > > >> > > > > > >> >> > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > >
> > > > > [hidden email]
> > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >
> > 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
> > > > > > > >> > > > > > >> >> > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > >:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >
> > > 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
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> >
> > > > > > > >> > > > > > >> >> [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > >
> > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > > > >> >> > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > > > > >> > > > > > >> >> [hidden email]
> > > > > > > >> > > > > > >> >> > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > >
> > > > > > > >> [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > 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
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> > > > > > >> >> > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > >:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >
> > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > >
> > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > >:
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >>
> > > > > > > >> > > > > 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
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> >
> > > > > > > >> > > > > > >> >> > > > > > > [hidden email]
> > > > > > > >> > > > > > >> >> > > > > > > > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > > > > > >> > > > [hidden email]>
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > > >> 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 <
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > > > > > > > > > > >
> > >>>
> > > >
> > > > >
> > > > > >
> > > > > > >>
> > > > > > > >> >> >
> > > > > > > >> > > > > > >> >> > > > > > > > >
> [hidden email]
> > >
> > > > > > > >> > > > > > >> >> > > > > > > > > > > > > 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
>