[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.branch-1.2.patch
HIVE-11141.branch-1.2.patch is the patch for branch-1.2
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Fix For: 2.0.0
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
HIVE-11141.7.patch, HIVE-11141.branch-1.2.patch, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.branch-1.0.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Fix For: 2.0.0
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
HIVE-11141.7.patch, HIVE-11141.branch-1.0.patch, HIVE-11141.branch-1.2.patch,
createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.7.patch
cc-ing [~jcamachorodriguez] for review.
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
HIVE-11141.7.patch, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: (was: SQLQuery10.sql.mssql)
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.5.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: (was: HIVE-11141.5.patch)
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.5.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, HIVE-11141.5.patch,
SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: (was: HIVE-11141.4.patch)
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.4.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, HIVE-11141.4.patch, SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.3.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
HIVE-11141.3.patch, SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.1.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.2.patch
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: (was: HIVE-11141.1.patch)
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Description:
Hive occassionally gets bottlenecked on generating plans for large queries, the
majority of the cases time is spent in fetching metadata, partitions and other
optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
was:
More and more complex workloads are migrated to Hive from Sql Server, Terradata
etc..
And occasionally Hive gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
SQLQuery10.sql.mssql, createtable.rtf
Hive occassionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Description:
Hive occasionally gets bottlenecked on generating plans for large queries, the
majority of the cases time is spent in fetching metadata, partitions and other
optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
was:
Hive occassionally gets bottlenecked on generating plans for large queries, the
majority of the cases time is spent in fetching metadata, partitions and other
optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, HIVE-11141.2.patch,
SQLQuery10.sql.mssql, createtable.rtf
Hive occasionally gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Description:
More and more complex workloads are migrated to Hive from Sql Server, Terradata
etc..
And occasionally Hive gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
was:
More and more complex workloads are migrated to Hive from Sql Server, Terradata
etc..
And occasionally Hive gets bottlenecked on generating plans for large queries,
the majority of the cases time is spent in fetching metadata, partitions and
other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
It seems that the most problematic part of the code as the stack gets arbitrary
long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: createtable.rtf
SQLQuery10.sql.mssql
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Updated] (HIVE-11141) Improve RuleRegExp when the Expression node stack gets huge
[
https://issues.apache.org/jira/browse/HIVE-11141?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Hari Sankar Sivarama Subramaniyan updated HIVE-11141:
-
Attachment: HIVE-11141.1.patch
cc-ing [~jpullokkaran] for review.
Improve RuleRegExp when the Expression node stack gets huge
---
Key: HIVE-11141
URL: https://issues.apache.org/jira/browse/HIVE-11141
Project: Hive
Issue Type: Bug
Reporter: Hari Sankar Sivarama Subramaniyan
Assignee: Hari Sankar Sivarama Subramaniyan
Attachments: HIVE-11141.1.patch, SQLQuery10.sql.mssql, createtable.rtf
More and more complex workloads are migrated to Hive from Sql Server,
Terradata etc..
And occasionally Hive gets bottlenecked on generating plans for large
queries, the majority of the cases time is spent in fetching metadata,
partitions and other optimizer transformation related rules
I have attached the query for the test case which needs to be tested after we
setup database as shown below.
{code}
create database dataset_3;
use database dataset_3;
{code}
createtable.rtf - create table command
SQLQuery10.sql.mssql - explain query
It seems that the most problematic part of the code as the stack gets
arbitrary long, in RuleRegExp.java
{code}
@Override
public int cost(StackNode stack) throws SemanticException {
int numElems = (stack != null ? stack.size() : 0);
String name = ;
for (int pos = numElems - 1; pos = 0; pos--) {
name = stack.get(pos).getName() + % + name;
Matcher m = pattern.matcher(name);
if (m.matches()) {
return m.group().length();
}
}
return -1;
}
{code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
