[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16752716#comment-16752716
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=- Run :: SQL: No blockers
found!|borderStyle=dashed|borderColor=#ccc|titleBGColor=#D6F7C1}{panel}
[TeamCity *- Run :: SQL*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2909445buildTypeId=IgniteTests24Java8_RunAllSql]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16752507#comment-16752507 ] Pavel Kuznetsov commented on IGNITE-10645: -- Upd: merged master and re-enabled test again. RunAllSql is scheduled. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16752477#comment-16752477
]
Pavel Kuznetsov commented on IGNITE-10645:
--
Marked
{{IgniteCacheSqlInsertValidationSelfTest.testMixedPlaceholderWithOtherKeyFields}}
as {{@Ignored}}
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16752313#comment-16752313
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Cache (Restarts) 2{color} [[tests
3|https://ci.ignite.apache.org/viewLog.html?buildId=2905388]]
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicPutAllFailoverSelfTest.testPutAllFailoverNearEnabledOneBackup
- 0,0% fails in last 409 master runs.
{color:#d04437}Queries 1{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2905418]]
* IgniteBinaryCacheQueryTestSuite:
IgniteCacheSqlInsertValidationSelfTest.testMixedPlaceholderWithOtherKeyFields
{color:#d04437}MVCC Queries{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2905375]]
* IgniteCacheMvccSqlTestSuite:
CacheMvccPartitionedSqlTxQueriesTest.testAccountsTxDmlSql_WithRemoves_ClientServer_Backups1_Persistence
- 0,0% fails in last 417 master runs.
{color:#d04437}Cache 7{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2905396]]
* IgniteCacheTestSuite7:
TxRollbackAsyncWithPersistenceTest.testMixedAsyncRollbackTypes - 0,0% fails in
last 406 master runs.
{color:#d04437}Compute (Grid){color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2905335]]
* IgniteBinaryObjectsComputeGridTestSuite:
IgniteComputeCustomExecutorSelfTest.testAllComputeApiByCustomExecutor - 0,0%
fails in last 484 master runs.
{color:#d04437}Basic 2{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2905329]]
* IgniteComputeBasicConfigVariationsFullApiTestSuite:
IgniteComputeConfigVariationsFullApiTest_47.testDeployExecuteByName - 0,0%
fails in last 6 master runs.
{color:#d04437}MVCC PDS 2{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2905438]]
* IgnitePdsMvccTestSuite2:
IgniteWalReaderTest.testArchiveIncompleteSegmentAfterInactivity - 0,0% fails in
last 419 master runs.
{color:#d04437}Spring{color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2905353]]
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2905441buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16752196#comment-16752196
]
Pavel Kuznetsov commented on IGNITE-10645:
--
Failed tests from {{IgniteCacheMergeSqlQuerySelfTest}} and
{{IgniteCacheUpdateSqlQuerySelfTest}} caused by master merge. Merged master
again, scheduled tests re-run to be 100% sure.
[~vozerov] think It's ready for review now.
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16750633#comment-16750633
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Cache (Restarts) 1{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2887947]]
* IgniteCacheRestartTestSuite:
GridCachePartitionedNodeRestartTest.testRestartWithTxTwoNodesOneBackup - 0,0%
fails in last 395 master runs.
{color:#d04437}Cache (Restarts) 2{color} [[tests
3|https://ci.ignite.apache.org/viewLog.html?buildId=2887948]]
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithPutTenNodesTwoBackups
- 0,0% fails in last 409 master runs.
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithPutFourNodesNoBackups
- 0,0% fails in last 409 master runs.
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithTxPutAllTenNodesTwoBackups
- 0,0% fails in last 409 master runs.
{color:#d04437}Queries 1{color} [[tests
3|https://ci.ignite.apache.org/viewLog.html?buildId=2887978]]
* IgniteBinaryCacheQueryTestSuite:
IgniteCacheUpdateSqlQuerySelfTest.testSingleInnerFieldUpdate - 0,2% fails in
last 413 master runs.
* IgniteBinaryCacheQueryTestSuite:
IgniteCacheUpdateSqlQuerySelfTest.testTypeConversions - 0,2% fails in last 413
master runs.
* IgniteBinaryCacheQueryTestSuite:
IgniteCacheMergeSqlQuerySelfTest.testNestedFieldsHandling - 0,2% fails in last
413 master runs.
{color:#d04437}PDS (Indexing){color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2887966]]
* IgnitePdsWithIndexingCoreTestSuite:
IgnitePdsThreadInterruptionTest.testInterruptsOnWALWrite - 0,0% fails in last
413 master runs.
{color:#d04437}ZooKeeper (Discovery) 3{color} [[tests
9|https://ci.ignite.apache.org/viewLog.html?buildId=2887982]]
* ZookeeperDiscoverySpiTestSuite3:
GridEventConsumeSelfTest.testRemoteProjection - 0,0% fails in last 400 master
runs.
{color:#d04437}MVCC Queries{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2887935]]
* IgniteCacheMvccSqlTestSuite:
CacheMvccPartitionedSqlQueriesTest.testAccountsTxSql_SingleNode_Persistence -
0,0% fails in last 416 master runs.
{color:#d04437}Cache 7{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2887956]]
* IgniteCacheTestSuite7:
TxRollbackAsyncWithPersistenceTest.testSynchronousRollback - 0,0% fails in last
406 master runs.
{color:#d04437}Examples (LGPL){color} [[tests
6|https://ci.ignite.apache.org/viewLog.html?buildId=2887984]]
* IgniteLgplExamplesSelfTestSuite:
ComputeScheduleExampleSelfTest.testComputeScheduleExample - 0,2% fails in last
401 master runs.
* IgniteLgplExamplesSelfTestSuite:
SpatialQueryExampleSelfTest.testSpatialQueryExample - 0,2% fails in last 401
master runs.
* IgniteLgplExamplesSelfTestSuite:
HibernateL2CacheExampleSelfTest.testHibernateL2CacheExample - 0,2% fails in
last 401 master runs.
* IgniteLgplExamplesSelfTestSuite:
SpatialQueryExampleMultiNodeSelfTest.testSpatialQueryExample - 0,2% fails in
last 401 master runs.
* IgniteLgplExamplesSelfTestSuite:
ComputeScheduleExampleMultiNodeSelfTest.testComputeScheduleExample - 0,2% fails
in last 401 master runs.
* IgniteLgplExamplesSelfTestSuite:
HibernateL2CacheExampleMultiNodeSelfTest.testHibernateL2CacheExample - 0,2%
fails in last 401 master runs.
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2888001buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16750082#comment-16750082 ] Vladimir Ozerov commented on IGNITE-10645: -- [~pkouznet], my comments: # We should remove new restriction, as it may break existing applications # Please either provide TC visa on confirm that new failures are not related to the PR. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16748781#comment-16748781
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}ZooKeeper (Discovery) 1{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2869956]]
* ZookeeperDiscoverySpiTestSuite1:
ZookeeperDiscoverySegmentationAndConnectionRestoreTest.testSegmentation2 - 0,0%
fails in last 76 master runs.
{color:#d04437}Cache (Restarts) 1{color} [[tests
13|https://ci.ignite.apache.org/viewLog.html?buildId=2869979]]
* IgniteCacheRestartTestSuite: GridCachePartitionedNodeRestartTest.testRestart
- 0,0% fails in last 575 master runs.
* IgniteCacheRestartTestSuite:
GridCachePartitionedNodeRestartTest.testRestartWithPutTwoNodesNoBackups - 0,0%
fails in last 575 master runs.
* IgniteCacheRestartTestSuite:
GridCachePartitionedNodeRestartTest.testRestartWithTxTwoNodesOneBackup - 0,0%
fails in last 575 master runs.
* IgniteCacheRestartTestSuite:
GridCachePartitionedNodeRestartTest.testRestartWithPutTwoNodesOneBackup - 0,0%
fails in last 575 master runs.
{color:#d04437}MVCC Queries{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2869967]]
* IgniteCacheMvccSqlTestSuite:
CacheMvccReplicatedSqlTxQueriesTest.testAccountsTxDmlSql_SingleNode_Persistence
- 0,0% fails in last 620 master runs.
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2870033buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16746170#comment-16746170 ] Pavel Kuznetsov commented on IGNITE-10645: -- [~vozerov] This check was added because I've simplified condition (https://github.com/apache/ignite/pull/5657/commits/bed7b76ade5990f4392e1169b060ef82dc67f3fe but note that comment would change one more time). If key is of sql type, we put it itself into the cache. As we discussed, key itself is not a key field, so isKeyField value in this case should be false. We relied on this fact in the jdbc metadata for example. If we duplicate keyFieldName in the list of keyFields then isKeyField value of the binary property will be true. Keeping in mind that configuration, having both keyFieldName and keyFields is contradictory, I forbid it. Other options: 1) Return old condition 2) Start thinking that key object itself is a keyField. Even more - start building KeyValueProperty for this field instead of BinaryProperty. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16742002#comment-16742002
]
Vladimir Ozerov commented on IGNITE-10645:
--
[~pkouznet], my comments:
# {{QueryUtils.processBinaryMeta}} - what is the reason to add
{{!F.isEmpty(keyFields) && isKeyClsSqlType}} check? Will it be valid when _KEY
alias is set? It is not obvious how this check is related to the problem
described in the ticket
The rest looks fine.
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16738201#comment-16738201
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=- Run :: Cache: No blockers
found!|borderStyle=dashed|borderColor=#ccc|titleBGColor=#D6F7C1}{panel}
[TeamCity *- Run :: Cache*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2751321buildTypeId=IgniteTests24Java8_RunCache]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16738103#comment-16738103
]
Pavel Kuznetsov commented on IGNITE-10645:
--
Fixed test {{CacheBinaryKeyConcurrentQueryTest.testPutAndQueries}}.
[~vozerov] Ready for the review.
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16730793#comment-16730793
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Cache 5{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2679781]]
* IgniteCacheWithIndexingTestSuite:
CacheBinaryKeyConcurrentQueryTest.testPutAndQueries - 0,0% fails in last 407
master runs.
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2679815buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16730772#comment-16730772
]
Pavel Kuznetsov commented on IGNITE-10645:
--
[~vozerov] Yes, there were 2 tests with incorrect configurations, fixed them
(python and {{CacheBinaryKeyConcurrentQueryTest.testPutAndQueries}} )
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16730235#comment-16730235 ] Vladimir Ozerov commented on IGNITE-10645: -- [~pkouznet], looks like we have new failures, are we? Please re-run and confirm that all above mentioned failures are not regressions. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16729255#comment-16729255
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Cache 5{color} [[tests
2|https://ci.ignite.apache.org/viewLog.html?buildId=2653576]]
* IgniteCacheWithIndexingTestSuite:
CacheBinaryKeyConcurrentQueryTest.testPutAndQueries - 0,0% fails in last 374
master runs.
{color:#d04437}Cache (Restarts) 2{color} [[tests
4|https://ci.ignite.apache.org/viewLog.html?buildId=2653570]]
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicNodeRestartTest.testRestartWithPutEightNodesTwoBackups - 0,0%
fails in last 398 master runs.
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicNodeRestartTest.testRestartWithTxTwoNodesOneBackup - 0,0%
fails in last 398 master runs.
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicNodeRestartTest.testRestartWithTxSixNodesTwoBackups - 0,0%
fails in last 398 master runs.
* IgniteCacheRestartTestSuite2:
IgniteCacheAtomicNodeRestartTest.testRestartWithTxFourNodesOneBackups - 0,0%
fails in last 398 master runs.
{color:#d04437}Data Structures{color} [[tests
3|https://ci.ignite.apache.org/viewLog.html?buildId=2653584]]
* IgniteCacheDataStructuresSelfTestSuite:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithTxPutAllTenNodesTwoBackups
- 0,0% fails in last 363 master runs.
* IgniteCacheDataStructuresSelfTestSuite:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithPutTenNodesTwoBackups
- 0,0% fails in last 363 master runs.
* IgniteCacheDataStructuresSelfTestSuite:
IgniteCacheAtomicReplicatedNodeRestartSelfTest.testRestartWithPutFourNodesNoBackups
- 0,0% fails in last 363 master runs.
{color:#d04437}Platform C++ (Linux Clang){color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2653554]]
{color:#d04437}Thin client: Python{color} [[tests 1 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2653601]]
*
tests.test_binary.test_sql_write_as_binary[localhost-None-_SSLMethod_PROTOCOL_TLSv1_1-None-None-0-10800-False-None-ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:!aNULL:!eNULL:!MD5-None-None]
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2653608buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
> Fix For: 2.8
>
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16729058#comment-16729058 ] Pavel Kuznetsov commented on IGNITE-10645: -- Reverted validation code. Updated expected exception messages. [~vozerov] done! > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16729018#comment-16729018 ] Pavel Kuznetsov commented on IGNITE-10645: -- Ok, I've created IGNITE-10824 > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16728986#comment-16728986 ] Vladimir Ozerov commented on IGNITE-10645: -- [~pkouznet], my comments: # We need to make sure that any DML command doesn't not allow simultaneous update of _KEY, key alias, and key fields. Same for values. Most probably this needs to be done in separate ticket # Double-check messages in existing tests > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > Fix For: 2.8 > > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16726762#comment-16726762
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=-- Run :: All: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Spring{color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2611979]]
{color:#d04437}Hibernate 5.1{color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2611968]]
{color:#d04437}Hibernate 4.2{color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2611967]]
{color:#d04437}Thin client: Python{color} [[tests 1 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2612045]]
*
tests.test_binary.test_sql_write_as_binary[None-None-None-0-None-ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+HIGH:DH+HIGH:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+HIGH:RSA+3DES:!aNULL:!eNULL:!MD5-None-None-_SSLMethod_PROTOCOL_TLSv1_1-10800-localhost-False]
{color:#d04437}Hibernate 5.3{color} [[tests 0 Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2612051]]
{color:#d04437}PDS 1{color} [[tests
3|https://ci.ignite.apache.org/viewLog.html?buildId=2612034]]
* IgnitePdsTestSuite:
BPlusTreeReuseListPageMemoryImplTest.testMassiveRemove2_false - 0,0% fails in
last 310 master runs.
{color:#d04437}Cache 5{color} [[tests
5|https://ci.ignite.apache.org/viewLog.html?buildId=2612020]]
* IgniteCacheWithIndexingTestSuite:
CacheBinaryKeyConcurrentQueryTest.testPutAndQueries - 0,0% fails in last 318
master runs.
{color:#d04437}Cache 7{color} [[tests
1|https://ci.ignite.apache.org/viewLog.html?buildId=2612022]]
* IgniteCacheTestSuite7:
TxRollbackAsyncWithPersistenceTest.testSynchronousRollback - 0,0% fails in last
304 master runs.
{panel}
[TeamCity *-- Run :: All*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2612052buildTypeId=IgniteTests24Java8_RunAll]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16725031#comment-16725031
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=- Run :: SQL: No blockers
found!|borderStyle=dashed|borderColor=#ccc|titleBGColor=#D6F7C1}{panel}
[TeamCity *- Run :: SQL*
Results|https://ci.ignite.apache.org/viewLog.html?buildId=2592891buildTypeId=IgniteTests24Java8_RunAllSql]
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16724346#comment-16724346
]
Ignite TC Bot commented on IGNITE-10645:
{panel:title=- Run :: SQL: Possible
Blockers|borderStyle=dashed|borderColor=#ccc|titleBGColor=#F7D6C1}
{color:#d04437}Platform C++ (Linux){color} [[tests 479 JVM CRASH , Exit Code
|https://ci.ignite.apache.org/viewLog.html?buildId=2584805]]
* IgniteOdbcTest: SslQueriesTestSuite: TestConnectionSslSuccess - 3,3% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionFloor - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: TransactionTestSuite: TransactionVersionMismatchError - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionLog - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlDateTimeFunctionTestSuite: TestCurrentDate - 1,2% fails in
last 887 master runs.
* IgniteCoreTest: CacheQueryTestSuite: TestFieldsQueryByteArrayInsertSelect -
1,2% fails in last 887 master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestBasic - 1,2% fails in last 887
master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestInitialQueryScan - 1,2% fails
in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLGetStmtAttr - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: StreamingTestSuite: TestStreamingManyObjects - 1,2% fails in
last 887 master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestInitialQuerySql - 1,2% fails in
last 887 master runs.
* IgniteThinClientTest: AuthTestSuite: AuthSuccess - 1,2% fails in last 887
master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestInitialQueryText - 1,2% fails
in last 887 master runs.
* IgniteThinClientTest: CacheClientTestSuite: CacheClientGetCacheExisting -
1,2% fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLSetStmtAttr - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLPrimaryKeys - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLNumParams - 1,2% fails in last
887 master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestBasicNoExcept - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLGetDiagField - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionLog10 - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLGetDiagRec - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLGetData - 1,2% fails in last
887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLGetEnvAttr - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionMod - 1,2%
fails in last 887 master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestInitialQueryScanNoExcept - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestSQLSpecialColumns - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionPi - 1,2%
fails in last 887 master runs.
* IgniteCoreTest: ContinuousQueryTestSuite: TestInitialQuerySqlNoExcept - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestFetchScrollLast - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionPower - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestFetchScrollPrior - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionRadians -
1,2% fails in last 887 master runs.
* IgniteOdbcTest: ApiRobustnessTestSuite: TestFetchScrollFirst - 1,2% fails in
last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionRand - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionRound - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionSign - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionSin - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionSqrt - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionTan - 1,2%
fails in last 887 master runs.
* IgniteOdbcTest: SqlNumericFunctionTestSuite: TestNumericFunctionTruncate -
1,2% fails in last 887 master runs.
* IgniteThinClientTest: CacheClientTestSuite: CacheClientGetCacheNonxisting -
1,2% fails in last 887 master runs.
* IgniteOdbcTest: SqlSystemFunctionTestSuite: TestSystemFunctionDatabase - 1,2%
fails in last 887 master runs.
* IgniteThinClientTest: CacheClientTestSuite:
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16724144#comment-16724144 ] Pavel Kuznetsov commented on IGNITE-10645: -- Fixed test. Issued visa comment. [~vozerov], could you please take a look at the patch? > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16723301#comment-16723301 ] Pavel Kuznetsov commented on IGNITE-10645: -- SQL test run https://ci.ignite.apache.org/viewQueued.html?itemId=2577098 > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16723076#comment-16723076 ] Pavel Kuznetsov commented on IGNITE-10645: -- Ok, Failed .net test now fail now with another exception. Test creates table via QueryEntity with no keyFields, so insertion with dml leads to empty binary object gets inserted as a cache key. Second insertion has empty binary object as a key too, so we got exception. [~vozerov] suggested to validate this case in the dml processing. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16722820#comment-16722820 ] Pavel Kuznetsov commented on IGNITE-10645: -- rerun https://ci.ignite.apache.org/viewQueued.html?itemId=2572836 > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16722643#comment-16722643 ] Pavel Kuznetsov commented on IGNITE-10645: -- sql test run https://ci.ignite.apache.org/viewQueued.html?itemId=2570414 Added validation for insert queries .net test fix TBD > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16720286#comment-16720286 ] Pavel Kuznetsov commented on IGNITE-10645: -- Fixed one more configuration: https://ci.ignite.apache.org/viewQueued.html?itemId=2540136 > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16719414#comment-16719414 ] Pavel Kuznetsov commented on IGNITE-10645: -- SQL Tests run : https://ci.ignite.apache.org/viewQueued.html?itemId=2533370 > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[ https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16719411#comment-16719411 ] ASF GitHub Bot commented on IGNITE-10645: - GitHub user pavel-kuznetsov opened a pull request: https://github.com/apache/ignite/pull/5657 IGNITE-10645: QueryBinaryProperty's isKey logic You can merge this pull request into a Git repository by running: $ git pull https://github.com/gridgain/apache-ignite ignite-10645 Alternatively you can review and apply these changes as the patch at: https://github.com/apache/ignite/pull/5657.patch To close this pull request, make a commit to your master/trunk branch with (at least) the following in the commit message: This closes #5657 commit 42bb29bf24ab221c4a16655cce4c098bc65535b1 Author: Pavel Kuznetsov Date: 2018-12-12T20:27:51Z ignite-10645: Removed runtime property configuration. Previously, in some cases (key is not of sql type and keyFields is null) QueryBinaryProperty was configured at runtime (at first cache.put()). Removed this logic, so now properties are configured when all binary metadata gets processed. commit 4aaaea81caa1d81ccd73b8e7b1d43ca34377b791 Author: Pavel Kuznetsov Date: 2018-12-12T20:30:55Z ignite-10645: Updated incorrect tests. These tests used non-sql KeyObject, and expected that keyFields get filled somehow (what is not supported). Added explicit keyFilds declaration. > SQL properties ownership flag should be set at configuration parsing, not > query execution. > -- > > Key: IGNITE-10645 > URL: https://issues.apache.org/jira/browse/IGNITE-10645 > Project: Ignite > Issue Type: Bug > Components: sql >Reporter: Pavel Kuznetsov >Assignee: Pavel Kuznetsov >Priority: Major > > At processing time, query entities are transformed and validated, table > descriptors with properties are created. > Now in some case (thre's no keyFields and key is of complex non-sql type), > ownership flag of query property is calculated at execution time (for example > at first put()): > https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132 > So we can't access metadata, that uses this not-yet-initialized field before > we put the data. > But we already have all necessary info to set this field at processing time. -- This message was sent by Atlassian JIRA (v7.6.3#76005)
[jira] [Commented] (IGNITE-10645) SQL properties ownership flag should be set at configuration parsing, not query execution.
[
https://issues.apache.org/jira/browse/IGNITE-10645?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16717438#comment-16717438
]
Pavel Kuznetsov commented on IGNITE-10645:
--
Now there are some thests that have configuration:
{noformat}
LinkedHashMap fields = new LinkedHashMap<>();
fields.put("keyStr", String.class.getName());
fields.put("keyLong", Long.class.getName());
fields.put("keyPojo", Pojo.class.getName());
fields.put("valStr", String.class.getName());
fields.put("valLong", Long.class.getName());
fields.put("valPojo", Pojo.class.getName());
ent = new QueryEntiry (Key.class.getName(), Value.class.getName())
.setFields(fields)
{noformat}
It's expected that engine somehow understands that field "keyStr" belongs to a
key, which is wrong.
Updating such tests.
> SQL properties ownership flag should be set at configuration parsing, not
> query execution.
> --
>
> Key: IGNITE-10645
> URL: https://issues.apache.org/jira/browse/IGNITE-10645
> Project: Ignite
> Issue Type: Bug
> Components: sql
>Reporter: Pavel Kuznetsov
>Assignee: Pavel Kuznetsov
>Priority: Major
>
> At processing time, query entities are transformed and validated, table
> descriptors with properties are created.
> Now in some case (thre's no keyFields and key is of complex non-sql type),
> ownership flag of query property is calculated at execution time (for example
> at first put()):
> https://github.com/apache/ignite/blob/dcdb27a24a450f63487290360b265e1570534629/modules/core/src/main/java/org/apache/ignite/internal/processors/query/property/QueryBinaryProperty.java#L132
> So we can't access metadata, that uses this not-yet-initialized field before
> we put the data.
> But we already have all necessary info to set this field at processing time.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
