diff --git common/src/java/org/apache/hadoop/hive/conf/HiveConf.java common/src/java/org/apache/hadoop/hive/conf/HiveConf.java index e3ddbf197b..edf7303691 100644 --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java @@ -4029,10 +4029,11 @@ private static void populateLlapDaemonVarsSet(Set llapDaemonVarsSetLocal "The name of counter group for internal Hive variables (CREATED_FILE, FATAL_ERROR, etc.)"), HIVE_QUOTEDID_SUPPORT("hive.support.quoted.identifiers", "column", - new StringSet("none", "column"), - "Whether to use quoted identifier. 'none' or 'column' can be used. \n" + - " none: default(past) behavior. Implies only alphaNumeric and underscore are valid characters in identifiers.\n" + - " column: implies column names can contain any character." + new StringSet("none", "column", "standard"), + "Whether to use quoted identifier. 'none', 'column', and 'standard' can be used. \n" + + " none: past behavior, it implies only alphaNumeric and underscore are valid characters in identifiers.\n" + + " column: implies identifier names can contain any character by using backticks `col1`.\n" + + " standard: implies identifier names can contain any character by using double quotes \"col1\"." ), /** * @deprecated Use MetastoreConf.SUPPORT_SPECIAL_CHARACTERS_IN_TABLE_NAMES @@ -4041,8 +4042,8 @@ private static void populateLlapDaemonVarsSet(Set llapDaemonVarsSetLocal HIVE_SUPPORT_SPECICAL_CHARACTERS_IN_TABLE_NAMES("hive.support.special.characters.tablename", true, "This flag should be set to true to enable support for special characters in table names.\n" + "When it is set to false, only [a-zA-Z_0-9]+ are supported.\n" - + "The only supported special character right now is '/'. This flag applies only to quoted table names.\n" - + "The default value is true."), + + "The supported special characters are %&'()*+,-./:;<=>?[]_|{}$^!~#@ and space. This flag applies only to" + + " quoted table names.\nThe default value is true."), HIVE_CREATE_TABLES_AS_INSERT_ONLY("hive.create.as.insert.only", false, "Whether the eligible tables should be created as ACID insert-only by default. Does \n" + "not apply to external tables, the ones using storage handlers, etc."), diff --git itests/src/test/resources/testconfiguration.properties itests/src/test/resources/testconfiguration.properties index c55f8db61a..2edf2efa39 100644 --- itests/src/test/resources/testconfiguration.properties +++ itests/src/test/resources/testconfiguration.properties @@ -795,6 +795,9 @@ minillaplocal.query.files=\ smb_cache.q,\ sort_acid.q,\ special_character_in_tabnames_1.q,\ + special_character_in_tabnames_2.q,\ + special_character_in_tabnames_quotes_1.q,\ + special_character_in_tabnames_quotes_2.q,\ sqlmerge.q,\ sqlmerge_stats.q,\ stats_based_fetch_decision.q,\ diff --git itests/util/src/main/java/org/apache/hadoop/hive/cli/control/CliConfigs.java itests/util/src/main/java/org/apache/hadoop/hive/cli/control/CliConfigs.java index 1c0c62fb13..1ecd0d15c9 100644 --- itests/util/src/main/java/org/apache/hadoop/hive/cli/control/CliConfigs.java +++ itests/util/src/main/java/org/apache/hadoop/hive/cli/control/CliConfigs.java @@ -250,7 +250,6 @@ public MiniLlapLocalCliConfig() { includesFrom(testConfigProps, "minillaplocal.query.files"); includesFrom(testConfigProps, "minillaplocal.shared.query.files"); excludeQuery("bucket_map_join_tez1.q"); // Disabled in HIVE-19509 - excludeQuery("special_character_in_tabnames_1.q"); // Disabled in HIVE-19509 excludeQuery("tez_smb_1.q"); // Disabled in HIVE-19509 excludeQuery("union_fast_stats.q"); // Disabled in HIVE-19509 excludeQuery("schema_evol_orc_acidvec_part.q"); // Disabled in HIVE-19509 diff --git parser/pom.xml parser/pom.xml index 18e0ad801d..2ad16d4553 100644 --- parser/pom.xml +++ parser/pom.xml @@ -77,7 +77,9 @@ ${basedir}/src/java **/HiveLexer.g + **/HiveLexerStandard.g **/HiveParser.g + **/HiveParserStandard.g **/HintParser.g diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/ANTLRNoCaseStringStream.java parser/src/java/org/apache/hadoop/hive/ql/parse/ANTLRNoCaseStringStream.java new file mode 100644 index 0000000000..29d2010796 --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/ANTLRNoCaseStringStream.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse; + +import org.antlr.runtime.ANTLRStringStream; +import org.antlr.runtime.CharStream; + +/** + * ANTLRNoCaseStringStream. + * This class provides and implementation for a case insensitive token checker + * for the lexical analysis part of antlr. By converting the token stream into + * upper case at the time when lexical rules are checked, this class ensures that the + * lexical rules need to just match the token with upper case letters as opposed to + * combination of upper case and lower case characteres. This is purely used for matching lexical + * rules. The actual token text is stored in the same way as the user input without + * actually converting it into an upper case. The token values are generated by the consume() + * function of the super class ANTLRStringStream. The LA() function is the lookahead funtion + * and is purely used for matching lexical rules. This also means that the grammar will only + * accept capitalized tokens in case it is run from other tools like antlrworks which + * do not have the ANTLRNoCaseStringStream implementation. + */ +public class ANTLRNoCaseStringStream extends ANTLRStringStream { + + public ANTLRNoCaseStringStream(String input) { + super(input); + } + + @Override + public int LA(int i) { + + int returnChar = super.LA(i); + if (returnChar == CharStream.EOF) { + return returnChar; + } else if (returnChar == 0) { + return returnChar; + } + + return Character.toUpperCase((char) returnChar); + } +} diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveLexer.java parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveLexer.java new file mode 100644 index 0000000000..9f68d7cb2c --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveLexer.java @@ -0,0 +1,108 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse; + +import java.util.ArrayList; +import org.antlr.runtime.CharStream; +import org.antlr.runtime.Lexer; +import org.antlr.runtime.NoViableAltException; +import org.antlr.runtime.RecognitionException; +import org.antlr.runtime.RecognizerSharedState; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.conf.HiveConf; + +/** + * Common class of Legacy and SQL Standard Hive Lexer. + */ +public abstract class GenericHiveLexer extends Lexer { + + public static GenericHiveLexer of(String statement, Configuration configuration) { + GenericHiveLexer lexer; + if (Quotation.from(configuration) == Quotation.STANDARD) { + lexer = new HiveLexerStandard(new ANTLRNoCaseStringStream(statement)); + } else { + lexer = new HiveLexer(new ANTLRNoCaseStringStream(statement)); + } + + lexer.setHiveConf(configuration); + for (GenericHiveLexer wrappedLexers : lexer.getDelegates()) { + wrappedLexers.setHiveConf(configuration); + } + + return lexer; + } + + private final ArrayList errors; + private Configuration hiveConf; + private Quotation quotation; + + public GenericHiveLexer() { + errors = new ArrayList<>(); + } + + public GenericHiveLexer(CharStream input) { + super(input); + errors = new ArrayList<>(); + } + + public GenericHiveLexer(CharStream input, RecognizerSharedState state) { + super(input, state); + errors = new ArrayList<>(); + } + + public void setHiveConf(Configuration hiveConf) { + this.hiveConf = hiveConf; + } + + public abstract GenericHiveLexer[] getDelegates(); + + protected Quotation allowQuotedId() { + if (quotation == null) { + quotation = Quotation.from(hiveConf); + } + return quotation; + } + + @Override + public void displayRecognitionError(String[] tokenNames, RecognitionException e) { + errors.add(new ParseError(this, e, tokenNames)); + } + + @Override + public String getErrorMessage(RecognitionException e, String[] tokenNames) { + String msg; + + if (e instanceof NoViableAltException) { + @SuppressWarnings("unused") + NoViableAltException nvae = (NoViableAltException) e; + // for development, can add + // "decision=<<"+nvae.grammarDecisionDescription+">>" + // and "(decision="+nvae.decisionNumber+") and + // "state "+nvae.stateNumber + msg = "character " + getCharErrorDisplay(e.c) + " not supported here"; + } else { + msg = super.getErrorMessage(e, tokenNames); + } + + return msg; + } + + public ArrayList getErrors() { + return errors; + } +} diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveParser.java parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveParser.java new file mode 100644 index 0000000000..c437c433e7 --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/GenericHiveParser.java @@ -0,0 +1,437 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse; + +import static org.apache.hadoop.hive.ql.parse.Quotation.STANDARD; + +import java.util.ArrayList; +import java.util.Stack; + +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; + +import org.antlr.runtime.tree.TreeAdaptor; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.conf.HiveConf; +import org.antlr.runtime.BitSet; +import org.antlr.runtime.FailedPredicateException; +import org.antlr.runtime.IntStream; +import org.antlr.runtime.MismatchedTokenException; +import org.antlr.runtime.NoViableAltException; +import org.antlr.runtime.Parser; +import org.antlr.runtime.ParserRuleReturnScope; +import org.antlr.runtime.RecognitionException; +import org.antlr.runtime.RecognizerSharedState; +import org.antlr.runtime.Token; +import org.antlr.runtime.TokenStream; +import org.antlr.runtime.tree.CommonTree; + +/** + * Common class of Legacy and SQL Standard Hive Parser. + */ +public abstract class GenericHiveParser extends Parser { + public static GenericHiveParser with( + TokenStream input, Configuration configuration, TreeAdaptor adaptor) { + + GenericHiveParser parser; + if (Quotation.from(configuration) == STANDARD) { + parser = new HiveParserStandard(input); + } else { + parser = new HiveParser(input); + } + + parser.setTreeAdaptor(adaptor); + parser.setHiveConf(configuration); + for (GenericHiveParser wrappedParsers : parser.getDelegates()) { + wrappedParsers.setHiveConf(configuration); + wrappedParsers.setTreeAdaptor(adaptor); + } + + return parser; + } + + private static final char[] EXCLUDED_CHAR_FOR_COLUMN_NAME = {'.', ':'}; + private static final HashMap xlateMap; + + static { + //this is used to support auto completion in CLI + xlateMap = new HashMap<>(); + + // Keywords + xlateMap.put("KW_TRUE", "TRUE"); + xlateMap.put("KW_FALSE", "FALSE"); + xlateMap.put("KW_UNKNOWN", "UNKNOWN"); + xlateMap.put("KW_ALL", "ALL"); + xlateMap.put("KW_NONE", "NONE"); + xlateMap.put("KW_AND", "AND"); + xlateMap.put("KW_OR", "OR"); + xlateMap.put("KW_NOT", "NOT"); + xlateMap.put("KW_LIKE", "LIKE"); + + xlateMap.put("KW_ASC", "ASC"); + xlateMap.put("KW_DESC", "DESC"); + xlateMap.put("KW_NULLS", "NULLS"); + xlateMap.put("KW_LAST", "LAST"); + xlateMap.put("KW_ORDER", "ORDER"); + xlateMap.put("KW_BY", "BY"); + xlateMap.put("KW_GROUP", "GROUP"); + xlateMap.put("KW_WHERE", "WHERE"); + xlateMap.put("KW_FROM", "FROM"); + xlateMap.put("KW_AS", "AS"); + xlateMap.put("KW_SELECT", "SELECT"); + xlateMap.put("KW_DISTINCT", "DISTINCT"); + xlateMap.put("KW_INSERT", "INSERT"); + xlateMap.put("KW_OVERWRITE", "OVERWRITE"); + xlateMap.put("KW_OUTER", "OUTER"); + xlateMap.put("KW_JOIN", "JOIN"); + xlateMap.put("KW_LEFT", "LEFT"); + xlateMap.put("KW_RIGHT", "RIGHT"); + xlateMap.put("KW_FULL", "FULL"); + xlateMap.put("KW_ON", "ON"); + xlateMap.put("KW_PARTITION", "PARTITION"); + xlateMap.put("KW_PARTITIONS", "PARTITIONS"); + xlateMap.put("KW_TABLE", "TABLE"); + xlateMap.put("KW_TABLES", "TABLES"); + xlateMap.put("KW_TBLPROPERTIES", "TBLPROPERTIES"); + xlateMap.put("KW_SHOW", "SHOW"); + xlateMap.put("KW_MSCK", "MSCK"); + xlateMap.put("KW_DIRECTORY", "DIRECTORY"); + xlateMap.put("KW_LOCAL", "LOCAL"); + xlateMap.put("KW_TRANSFORM", "TRANSFORM"); + xlateMap.put("KW_USING", "USING"); + xlateMap.put("KW_CLUSTER", "CLUSTER"); + xlateMap.put("KW_DISTRIBUTE", "DISTRIBUTE"); + xlateMap.put("KW_SORT", "SORT"); + xlateMap.put("KW_SYNC", "SYNC"); + xlateMap.put("KW_UNION", "UNION"); + xlateMap.put("KW_INTERSECT", "INTERSECT"); + xlateMap.put("KW_EXCEPT", "EXCEPT"); + xlateMap.put("KW_LOAD", "LOAD"); + xlateMap.put("KW_DATA", "DATA"); + xlateMap.put("KW_INPATH", "INPATH"); + xlateMap.put("KW_IS", "IS"); + xlateMap.put("KW_NULL", "NULL"); + xlateMap.put("KW_CREATE", "CREATE"); + xlateMap.put("KW_EXTERNAL", "EXTERNAL"); + xlateMap.put("KW_ALTER", "ALTER"); + xlateMap.put("KW_DESCRIBE", "DESCRIBE"); + xlateMap.put("KW_DROP", "DROP"); + xlateMap.put("KW_RENAME", "RENAME"); + xlateMap.put("KW_TO", "TO"); + xlateMap.put("KW_COMMENT", "COMMENT"); + xlateMap.put("KW_BOOLEAN", "BOOLEAN"); + xlateMap.put("KW_TINYINT", "TINYINT"); + xlateMap.put("KW_SMALLINT", "SMALLINT"); + xlateMap.put("KW_INT", "INT"); + xlateMap.put("KW_BIGINT", "BIGINT"); + xlateMap.put("KW_FLOAT", "FLOAT"); + xlateMap.put("KW_REAL", "REAL"); + xlateMap.put("KW_DOUBLE", "DOUBLE"); + xlateMap.put("KW_PRECISION", "PRECISION"); + xlateMap.put("KW_DATE", "DATE"); + xlateMap.put("KW_DATETIME", "DATETIME"); + xlateMap.put("KW_TIMESTAMP", "TIMESTAMP"); + xlateMap.put("KW_TIMESTAMPLOCALTZ", "TIMESTAMPLOCALTZ"); + xlateMap.put("KW_TIME", "TIME"); + xlateMap.put("KW_ZONE", "ZONE"); + xlateMap.put("KW_STRING", "STRING"); + xlateMap.put("KW_BINARY", "BINARY"); + xlateMap.put("KW_ARRAY", "ARRAY"); + xlateMap.put("KW_MAP", "MAP"); + xlateMap.put("KW_REDUCE", "REDUCE"); + xlateMap.put("KW_PARTITIONED", "PARTITIONED"); + xlateMap.put("KW_CLUSTERED", "CLUSTERED"); + xlateMap.put("KW_SORTED", "SORTED"); + xlateMap.put("KW_INTO", "INTO"); + xlateMap.put("KW_BUCKETS", "BUCKETS"); + xlateMap.put("KW_ROW", "ROW"); + xlateMap.put("KW_FORMAT", "FORMAT"); + xlateMap.put("KW_DELIMITED", "DELIMITED"); + xlateMap.put("KW_FIELDS", "FIELDS"); + xlateMap.put("KW_TERMINATED", "TERMINATED"); + xlateMap.put("KW_COLLECTION", "COLLECTION"); + xlateMap.put("KW_ITEMS", "ITEMS"); + xlateMap.put("KW_KEYS", "KEYS"); + xlateMap.put("KW_KEY_TYPE", "$KEY$"); + xlateMap.put("KW_LINES", "LINES"); + xlateMap.put("KW_STORED", "STORED"); + xlateMap.put("KW_SEQUENCEFILE", "SEQUENCEFILE"); + xlateMap.put("KW_TEXTFILE", "TEXTFILE"); + xlateMap.put("KW_INPUTFORMAT", "INPUTFORMAT"); + xlateMap.put("KW_OUTPUTFORMAT", "OUTPUTFORMAT"); + xlateMap.put("KW_LOCATION", "LOCATION"); + xlateMap.put("KW_MANAGEDLOCATION", "MANAGEDLOCATION"); + xlateMap.put("KW_TABLESAMPLE", "TABLESAMPLE"); + xlateMap.put("KW_BUCKET", "BUCKET"); + xlateMap.put("KW_OUT", "OUT"); + xlateMap.put("KW_OF", "OF"); + xlateMap.put("KW_CAST", "CAST"); + xlateMap.put("KW_ADD", "ADD"); + xlateMap.put("KW_REPLACE", "REPLACE"); + xlateMap.put("KW_COLUMNS", "COLUMNS"); + xlateMap.put("KW_RLIKE", "RLIKE"); + xlateMap.put("KW_REGEXP", "REGEXP"); + xlateMap.put("KW_TEMPORARY", "TEMPORARY"); + xlateMap.put("KW_FUNCTION", "FUNCTION"); + xlateMap.put("KW_FUNCTIONS", "FUNCTIONS"); + xlateMap.put("KW_EXPLAIN", "EXPLAIN"); + xlateMap.put("KW_EXTENDED", "EXTENDED"); + xlateMap.put("KW_DEBUG", "DEBUG"); + xlateMap.put("KW_SERDE", "SERDE"); + xlateMap.put("KW_WITH", "WITH"); + xlateMap.put("KW_SERDEPROPERTIES", "SERDEPROPERTIES"); + xlateMap.put("KW_LIMIT", "LIMIT"); + xlateMap.put("KW_OFFSET", "OFFSET"); + xlateMap.put("KW_SET", "SET"); + xlateMap.put("KW_PROPERTIES", "TBLPROPERTIES"); + xlateMap.put("KW_VALUE_TYPE", "$VALUE$"); + xlateMap.put("KW_ELEM_TYPE", "$ELEM$"); + xlateMap.put("KW_DEFINED", "DEFINED"); + xlateMap.put("KW_SUBQUERY", "SUBQUERY"); + xlateMap.put("KW_REWRITE", "REWRITE"); + xlateMap.put("KW_UPDATE", "UPDATE"); + xlateMap.put("KW_VALUES", "VALUES"); + xlateMap.put("KW_PURGE", "PURGE"); + xlateMap.put("KW_UNIQUE", "UNIQUE"); + xlateMap.put("KW_PRIMARY", "PRIMARY"); + xlateMap.put("KW_FOREIGN", "FOREIGN"); + xlateMap.put("KW_KEY", "KEY"); + xlateMap.put("KW_REFERENCES", "REFERENCES"); + xlateMap.put("KW_CONSTRAINT", "CONSTRAINT"); + xlateMap.put("KW_ENABLE", "ENABLE"); + xlateMap.put("KW_DISABLE", "DISABLE"); + xlateMap.put("KW_VALIDATE", "VALIDATE"); + xlateMap.put("KW_NOVALIDATE", "NOVALIDATE"); + xlateMap.put("KW_RELY", "RELY"); + xlateMap.put("KW_NORELY", "NORELY"); + xlateMap.put("KW_ABORT", "ABORT"); + xlateMap.put("KW_TRANSACTIONS", "TRANSACTIONS"); + xlateMap.put("KW_COMPACTIONS", "COMPACTIONS"); + xlateMap.put("KW_COMPACT", "COMPACT"); + xlateMap.put("KW_WAIT", "WAIT"); + xlateMap.put("KW_KILL", "KILL"); + xlateMap.put("KW_QUERY", "QUERY"); + xlateMap.put("KW_RESOURCE", "RESOURCE"); + xlateMap.put("KW_PLAN", "PLAN"); + xlateMap.put("KW_QUERY_PARALLELISM", "QUERY_PARALLELISM"); + xlateMap.put("KW_PLANS", "PLANS"); + xlateMap.put("KW_ACTIVATE", "ACTIVATE"); + xlateMap.put("KW_DEFAULT", "DEFAULT"); + xlateMap.put("KW_CHECK", "CHECK"); + xlateMap.put("KW_POOL", "POOL"); + xlateMap.put("KW_MOVE", "MOVE"); + xlateMap.put("KW_DO", "DO"); + xlateMap.put("KW_ALLOC_FRACTION", "ALLOC_FRACTION"); + xlateMap.put("KW_SCHEDULING_POLICY", "SCHEDULING_POLICY"); + xlateMap.put("KW_PATH", "PATH"); + xlateMap.put("KW_AST", "AST"); + xlateMap.put("KW_TRANSACTIONAL", "TRANSACTIONAL"); + + // Operators + xlateMap.put("DOT", "."); + xlateMap.put("COLON", ":"); + xlateMap.put("COMMA", ","); + xlateMap.put("SEMICOLON", ");"); + + xlateMap.put("LPAREN", "("); + xlateMap.put("RPAREN", ")"); + xlateMap.put("LSQUARE", "["); + xlateMap.put("RSQUARE", "]"); + + xlateMap.put("EQUAL", "="); + xlateMap.put("NOTEQUAL", "<>"); + xlateMap.put("EQUAL_NS", "<=>"); + xlateMap.put("LESSTHANOREQUALTO", "<="); + xlateMap.put("LESSTHAN", "<"); + xlateMap.put("GREATERTHANOREQUALTO", ">="); + xlateMap.put("GREATERTHAN", ">"); + + xlateMap.put("DIVIDE", "/"); + xlateMap.put("PLUS", "+"); + xlateMap.put("MINUS", "-"); + xlateMap.put("STAR", "*"); + xlateMap.put("MOD", "%"); + + xlateMap.put("AMPERSAND", "&"); + xlateMap.put("TILDE", "~"); + xlateMap.put("BITWISEOR", "|"); + xlateMap.put("BITWISEXOR", "^"); + xlateMap.put("CharSetLiteral", "\\'"); + } + + + public ArrayList errors = new ArrayList<>(); + protected Stack msgs = new Stack<>(); + private Configuration hiveConf; + // counter to generate unique union aliases + private int aliasCounter; + + + public GenericHiveParser(TokenStream input) { + super(input); + } + + public GenericHiveParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + } + + public abstract void setTreeAdaptor(TreeAdaptor treeAdaptor); + + public abstract GenericHiveParser[] getDelegates(); + + public ParserRuleReturnScope statement() throws RecognitionException { + throw new UnsupportedOperationException(); + } + + public ParserRuleReturnScope selectClause() throws RecognitionException { + throw new UnsupportedOperationException(); + } + + public ParserRuleReturnScope expression() throws RecognitionException { + throw new UnsupportedOperationException(); + } + + public ParserRuleReturnScope triggerExpressionStandalone() throws RecognitionException { + throw new UnsupportedOperationException(); + } + + public ParserRuleReturnScope triggerActionExpressionStandalone() throws RecognitionException { + throw new UnsupportedOperationException(); + } + + public void setHiveConf(Configuration hiveConf) { + this.hiveConf = hiveConf; + } + + public static Collection getKeywords() { + return xlateMap.values(); + } + + private String xlate(String name) { + + String ret = xlateMap.get(name); + if (ret == null) { + ret = name; + } + + return ret; + } + + @Override + public Object recoverFromMismatchedSet(IntStream input, RecognitionException re, BitSet follow) + throws RecognitionException { + throw re; + } + + @Override + public void displayRecognitionError(String[] tokenNames, + RecognitionException e) { + errors.add(new ParseError(this, e, tokenNames)); + } + + @Override + public String getErrorHeader(RecognitionException e) { + String header; + if (e.charPositionInLine < 0 && input.LT(-1) != null) { + Token t = input.LT(-1); + header = "line " + t.getLine() + ":" + t.getCharPositionInLine(); + } else { + header = super.getErrorHeader(e); + } + + return header; + } + + @Override + public String getErrorMessage(RecognitionException e, String[] tokenNames) { + String msg; + + // Translate the token names to something that the user can understand + String[] xlateNames = new String[tokenNames.length]; + for (int i = 0; i < tokenNames.length; ++i) { + xlateNames[i] = xlate(tokenNames[i]); + } + + if (e instanceof NoViableAltException) { + @SuppressWarnings("unused") + NoViableAltException nvae = (NoViableAltException) e; + // for development, can add + // "decision=<<"+nvae.grammarDecisionDescription+">>" + // and "(decision="+nvae.decisionNumber+") and + // "state "+nvae.stateNumber + msg = "cannot recognize input near" + + (input.LT(1) != null ? " " + getTokenErrorDisplay(input.LT(1)) : "") + + (input.LT(2) != null ? " " + getTokenErrorDisplay(input.LT(2)) : "") + + (input.LT(3) != null ? " " + getTokenErrorDisplay(input.LT(3)) : ""); + } else if (e instanceof MismatchedTokenException) { + MismatchedTokenException mte = (MismatchedTokenException) e; + msg = super.getErrorMessage(e, xlateNames) + (input.LT(-1) == null ? "":" near '" + input.LT(-1).getText()) + "'"; + } else if (e instanceof FailedPredicateException) { + FailedPredicateException fpe = (FailedPredicateException) e; + msg = "Failed to recognize predicate '" + fpe.token.getText() + "'. Failed rule: '" + fpe.ruleName + "'"; + } else { + msg = super.getErrorMessage(e, xlateNames); + } + if (msgs.size() > 0) { + msg = msg + " in " + msgs.peek(); + } + return msg; + } + + protected void pushMsg(String msg, RecognizerSharedState state) { + // ANTLR generated code does not wrap the @init code wit this backtracking check, + // even if the matching @after has it. If we have parser rules with that are doing + // some lookahead with syntactic predicates this can cause the push() and pop() calls + // to become unbalanced, so make sure both push/pop check the backtracking state. + if (state.backtracking == 0) { + msgs.push(msg); + } + } + + protected void popMsg(RecognizerSharedState state) { + if (state.backtracking == 0) { + Object o = msgs.pop(); + } + } + + protected String generateUnionAlias() { + return "__u" + (++aliasCounter); + } + + protected boolean containExcludedCharForCreateTableColumnName(String input) { + for(char c : EXCLUDED_CHAR_FOR_COLUMN_NAME) { + if(input.indexOf(c)>-1) { + return true; + } + } + return false; + } + + protected CommonTree throwColumnNameException() throws RecognitionException { + throw new FailedPredicateException(input, Arrays.toString(EXCLUDED_CHAR_FOR_COLUMN_NAME) + + " can not be used in column name in create table statement.", ""); + } + + protected boolean nullsLast() { + if (hiveConf == null) { + return false; + } + return HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVE_DEFAULT_NULLS_LAST); + } +} diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g index 23f74ba05e..fff0fdade0 100644 --- parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexer.g @@ -16,534 +16,24 @@ */ lexer grammar HiveLexer; +options { +superClass = GenericHiveLexer; +} +import HiveLexerParent; + @lexer::header { package org.apache.hadoop.hive.ql.parse; -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hive.conf.HiveConf; import org.apache.commons.lang3.StringUtils; } -@lexer::members { - private Configuration hiveConf; - - public void setHiveConf(Configuration hiveConf) { - this.hiveConf = hiveConf; - } - - protected boolean allowQuotedId() { - if(hiveConf == null){ - return false; - } - String supportedQIds = HiveConf.getVar(hiveConf, HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT); - return !"none".equals(supportedQIds); - } -} - -// Keywords - -KW_TRUE : 'TRUE'; -KW_FALSE : 'FALSE'; -KW_UNKNOWN : 'UNKNOWN'; -KW_ALL : 'ALL'; -KW_SOME : 'SOME'; -KW_NONE: 'NONE'; -KW_AND : 'AND'; -KW_OR : 'OR'; -KW_NOT : 'NOT' | '!'; -KW_LIKE : 'LIKE'; -KW_ANY : 'ANY'; - -KW_IF : 'IF'; -KW_EXISTS : 'EXISTS'; - -KW_ASC : 'ASC'; -KW_DESC : 'DESC'; -KW_NULLS : 'NULLS'; -KW_LAST : 'LAST'; -KW_ORDER : 'ORDER'; -KW_GROUP : 'GROUP'; -KW_BY : 'BY'; -KW_HAVING : 'HAVING'; -KW_WHERE : 'WHERE'; -KW_FROM : 'FROM'; -KW_AS : 'AS'; -KW_SELECT : 'SELECT'; -KW_DISTINCT : 'DISTINCT'; -KW_INSERT : 'INSERT'; -KW_OVERWRITE : 'OVERWRITE'; -KW_OUTER : 'OUTER'; -KW_UNIQUEJOIN : 'UNIQUEJOIN'; -KW_PRESERVE : 'PRESERVE'; -KW_JOIN : 'JOIN'; -KW_LEFT : 'LEFT'; -KW_RIGHT : 'RIGHT'; -KW_FULL : 'FULL'; -KW_ON : 'ON'; -KW_PARTITION : 'PARTITION'; -KW_PARTITIONS : 'PARTITIONS'; -KW_TABLE: 'TABLE'; -KW_TABLES: 'TABLES'; -KW_COLUMNS: 'COLUMNS'; -KW_INDEX: 'INDEX'; -KW_INDEXES: 'INDEXES'; -KW_REBUILD: 'REBUILD'; -KW_FUNCTIONS: 'FUNCTIONS'; -KW_SHOW: 'SHOW'; -KW_MSCK: 'MSCK'; -KW_REPAIR: 'REPAIR'; -KW_DIRECTORY: 'DIRECTORY'; -KW_LOCAL: 'LOCAL'; -KW_TRANSFORM : 'TRANSFORM'; -KW_USING: 'USING'; -KW_CLUSTER: 'CLUSTER'; -KW_DISTRIBUTE: 'DISTRIBUTE'; -KW_SORT: 'SORT'; -KW_UNION: 'UNION'; -KW_EXCEPT: 'EXCEPT'; -KW_LOAD: 'LOAD'; -KW_EXPORT: 'EXPORT'; -KW_IMPORT: 'IMPORT'; -KW_REPLICATION: 'REPLICATION'; -KW_METADATA: 'METADATA'; -KW_DATA: 'DATA'; -KW_INPATH: 'INPATH'; -KW_IS: 'IS'; -KW_NULL: 'NULL'; -KW_CREATE: 'CREATE'; -KW_EXTERNAL: 'EXTERNAL'; -KW_ALTER: 'ALTER'; -KW_CHANGE: 'CHANGE'; -KW_COLUMN: 'COLUMN'; -KW_FIRST: 'FIRST'; -KW_AFTER: 'AFTER'; -KW_DESCRIBE: 'DESCRIBE'; -KW_DROP: 'DROP'; -KW_RENAME: 'RENAME'; -KW_TO: 'TO'; -KW_COMMENT: 'COMMENT'; -KW_BOOLEAN: 'BOOLEAN'; -KW_TINYINT: 'TINYINT'; -KW_SMALLINT: 'SMALLINT'; -KW_INT: 'INT' | 'INTEGER'; -KW_BIGINT: 'BIGINT'; -KW_FLOAT: 'FLOAT'; -KW_REAL: 'REAL'; -KW_DOUBLE: 'DOUBLE'; -KW_PRECISION: 'PRECISION'; -KW_DATE: 'DATE'; -KW_DATETIME: 'DATETIME'; -KW_TIMESTAMP: 'TIMESTAMP'; -KW_TIMESTAMPLOCALTZ: 'TIMESTAMPLOCALTZ'; -KW_TIME: 'TIME'; -KW_ZONE: 'ZONE'; -KW_INTERVAL: 'INTERVAL'; -KW_DECIMAL: 'DECIMAL' | 'DEC' | 'NUMERIC'; -KW_STRING: 'STRING'; -KW_CHAR: 'CHAR'; -KW_VARCHAR: 'VARCHAR'; -KW_ARRAY: 'ARRAY'; -KW_STRUCT: 'STRUCT'; -KW_MAP: 'MAP'; -KW_UNIONTYPE: 'UNIONTYPE'; -KW_REDUCE: 'REDUCE'; -KW_PARTITIONED: 'PARTITIONED'; -KW_CLUSTERED: 'CLUSTERED'; -KW_DISTRIBUTED: 'DISTRIBUTED'; -KW_SORTED: 'SORTED'; -KW_INTO: 'INTO'; -KW_BUCKETS: 'BUCKETS'; -KW_ROW: 'ROW'; -KW_ROWS: 'ROWS'; -KW_FORMAT: 'FORMAT'; -KW_DELIMITED: 'DELIMITED'; -KW_FIELDS: 'FIELDS'; -KW_TERMINATED: 'TERMINATED'; -KW_ESCAPED: 'ESCAPED'; -KW_COLLECTION: 'COLLECTION'; -KW_ITEMS: 'ITEMS'; -KW_KEYS: 'KEYS'; -KW_KEY_TYPE: '$KEY$'; -KW_KILL: 'KILL'; -KW_LINES: 'LINES'; -KW_STORED: 'STORED'; -KW_FILEFORMAT: 'FILEFORMAT'; -KW_INPUTFORMAT: 'INPUTFORMAT'; -KW_OUTPUTFORMAT: 'OUTPUTFORMAT'; -KW_INPUTDRIVER: 'INPUTDRIVER'; -KW_OUTPUTDRIVER: 'OUTPUTDRIVER'; -KW_ENABLE: 'ENABLE' | 'ENABLED'; -KW_DISABLE: 'DISABLE' | 'DISABLED'; -KW_EXECUTED: 'EXECUTED'; -KW_EXECUTE: 'EXECUTE'; -KW_LOCATION: 'LOCATION'; -KW_MANAGEDLOCATION: 'MANAGEDLOCATION'; -KW_TABLESAMPLE: 'TABLESAMPLE'; -KW_BUCKET: 'BUCKET'; -KW_OUT: 'OUT'; -KW_OF: 'OF'; -KW_PERCENT: 'PERCENT'; -KW_CAST: 'CAST'; -KW_ADD: 'ADD'; -KW_REPLACE: 'REPLACE'; -KW_RLIKE: 'RLIKE'; -KW_REGEXP: 'REGEXP'; -KW_TEMPORARY: 'TEMPORARY'; -KW_FUNCTION: 'FUNCTION'; -KW_MACRO: 'MACRO'; -KW_FILE: 'FILE'; -KW_JAR: 'JAR'; -KW_EXPLAIN: 'EXPLAIN'; -KW_EXTENDED: 'EXTENDED'; -KW_DEBUG: 'DEBUG'; -KW_FORMATTED: 'FORMATTED'; -KW_DEPENDENCY: 'DEPENDENCY'; -KW_LOGICAL: 'LOGICAL'; -KW_CBO: 'CBO'; -KW_SERDE: 'SERDE'; -KW_WITH: 'WITH'; -KW_DEFERRED: 'DEFERRED'; -KW_SERDEPROPERTIES: 'SERDEPROPERTIES'; -KW_DBPROPERTIES: 'DBPROPERTIES'; -KW_LIMIT: 'LIMIT'; -KW_OFFSET: 'OFFSET'; -KW_SET: 'SET'; -KW_UNSET: 'UNSET'; -KW_TBLPROPERTIES: 'TBLPROPERTIES'; -KW_IDXPROPERTIES: 'IDXPROPERTIES'; -KW_VALUE_TYPE: '$VALUE$'; -KW_ELEM_TYPE: '$ELEM$'; -KW_DEFINED: 'DEFINED'; -KW_CASE: 'CASE'; -KW_WHEN: 'WHEN'; -KW_THEN: 'THEN'; -KW_ELSE: 'ELSE'; -KW_END: 'END'; -KW_MAPJOIN: 'MAPJOIN'; -KW_STREAMTABLE: 'STREAMTABLE'; -KW_CLUSTERSTATUS: 'CLUSTERSTATUS'; -KW_UTC: 'UTC'; -KW_UTCTIMESTAMP: 'UTC_TMESTAMP'; -KW_LONG: 'LONG'; -KW_DELETE: 'DELETE'; -KW_PLUS: 'PLUS'; -KW_MINUS: 'MINUS'; -KW_FETCH: 'FETCH'; -KW_INTERSECT: 'INTERSECT'; -KW_VIEW: 'VIEW'; -KW_VIEWS: 'VIEWS'; -KW_IN: 'IN'; -KW_DATABASE: 'DATABASE'; -KW_DATABASES: 'DATABASES'; -KW_MATERIALIZED: 'MATERIALIZED'; -KW_SCHEMA: 'SCHEMA'; -KW_SCHEMAS: 'SCHEMAS'; -KW_GRANT: 'GRANT'; -KW_REVOKE: 'REVOKE'; -KW_SSL: 'SSL'; -KW_UNDO: 'UNDO'; -KW_LOCK: 'LOCK'; -KW_LOCKS: 'LOCKS'; -KW_UNLOCK: 'UNLOCK'; -KW_SHARED: 'SHARED'; -KW_EXCLUSIVE: 'EXCLUSIVE'; -KW_PROCEDURE: 'PROCEDURE'; -KW_UNSIGNED: 'UNSIGNED'; -KW_WHILE: 'WHILE'; -KW_READ: 'READ'; -KW_READS: 'READS'; -KW_PURGE: 'PURGE'; -KW_RANGE: 'RANGE'; -KW_ANALYZE: 'ANALYZE'; -KW_BEFORE: 'BEFORE'; -KW_BETWEEN: 'BETWEEN'; -KW_BOTH: 'BOTH'; -KW_BINARY: 'BINARY'; -KW_CROSS: 'CROSS'; -KW_CONTINUE: 'CONTINUE'; -KW_CURSOR: 'CURSOR'; -KW_TRIGGER: 'TRIGGER'; -KW_RECORDREADER: 'RECORDREADER'; -KW_RECORDWRITER: 'RECORDWRITER'; -KW_SEMI: 'SEMI'; -KW_LATERAL: 'LATERAL'; -KW_TOUCH: 'TOUCH'; -KW_ARCHIVE: 'ARCHIVE'; -KW_UNARCHIVE: 'UNARCHIVE'; -KW_COMPUTE: 'COMPUTE'; -KW_STATISTICS: 'STATISTICS'; -KW_USE: 'USE'; -KW_OPTION: 'OPTION'; -KW_CONCATENATE: 'CONCATENATE'; -KW_SHOW_DATABASE: 'SHOW_DATABASE'; -KW_UPDATE: 'UPDATE'; -KW_RESTRICT: 'RESTRICT'; -KW_CASCADE: 'CASCADE'; -KW_SKEWED: 'SKEWED'; -KW_ROLLUP: 'ROLLUP'; -KW_CUBE: 'CUBE'; -KW_DIRECTORIES: 'DIRECTORIES'; -KW_FOR: 'FOR'; -KW_WINDOW: 'WINDOW'; -KW_UNBOUNDED: 'UNBOUNDED'; -KW_PRECEDING: 'PRECEDING'; -KW_FOLLOWING: 'FOLLOWING'; -KW_CURRENT: 'CURRENT'; -KW_CURRENT_DATE: 'CURRENT_DATE'; -KW_CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; -KW_LESS: 'LESS'; -KW_MORE: 'MORE'; -KW_OVER: 'OVER'; -KW_GROUPING: 'GROUPING'; -KW_SETS: 'SETS'; -KW_TRUNCATE: 'TRUNCATE'; -KW_NOSCAN: 'NOSCAN'; -KW_USER: 'USER'; -KW_ROLE: 'ROLE'; -KW_ROLES: 'ROLES'; -KW_INNER: 'INNER'; -KW_EXCHANGE: 'EXCHANGE'; -KW_URI: 'URI'; -KW_SERVER : 'SERVER'; -KW_ADMIN: 'ADMIN'; -KW_OWNER: 'OWNER'; -KW_PRINCIPALS: 'PRINCIPALS'; -KW_COMPACT: 'COMPACT'; -KW_COMPACTIONS: 'COMPACTIONS'; -KW_TRANSACTIONS: 'TRANSACTIONS'; -KW_TRANSACTIONAL: 'TRANSACTIONAL'; -KW_REWRITE : 'REWRITE'; -KW_AUTHORIZATION: 'AUTHORIZATION'; -KW_REOPTIMIZATION: 'REOPTIMIZATION'; -KW_CONF: 'CONF'; -KW_VALUES: 'VALUES'; -KW_RELOAD: 'RELOAD'; -KW_YEAR: 'YEAR' | 'YEARS'; -KW_QUERY: 'QUERY'; -KW_QUARTER: 'QUARTER'; -KW_MONTH: 'MONTH' | 'MONTHS'; -KW_WEEK: 'WEEK' | 'WEEKS'; -KW_DAY: 'DAY' | 'DAYS'; -KW_DOW: 'DAYOFWEEK'; -KW_HOUR: 'HOUR' | 'HOURS'; -KW_MINUTE: 'MINUTE' | 'MINUTES'; -KW_SECOND: 'SECOND' | 'SECONDS'; -KW_START: 'START'; -KW_TRANSACTION: 'TRANSACTION'; -KW_COMMIT: 'COMMIT'; -KW_ROLLBACK: 'ROLLBACK'; -KW_WORK: 'WORK'; -KW_ONLY: 'ONLY'; -KW_WRITE: 'WRITE'; -KW_ISOLATION: 'ISOLATION'; -KW_LEVEL: 'LEVEL'; -KW_SNAPSHOT: 'SNAPSHOT'; -KW_AUTOCOMMIT: 'AUTOCOMMIT'; -KW_CACHE: 'CACHE'; -KW_PRIMARY: 'PRIMARY'; -KW_FOREIGN: 'FOREIGN'; -KW_REFERENCES: 'REFERENCES'; -KW_CONSTRAINT: 'CONSTRAINT'; -KW_FORCE: 'FORCE'; -KW_ENFORCED: 'ENFORCED'; -KW_VALIDATE: 'VALIDATE'; -KW_NOVALIDATE: 'NOVALIDATE'; -KW_RELY: 'RELY'; -KW_NORELY: 'NORELY'; -KW_UNIQUE: 'UNIQUE'; -KW_KEY: 'KEY'; -KW_ABORT: 'ABORT'; -KW_EXTRACT: 'EXTRACT'; -KW_FLOOR: 'FLOOR'; -KW_MERGE: 'MERGE'; -KW_MATCHED: 'MATCHED'; -KW_REPL: 'REPL'; -KW_DUMP: 'DUMP'; -KW_STATUS: 'STATUS'; -KW_VECTORIZATION: 'VECTORIZATION'; -KW_SUMMARY: 'SUMMARY'; -KW_OPERATOR: 'OPERATOR'; -KW_EXPRESSION: 'EXPRESSION'; -KW_DETAIL: 'DETAIL'; -KW_WAIT: 'WAIT'; -KW_RESOURCE: 'RESOURCE'; -KW_PLAN: 'PLAN'; -KW_QUERY_PARALLELISM: 'QUERY_PARALLELISM'; -KW_PLANS: 'PLANS'; -KW_ACTIVATE: 'ACTIVATE'; -KW_DEFAULT: 'DEFAULT'; -KW_CHECK: 'CHECK'; -KW_POOL: 'POOL'; -KW_MOVE: 'MOVE'; -KW_DO: 'DO'; -KW_ALLOC_FRACTION: 'ALLOC_FRACTION'; -KW_SCHEDULING_POLICY: 'SCHEDULING_POLICY'; -KW_SCHEDULED: 'SCHEDULED'; -KW_EVERY: 'EVERY'; -KW_AT: 'AT'; -KW_CRON: 'CRON'; -KW_PATH: 'PATH'; -KW_MAPPING: 'MAPPING'; -KW_WORKLOAD: 'WORKLOAD'; -KW_MANAGEMENT: 'MANAGEMENT'; -KW_ACTIVE: 'ACTIVE'; -KW_UNMANAGED: 'UNMANAGED'; -KW_APPLICATION: 'APPLICATION'; -KW_SYNC: 'SYNC'; -KW_AST: 'AST'; -KW_COST: 'COST'; -KW_JOINCOST: 'JOINCOST'; -KW_WITHIN: 'WITHIN'; - -// Operators -// NOTE: if you add a new function/operator, add it to sysFuncNames so that describe function _FUNC_ will work. - -DOT : '.'; // generated as a part of Number rule -COLON : ':' ; -COMMA : ',' ; -SEMICOLON : ';' ; - -LPAREN : '(' ; -RPAREN : ')' ; -LSQUARE : '[' ; -RSQUARE : ']' ; -LCURLY : '{'; -RCURLY : '}'; - -EQUAL : '=' | '=='; -EQUAL_NS : '<=>'; -NOTEQUAL : '<>' | '!='; -LESSTHANOREQUALTO : '<='; -LESSTHAN : '<'; -GREATERTHANOREQUALTO : '>='; -GREATERTHAN : '>'; - -DIVIDE : '/'; -PLUS : '+'; -MINUS : '-'; -STAR : '*'; -MOD : '%'; -DIV : 'DIV'; - -AMPERSAND : '&'; -TILDE : '~'; -BITWISEOR : '|'; -CONCATENATE : '||'; -BITWISEXOR : '^'; -QUESTION : '?'; -DOLLAR : '$'; - -// LITERALS -fragment -Letter - : 'a'..'z' | 'A'..'Z' - ; - -fragment -HexDigit - : 'a'..'f' | 'A'..'F' - ; - -fragment -Digit - : - '0'..'9' - ; - -fragment -Exponent - : - ('e' | 'E') ( PLUS|MINUS )? (Digit)+ - ; - -fragment -RegexComponent - : 'a'..'z' | 'A'..'Z' | '0'..'9' | '_' - | PLUS | STAR | QUESTION | MINUS | DOT - | LPAREN | RPAREN | LSQUARE | RSQUARE | LCURLY | RCURLY - | BITWISEXOR | BITWISEOR | DOLLAR | '!' - ; - StringLiteral : - ( '\'' ( ~('\''|'\\') | ('\\' .) )* '\'' - | '\"' ( ~('\"'|'\\') | ('\\' .) )* '\"' - )+ - ; - -CharSetLiteral - : - StringLiteral - | '0' 'X' (HexDigit|Digit)+ + ( '\"' ( ~('\"'|'\\') | ('\\' .) )* '\"' | '\'' ( ~('\''|'\\') | ('\\' .) )* '\'' )+ ; -IntegralLiteral - : - (Digit)+ ('L' | 'S' | 'Y') - ; - -NumberLiteral - : - Number ('D' | 'B' 'D') - ; - -ByteLengthLiteral - : - (Digit)+ ('b' | 'B' | 'k' | 'K' | 'm' | 'M' | 'g' | 'G') - ; - -Number - : - (Digit)+ ( DOT (Digit)* (Exponent)? | Exponent)? - ; - -/* -An Identifier can be: -- tableName -- columnName -- select expr alias -- lateral view aliases -- database name -- view name -- subquery alias -- function name -- ptf argument identifier -- index name -- property name for: db,tbl,partition... -- fileFormat -- role name -- privilege name -- principal name -- macro name -- hint name -- window name -*/ -Identifier - : - (Letter | Digit) (Letter | Digit | '_')* - | {allowQuotedId()}? QuotedIdentifier /* though at the language level we allow all Identifiers to be QuotedIdentifiers; - at the API level only columns are allowed to be of this form */ - | '`' RegexComponent+ '`' - ; - -fragment -QuotedIdentifier - : - '`' ( '``' | ~('`') )* '`' { setText(StringUtils.replace(getText().substring(1, getText().length() -1 ), "``", "`")); } - ; - -CharSetName +fragment +QuotedIdentifier : - '_' (Letter | Digit | '_' | '-' | '.' | ':' )+ - ; - -WS : (' '|'\r'|'\t'|'\n') {$channel=HIDDEN;} - ; - -LINE_COMMENT - : '--' (~('\n'|'\r'))* { $channel=HIDDEN; } - ; - -QUERY_HINT - : '/*' (options { greedy=false; } : QUERY_HINT|.)* '*/' { if(getText().charAt(2) != '+') { $channel=HIDDEN; } else { setText(getText().substring(3, getText().length() - 2)); } } + ('`' ( '``' | ~('`') )* '`') { setText(StringUtils.replace(getText().substring(1, getText().length() -1 ), "``", "`")); } ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g new file mode 100644 index 0000000000..f8cd211345 --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerParent.g @@ -0,0 +1,522 @@ +/** + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +lexer grammar HiveLexerParent; + +// Keywords + +KW_TRUE : 'TRUE'; +KW_FALSE : 'FALSE'; +KW_UNKNOWN : 'UNKNOWN'; +KW_ALL : 'ALL'; +KW_SOME : 'SOME'; +KW_NONE: 'NONE'; +KW_AND : 'AND'; +KW_OR : 'OR'; +KW_NOT : 'NOT' | '!'; +KW_LIKE : 'LIKE'; +KW_ANY : 'ANY'; + +KW_IF : 'IF'; +KW_EXISTS : 'EXISTS'; + +KW_ASC : 'ASC'; +KW_DESC : 'DESC'; +KW_NULLS : 'NULLS'; +KW_LAST : 'LAST'; +KW_ORDER : 'ORDER'; +KW_GROUP : 'GROUP'; +KW_BY : 'BY'; +KW_HAVING : 'HAVING'; +KW_WHERE : 'WHERE'; +KW_FROM : 'FROM'; +KW_AS : 'AS'; +KW_SELECT : 'SELECT'; +KW_DISTINCT : 'DISTINCT'; +KW_INSERT : 'INSERT'; +KW_OVERWRITE : 'OVERWRITE'; +KW_OUTER : 'OUTER'; +KW_UNIQUEJOIN : 'UNIQUEJOIN'; +KW_PRESERVE : 'PRESERVE'; +KW_JOIN : 'JOIN'; +KW_LEFT : 'LEFT'; +KW_RIGHT : 'RIGHT'; +KW_FULL : 'FULL'; +KW_ON : 'ON'; +KW_PARTITION : 'PARTITION'; +KW_PARTITIONS : 'PARTITIONS'; +KW_TABLE: 'TABLE'; +KW_TABLES: 'TABLES'; +KW_COLUMNS: 'COLUMNS'; +KW_INDEX: 'INDEX'; +KW_INDEXES: 'INDEXES'; +KW_REBUILD: 'REBUILD'; +KW_FUNCTIONS: 'FUNCTIONS'; +KW_SHOW: 'SHOW'; +KW_MSCK: 'MSCK'; +KW_REPAIR: 'REPAIR'; +KW_DIRECTORY: 'DIRECTORY'; +KW_LOCAL: 'LOCAL'; +KW_TRANSFORM : 'TRANSFORM'; +KW_USING: 'USING'; +KW_CLUSTER: 'CLUSTER'; +KW_DISTRIBUTE: 'DISTRIBUTE'; +KW_SORT: 'SORT'; +KW_UNION: 'UNION'; +KW_EXCEPT: 'EXCEPT'; +KW_LOAD: 'LOAD'; +KW_EXPORT: 'EXPORT'; +KW_IMPORT: 'IMPORT'; +KW_REPLICATION: 'REPLICATION'; +KW_METADATA: 'METADATA'; +KW_DATA: 'DATA'; +KW_INPATH: 'INPATH'; +KW_IS: 'IS'; +KW_NULL: 'NULL'; +KW_CREATE: 'CREATE'; +KW_EXTERNAL: 'EXTERNAL'; +KW_ALTER: 'ALTER'; +KW_CHANGE: 'CHANGE'; +KW_COLUMN: 'COLUMN'; +KW_FIRST: 'FIRST'; +KW_AFTER: 'AFTER'; +KW_DESCRIBE: 'DESCRIBE'; +KW_DROP: 'DROP'; +KW_RENAME: 'RENAME'; +KW_TO: 'TO'; +KW_COMMENT: 'COMMENT'; +KW_BOOLEAN: 'BOOLEAN'; +KW_TINYINT: 'TINYINT'; +KW_SMALLINT: 'SMALLINT'; +KW_INT: 'INT' | 'INTEGER'; +KW_BIGINT: 'BIGINT'; +KW_FLOAT: 'FLOAT'; +KW_REAL: 'REAL'; +KW_DOUBLE: 'DOUBLE'; +KW_PRECISION: 'PRECISION'; +KW_DATE: 'DATE'; +KW_DATETIME: 'DATETIME'; +KW_TIMESTAMP: 'TIMESTAMP'; +KW_TIMESTAMPLOCALTZ: 'TIMESTAMPLOCALTZ'; +KW_TIME: 'TIME'; +KW_ZONE: 'ZONE'; +KW_INTERVAL: 'INTERVAL'; +KW_DECIMAL: 'DECIMAL' | 'DEC' | 'NUMERIC'; +KW_STRING: 'STRING'; +KW_CHAR: 'CHAR'; +KW_VARCHAR: 'VARCHAR'; +KW_ARRAY: 'ARRAY'; +KW_STRUCT: 'STRUCT'; +KW_MAP: 'MAP'; +KW_UNIONTYPE: 'UNIONTYPE'; +KW_REDUCE: 'REDUCE'; +KW_PARTITIONED: 'PARTITIONED'; +KW_CLUSTERED: 'CLUSTERED'; +KW_DISTRIBUTED: 'DISTRIBUTED'; +KW_SORTED: 'SORTED'; +KW_INTO: 'INTO'; +KW_BUCKETS: 'BUCKETS'; +KW_ROW: 'ROW'; +KW_ROWS: 'ROWS'; +KW_FORMAT: 'FORMAT'; +KW_DELIMITED: 'DELIMITED'; +KW_FIELDS: 'FIELDS'; +KW_TERMINATED: 'TERMINATED'; +KW_ESCAPED: 'ESCAPED'; +KW_COLLECTION: 'COLLECTION'; +KW_ITEMS: 'ITEMS'; +KW_KEYS: 'KEYS'; +KW_KEY_TYPE: '$KEY$'; +KW_KILL: 'KILL'; +KW_LINES: 'LINES'; +KW_STORED: 'STORED'; +KW_FILEFORMAT: 'FILEFORMAT'; +KW_INPUTFORMAT: 'INPUTFORMAT'; +KW_OUTPUTFORMAT: 'OUTPUTFORMAT'; +KW_INPUTDRIVER: 'INPUTDRIVER'; +KW_OUTPUTDRIVER: 'OUTPUTDRIVER'; +KW_ENABLE: 'ENABLE' | 'ENABLED'; +KW_DISABLE: 'DISABLE' | 'DISABLED'; +KW_EXECUTED: 'EXECUTED'; +KW_EXECUTE: 'EXECUTE'; +KW_LOCATION: 'LOCATION'; +KW_MANAGEDLOCATION: 'MANAGEDLOCATION'; +KW_TABLESAMPLE: 'TABLESAMPLE'; +KW_BUCKET: 'BUCKET'; +KW_OUT: 'OUT'; +KW_OF: 'OF'; +KW_PERCENT: 'PERCENT'; +KW_CAST: 'CAST'; +KW_ADD: 'ADD'; +KW_REPLACE: 'REPLACE'; +KW_RLIKE: 'RLIKE'; +KW_REGEXP: 'REGEXP'; +KW_TEMPORARY: 'TEMPORARY'; +KW_FUNCTION: 'FUNCTION'; +KW_MACRO: 'MACRO'; +KW_FILE: 'FILE'; +KW_JAR: 'JAR'; +KW_EXPLAIN: 'EXPLAIN'; +KW_EXTENDED: 'EXTENDED'; +KW_DEBUG: 'DEBUG'; +KW_FORMATTED: 'FORMATTED'; +KW_DEPENDENCY: 'DEPENDENCY'; +KW_LOGICAL: 'LOGICAL'; +KW_CBO: 'CBO'; +KW_SERDE: 'SERDE'; +KW_WITH: 'WITH'; +KW_DEFERRED: 'DEFERRED'; +KW_SERDEPROPERTIES: 'SERDEPROPERTIES'; +KW_DBPROPERTIES: 'DBPROPERTIES'; +KW_LIMIT: 'LIMIT'; +KW_OFFSET: 'OFFSET'; +KW_SET: 'SET'; +KW_UNSET: 'UNSET'; +KW_TBLPROPERTIES: 'TBLPROPERTIES'; +KW_IDXPROPERTIES: 'IDXPROPERTIES'; +KW_VALUE_TYPE: '$VALUE$'; +KW_ELEM_TYPE: '$ELEM$'; +KW_DEFINED: 'DEFINED'; +KW_CASE: 'CASE'; +KW_WHEN: 'WHEN'; +KW_THEN: 'THEN'; +KW_ELSE: 'ELSE'; +KW_END: 'END'; +KW_MAPJOIN: 'MAPJOIN'; +KW_STREAMTABLE: 'STREAMTABLE'; +KW_CLUSTERSTATUS: 'CLUSTERSTATUS'; +KW_UTC: 'UTC'; +KW_UTCTIMESTAMP: 'UTC_TMESTAMP'; +KW_LONG: 'LONG'; +KW_DELETE: 'DELETE'; +KW_PLUS: 'PLUS'; +KW_MINUS: 'MINUS'; +KW_FETCH: 'FETCH'; +KW_INTERSECT: 'INTERSECT'; +KW_VIEW: 'VIEW'; +KW_VIEWS: 'VIEWS'; +KW_IN: 'IN'; +KW_DATABASE: 'DATABASE'; +KW_DATABASES: 'DATABASES'; +KW_MATERIALIZED: 'MATERIALIZED'; +KW_SCHEMA: 'SCHEMA'; +KW_SCHEMAS: 'SCHEMAS'; +KW_GRANT: 'GRANT'; +KW_REVOKE: 'REVOKE'; +KW_SSL: 'SSL'; +KW_UNDO: 'UNDO'; +KW_LOCK: 'LOCK'; +KW_LOCKS: 'LOCKS'; +KW_UNLOCK: 'UNLOCK'; +KW_SHARED: 'SHARED'; +KW_EXCLUSIVE: 'EXCLUSIVE'; +KW_PROCEDURE: 'PROCEDURE'; +KW_UNSIGNED: 'UNSIGNED'; +KW_WHILE: 'WHILE'; +KW_READ: 'READ'; +KW_READS: 'READS'; +KW_PURGE: 'PURGE'; +KW_RANGE: 'RANGE'; +KW_ANALYZE: 'ANALYZE'; +KW_BEFORE: 'BEFORE'; +KW_BETWEEN: 'BETWEEN'; +KW_BOTH: 'BOTH'; +KW_BINARY: 'BINARY'; +KW_CROSS: 'CROSS'; +KW_CONTINUE: 'CONTINUE'; +KW_CURSOR: 'CURSOR'; +KW_TRIGGER: 'TRIGGER'; +KW_RECORDREADER: 'RECORDREADER'; +KW_RECORDWRITER: 'RECORDWRITER'; +KW_SEMI: 'SEMI'; +KW_LATERAL: 'LATERAL'; +KW_TOUCH: 'TOUCH'; +KW_ARCHIVE: 'ARCHIVE'; +KW_UNARCHIVE: 'UNARCHIVE'; +KW_COMPUTE: 'COMPUTE'; +KW_STATISTICS: 'STATISTICS'; +KW_USE: 'USE'; +KW_OPTION: 'OPTION'; +KW_CONCATENATE: 'CONCATENATE'; +KW_SHOW_DATABASE: 'SHOW_DATABASE'; +KW_UPDATE: 'UPDATE'; +KW_RESTRICT: 'RESTRICT'; +KW_CASCADE: 'CASCADE'; +KW_SKEWED: 'SKEWED'; +KW_ROLLUP: 'ROLLUP'; +KW_CUBE: 'CUBE'; +KW_DIRECTORIES: 'DIRECTORIES'; +KW_FOR: 'FOR'; +KW_WINDOW: 'WINDOW'; +KW_UNBOUNDED: 'UNBOUNDED'; +KW_PRECEDING: 'PRECEDING'; +KW_FOLLOWING: 'FOLLOWING'; +KW_CURRENT: 'CURRENT'; +KW_CURRENT_DATE: 'CURRENT_DATE'; +KW_CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +KW_LESS: 'LESS'; +KW_MORE: 'MORE'; +KW_OVER: 'OVER'; +KW_GROUPING: 'GROUPING'; +KW_SETS: 'SETS'; +KW_TRUNCATE: 'TRUNCATE'; +KW_NOSCAN: 'NOSCAN'; +KW_USER: 'USER'; +KW_ROLE: 'ROLE'; +KW_ROLES: 'ROLES'; +KW_INNER: 'INNER'; +KW_EXCHANGE: 'EXCHANGE'; +KW_URI: 'URI'; +KW_SERVER : 'SERVER'; +KW_ADMIN: 'ADMIN'; +KW_OWNER: 'OWNER'; +KW_PRINCIPALS: 'PRINCIPALS'; +KW_COMPACT: 'COMPACT'; +KW_COMPACTIONS: 'COMPACTIONS'; +KW_TRANSACTIONS: 'TRANSACTIONS'; +KW_TRANSACTIONAL: 'TRANSACTIONAL'; +KW_REWRITE : 'REWRITE'; +KW_AUTHORIZATION: 'AUTHORIZATION'; +KW_REOPTIMIZATION: 'REOPTIMIZATION'; +KW_CONF: 'CONF'; +KW_VALUES: 'VALUES'; +KW_RELOAD: 'RELOAD'; +KW_YEAR: 'YEAR' | 'YEARS'; +KW_QUERY: 'QUERY'; +KW_QUARTER: 'QUARTER'; +KW_MONTH: 'MONTH' | 'MONTHS'; +KW_WEEK: 'WEEK' | 'WEEKS'; +KW_DAY: 'DAY' | 'DAYS'; +KW_DOW: 'DAYOFWEEK'; +KW_HOUR: 'HOUR' | 'HOURS'; +KW_MINUTE: 'MINUTE' | 'MINUTES'; +KW_SECOND: 'SECOND' | 'SECONDS'; +KW_START: 'START'; +KW_TRANSACTION: 'TRANSACTION'; +KW_COMMIT: 'COMMIT'; +KW_ROLLBACK: 'ROLLBACK'; +KW_WORK: 'WORK'; +KW_ONLY: 'ONLY'; +KW_WRITE: 'WRITE'; +KW_ISOLATION: 'ISOLATION'; +KW_LEVEL: 'LEVEL'; +KW_SNAPSHOT: 'SNAPSHOT'; +KW_AUTOCOMMIT: 'AUTOCOMMIT'; +KW_CACHE: 'CACHE'; +KW_PRIMARY: 'PRIMARY'; +KW_FOREIGN: 'FOREIGN'; +KW_REFERENCES: 'REFERENCES'; +KW_CONSTRAINT: 'CONSTRAINT'; +KW_FORCE: 'FORCE'; +KW_ENFORCED: 'ENFORCED'; +KW_VALIDATE: 'VALIDATE'; +KW_NOVALIDATE: 'NOVALIDATE'; +KW_RELY: 'RELY'; +KW_NORELY: 'NORELY'; +KW_UNIQUE: 'UNIQUE'; +KW_KEY: 'KEY'; +KW_ABORT: 'ABORT'; +KW_EXTRACT: 'EXTRACT'; +KW_FLOOR: 'FLOOR'; +KW_MERGE: 'MERGE'; +KW_MATCHED: 'MATCHED'; +KW_REPL: 'REPL'; +KW_DUMP: 'DUMP'; +KW_STATUS: 'STATUS'; +KW_VECTORIZATION: 'VECTORIZATION'; +KW_SUMMARY: 'SUMMARY'; +KW_OPERATOR: 'OPERATOR'; +KW_EXPRESSION: 'EXPRESSION'; +KW_DETAIL: 'DETAIL'; +KW_WAIT: 'WAIT'; +KW_RESOURCE: 'RESOURCE'; +KW_PLAN: 'PLAN'; +KW_QUERY_PARALLELISM: 'QUERY_PARALLELISM'; +KW_PLANS: 'PLANS'; +KW_ACTIVATE: 'ACTIVATE'; +KW_DEFAULT: 'DEFAULT'; +KW_CHECK: 'CHECK'; +KW_POOL: 'POOL'; +KW_MOVE: 'MOVE'; +KW_DO: 'DO'; +KW_ALLOC_FRACTION: 'ALLOC_FRACTION'; +KW_SCHEDULING_POLICY: 'SCHEDULING_POLICY'; +KW_SCHEDULED: 'SCHEDULED'; +KW_EVERY: 'EVERY'; +KW_AT: 'AT'; +KW_CRON: 'CRON'; +KW_PATH: 'PATH'; +KW_MAPPING: 'MAPPING'; +KW_WORKLOAD: 'WORKLOAD'; +KW_MANAGEMENT: 'MANAGEMENT'; +KW_ACTIVE: 'ACTIVE'; +KW_UNMANAGED: 'UNMANAGED'; +KW_APPLICATION: 'APPLICATION'; +KW_SYNC: 'SYNC'; +KW_AST: 'AST'; +KW_COST: 'COST'; +KW_JOINCOST: 'JOINCOST'; +KW_WITHIN: 'WITHIN'; + +// Operators +// NOTE: if you add a new function/operator, add it to sysFuncNames so that describe function _FUNC_ will work. + +DOT : '.'; // generated as a part of Number rule +COLON : ':' ; +COMMA : ',' ; +SEMICOLON : ';' ; + +LPAREN : '(' ; +RPAREN : ')' ; +LSQUARE : '[' ; +RSQUARE : ']' ; +LCURLY : '{'; +RCURLY : '}'; + +EQUAL : '=' | '=='; +EQUAL_NS : '<=>'; +NOTEQUAL : '<>' | '!='; +LESSTHANOREQUALTO : '<='; +LESSTHAN : '<'; +GREATERTHANOREQUALTO : '>='; +GREATERTHAN : '>'; + +DIVIDE : '/'; +PLUS : '+'; +MINUS : '-'; +STAR : '*'; +MOD : '%'; +DIV : 'DIV'; + +AMPERSAND : '&'; +TILDE : '~'; +BITWISEOR : '|'; +CONCATENATE : '||'; +BITWISEXOR : '^'; +QUESTION : '?'; +DOLLAR : '$'; + +// LITERALS +fragment +Letter + : 'a'..'z' | 'A'..'Z' + ; + +fragment +HexDigit + : 'a'..'f' | 'A'..'F' + ; + +fragment +Digit + : + '0'..'9' + ; + +fragment +Exponent + : + ('e' | 'E') ( PLUS|MINUS )? (Digit)+ + ; + +fragment +RegexComponent + : 'a'..'z' | 'A'..'Z' | '0'..'9' | '_' + | PLUS | STAR | QUESTION | MINUS | DOT + | LPAREN | RPAREN | LSQUARE | RSQUARE | LCURLY | RCURLY + | BITWISEXOR | BITWISEOR | DOLLAR | '!' + ; + +StringLiteral + : + // This is implemented by subclass. + ; + +CharSetLiteral + : + StringLiteral + | '0' 'X' (HexDigit|Digit)+ + ; + +IntegralLiteral + : + (Digit)+ ('L' | 'S' | 'Y') + ; + +NumberLiteral + : + Number ('D' | 'B' 'D') + ; + +ByteLengthLiteral + : + (Digit)+ ('b' | 'B' | 'k' | 'K' | 'm' | 'M' | 'g' | 'G') + ; + +Number + : + (Digit)+ ( DOT (Digit)* (Exponent)? | Exponent)? + ; + +/* +An Identifier can be: +- tableName +- columnName +- select expr alias +- lateral view aliases +- database name +- view name +- subquery alias +- function name +- ptf argument identifier +- index name +- property name for: db,tbl,partition... +- fileFormat +- role name +- privilege name +- principal name +- macro name +- hint name +- window name +*/ +Identifier + : + (Letter | Digit) (Letter | Digit | '_')* + | {allowQuotedId() != Quotation.NONE}? QuotedIdentifier + | '`' RegexComponent+ '`' + ; + +fragment +QuotedIdentifier + : + // This is implemented by subclass. + ; + +CharSetName + : + '_' (Letter | Digit | '_' | '-' | '.' | ':' )+ + ; + +WS : (' '|'\r'|'\t'|'\n') {$channel=HIDDEN;} + ; + +LINE_COMMENT + : '--' (~('\n'|'\r'))* { $channel=HIDDEN; } + ; + +QUERY_HINT + : '/*' (options { greedy=false; } : QUERY_HINT|.)* '*/' { if(getText().charAt(2) != '+') { $channel=HIDDEN; } else { setText(getText().substring(3, getText().length() - 2)); } } + ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerStandard.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerStandard.g new file mode 100644 index 0000000000..8f1470008b --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveLexerStandard.g @@ -0,0 +1,39 @@ +/** + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +lexer grammar HiveLexerStandard; + +options { +superClass = GenericHiveLexer; +} +import HiveLexerParent; + +@lexer::header { +package org.apache.hadoop.hive.ql.parse; + +import org.apache.commons.lang3.StringUtils; +} + +StringLiteral + : + ( '\'' ( ~('\''|'\\') | ('\\' .) )* '\'' )+ + ; + +fragment +QuotedIdentifier + : + ('"' ( '""' | ~('"') )* '"') { setText(StringUtils.replace(getText().substring(1, getText().length() -1 ), "\"\"", "\"")); } + ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g index b03b0989b8..ba5bd28091 100644 --- parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParser.g @@ -23,798 +23,12 @@ output=AST; ASTLabelType=ASTNode; backtrack=false; k=3; +superClass = GenericHiveParser; } -import SelectClauseParser, FromClauseParser, IdentifiersParser, ResourcePlanParser; +import HiveParserParent; -tokens { -TOK_INSERT; -TOK_QUERY; -TOK_SELECT; -TOK_SELECTDI; -TOK_SELEXPR; -TOK_FROM; -TOK_TAB; -TOK_PARTSPEC; -TOK_PARTVAL; -TOK_DIR; -TOK_TABREF; -TOK_SUBQUERY; -TOK_INSERT_INTO; -TOK_DESTINATION; -TOK_ALLCOLREF; -TOK_SETCOLREF; -TOK_TABLE_OR_COL; -TOK_FUNCTION; -TOK_FUNCTIONDI; -TOK_FUNCTIONSTAR; -TOK_WHERE; -TOK_OP_EQ; -TOK_OP_NE; -TOK_OP_LE; -TOK_OP_LT; -TOK_OP_GE; -TOK_OP_GT; -TOK_OP_DIV; -TOK_OP_ADD; -TOK_OP_SUB; -TOK_OP_MUL; -TOK_OP_MOD; -TOK_OP_BITAND; -TOK_OP_BITNOT; -TOK_OP_BITOR; -TOK_OP_BITXOR; -TOK_OP_AND; -TOK_OP_OR; -TOK_OP_NOT; -TOK_OP_LIKE; -TOK_TRUE; -TOK_FALSE; -TOK_UNKNOWN; -TOK_TRANSFORM; -TOK_SERDE; -TOK_SERDENAME; -TOK_SERDEPROPS; -TOK_EXPLIST; -TOK_ALIASLIST; -TOK_GROUPBY; -TOK_ROLLUP_GROUPBY; -TOK_CUBE_GROUPBY; -TOK_GROUPING_SETS; -TOK_GROUPING_SETS_EXPRESSION; -TOK_HAVING; -TOK_ORDERBY; -TOK_NULLS_FIRST; -TOK_NULLS_LAST; -TOK_CLUSTERBY; -TOK_DISTRIBUTEBY; -TOK_SORTBY; -TOK_UNIONALL; -TOK_UNIONDISTINCT; -TOK_INTERSECTALL; -TOK_INTERSECTDISTINCT; -TOK_EXCEPTALL; -TOK_EXCEPTDISTINCT; -TOK_JOIN; -TOK_LEFTOUTERJOIN; -TOK_RIGHTOUTERJOIN; -TOK_FULLOUTERJOIN; -TOK_UNIQUEJOIN; -TOK_CROSSJOIN; -TOK_LOAD; -TOK_EXPORT; -TOK_IMPORT; -TOK_REPLICATION; -TOK_METADATA; -TOK_NULL; -TOK_NOT_NULL; -TOK_UNIQUE; -TOK_PRIMARY_KEY; -TOK_FOREIGN_KEY; -TOK_DEFAULT_VALUE; -TOK_CHECK_CONSTRAINT; -TOK_VALIDATE; -TOK_NOVALIDATE; -TOK_RELY; -TOK_NORELY; -TOK_CONSTRAINT_NAME; -TOK_TINYINT; -TOK_SMALLINT; -TOK_INT; -TOK_BIGINT; -TOK_BOOLEAN; -TOK_FLOAT; -TOK_REAL; -TOK_DOUBLE; -TOK_DATE; -TOK_DATELITERAL; -TOK_DATETIME; -TOK_TIMESTAMP; -TOK_TIMESTAMPLITERAL; -TOK_TIMESTAMPLOCALTZ; -TOK_TIMESTAMPLOCALTZLITERAL; -TOK_INTERVAL_YEAR_MONTH; -TOK_INTERVAL_YEAR_MONTH_LITERAL; -TOK_INTERVAL_DAY_TIME; -TOK_INTERVAL_DAY_TIME_LITERAL; -TOK_INTERVAL_YEAR_LITERAL; -TOK_INTERVAL_MONTH_LITERAL; -TOK_INTERVAL_DAY_LITERAL; -TOK_INTERVAL_HOUR_LITERAL; -TOK_INTERVAL_MINUTE_LITERAL; -TOK_INTERVAL_SECOND_LITERAL; -TOK_STRING; -TOK_CHAR; -TOK_VARCHAR; -TOK_BINARY; -TOK_DECIMAL; -TOK_LIST; -TOK_STRUCT; -TOK_MAP; -TOK_UNIONTYPE; -TOK_COLTYPELIST; -TOK_CREATEDATABASE; -TOK_CREATETABLE; -TOK_TRUNCATETABLE; -TOK_LIKETABLE; -TOK_DESCTABLE; -TOK_DESCFUNCTION; -TOK_ALTERTABLE; -TOK_ALTERTABLE_RENAME; -TOK_ALTERTABLE_ADDCOLS; -TOK_ALTERTABLE_RENAMECOL; -TOK_ALTERTABLE_RENAMEPART; -TOK_ALTERTABLE_REPLACECOLS; -TOK_ALTERTABLE_ADDPARTS; -TOK_ALTERTABLE_DROPPARTS; -TOK_ALTERTABLE_PARTCOLTYPE; -TOK_ALTERTABLE_MERGEFILES; -TOK_ALTERPARTITION_MERGEFILES; -TOK_ALTERTABLE_TOUCH; -TOK_ALTERTABLE_ARCHIVE; -TOK_ALTERTABLE_UNARCHIVE; -TOK_ALTERTABLE_SERDEPROPERTIES; -TOK_ALTERPARTITION_SERDEPROPERTIES; -TOK_ALTERTABLE_SERIALIZER; -TOK_ALTERPARTITION_SERIALIZER; -TOK_ALTERTABLE_UPDATECOLSTATS; -TOK_ALTERPARTITION_UPDATECOLSTATS; -TOK_ALTERTABLE_UPDATESTATS; -TOK_ALTERPARTITION_UPDATESTATS; -TOK_TABLE_PARTITION; -TOK_ALTERTABLE_FILEFORMAT; -TOK_ALTERPARTITION_FILEFORMAT; -TOK_ALTERTABLE_LOCATION; -TOK_ALTERPARTITION_LOCATION; -TOK_ALTERTABLE_PROPERTIES; -TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION; -TOK_ALTERTABLE_DROPPROPERTIES; -TOK_ALTERTABLE_SKEWED; -TOK_ALTERTABLE_EXCHANGEPARTITION; -TOK_ALTERTABLE_SKEWED_LOCATION; -TOK_ALTERTABLE_BUCKETS; -TOK_ALTERPARTITION_BUCKETS; -TOK_ALTERTABLE_CLUSTER_SORT; -TOK_ALTERTABLE_COMPACT; -TOK_ALTERTABLE_DROPCONSTRAINT; -TOK_ALTERTABLE_ADDCONSTRAINT; -TOK_ALTERTABLE_UPDATECOLUMNS; -TOK_ALTERTABLE_OWNER; -TOK_MSCK; -TOK_SHOWDATABASES; -TOK_SHOWTABLES; -TOK_SHOWCOLUMNS; -TOK_SHOWFUNCTIONS; -TOK_SHOWPARTITIONS; -TOK_SHOW_CREATEDATABASE; -TOK_SHOW_CREATETABLE; -TOK_SHOW_TABLESTATUS; -TOK_SHOW_TBLPROPERTIES; -TOK_SHOWLOCKS; -TOK_SHOWCONF; -TOK_LOCKTABLE; -TOK_UNLOCKTABLE; -TOK_LOCKDB; -TOK_UNLOCKDB; -TOK_SWITCHDATABASE; -TOK_DROPDATABASE; -TOK_DROPTABLE; -TOK_DATABASECOMMENT; -TOK_TABCOLLIST; -TOK_TABCOL; -TOK_TABLECOMMENT; -TOK_TABLEPARTCOLS; -TOK_TABLEPARTCOLNAMES; -TOK_TABLEROWFORMAT; -TOK_TABLEROWFORMATFIELD; -TOK_TABLEROWFORMATCOLLITEMS; -TOK_TABLEROWFORMATMAPKEYS; -TOK_TABLEROWFORMATLINES; -TOK_TABLEROWFORMATNULL; -TOK_TABLEFILEFORMAT; -TOK_FILEFORMAT_GENERIC; -TOK_OFFLINE; -TOK_ENABLE; -TOK_DISABLE; -TOK_READONLY; -TOK_NO_DROP; -TOK_STORAGEHANDLER; -TOK_NOT_CLUSTERED; -TOK_NOT_SORTED; -TOK_TABCOLNAME; -TOK_TABLELOCATION; -TOK_PARTITIONLOCATION; -TOK_TABLEBUCKETSAMPLE; -TOK_TABLESPLITSAMPLE; -TOK_PERCENT; -TOK_LENGTH; -TOK_ROWCOUNT; -TOK_TMP_FILE; -TOK_TABSORTCOLNAMEASC; -TOK_TABSORTCOLNAMEDESC; -TOK_STRINGLITERALSEQUENCE; -TOK_CHARSETLITERAL; -TOK_CREATEFUNCTION; -TOK_DROPFUNCTION; -TOK_RELOADFUNCTIONS; -TOK_CREATEMACRO; -TOK_DROPMACRO; -TOK_TEMPORARY; -TOK_CREATEVIEW; -TOK_DROPVIEW; -TOK_ALTERVIEW; -TOK_ALTERVIEW_PROPERTIES; -TOK_ALTERVIEW_DROPPROPERTIES; -TOK_ALTERVIEW_ADDPARTS; -TOK_ALTERVIEW_DROPPARTS; -TOK_ALTERVIEW_RENAME; -TOK_CREATE_MATERIALIZED_VIEW; -TOK_DROP_MATERIALIZED_VIEW; -TOK_ALTER_MATERIALIZED_VIEW; -TOK_ALTER_MATERIALIZED_VIEW_REWRITE; -TOK_ALTER_MATERIALIZED_VIEW_REBUILD; -TOK_CREATE_SCHEDULED_QUERY; -TOK_ALTER_SCHEDULED_QUERY; -TOK_DROP_SCHEDULED_QUERY; -TOK_REWRITE_ENABLED; -TOK_REWRITE_DISABLED; -TOK_VIEWPARTCOLS; -TOK_VIEWCLUSTERCOLS; -TOK_VIEWDISTRIBUTECOLS; -TOK_VIEWSORTCOLS; -TOK_EXPLAIN; -TOK_EXPLAIN_SQ_REWRITE; -TOK_TABLESERIALIZER; -TOK_TABLEPROPERTIES; -TOK_TABLEPROPLIST; -TOK_TABTYPE; -TOK_LIMIT; -TOK_OFFSET; -TOK_TABLEPROPERTY; -TOK_IFEXISTS; -TOK_IFNOTEXISTS; -TOK_ORREPLACE; -TOK_USERSCRIPTCOLNAMES; -TOK_USERSCRIPTCOLSCHEMA; -TOK_RECORDREADER; -TOK_RECORDWRITER; -TOK_LEFTSEMIJOIN; -TOK_LATERAL_VIEW; -TOK_LATERAL_VIEW_OUTER; -TOK_TABALIAS; -TOK_ANALYZE; -TOK_CREATEROLE; -TOK_DROPROLE; -TOK_GRANT; -TOK_REVOKE; -TOK_SHOW_GRANT; -TOK_PRIVILEGE_LIST; -TOK_PRIVILEGE; -TOK_PRINCIPAL_NAME; -TOK_USER; -TOK_GROUP; -TOK_ROLE; -TOK_RESOURCE_ALL; -TOK_GRANT_WITH_OPTION; -TOK_GRANT_WITH_ADMIN_OPTION; -TOK_ADMIN_OPTION_FOR; -TOK_GRANT_OPTION_FOR; -TOK_PRIV_ALL; -TOK_PRIV_ALTER_METADATA; -TOK_PRIV_ALTER_DATA; -TOK_PRIV_DELETE; -TOK_PRIV_DROP; -TOK_PRIV_INSERT; -TOK_PRIV_LOCK; -TOK_PRIV_SELECT; -TOK_PRIV_SHOW_DATABASE; -TOK_PRIV_CREATE; -TOK_PRIV_OBJECT; -TOK_PRIV_OBJECT_COL; -TOK_GRANT_ROLE; -TOK_REVOKE_ROLE; -TOK_SET_ROLE; -TOK_SHOW_ROLE_GRANT; -TOK_SHOW_ROLES; -TOK_SHOW_CURRENT_ROLE; -TOK_SHOW_ROLE_PRINCIPALS; -TOK_SHOWDBLOCKS; -TOK_DESCDATABASE; -TOK_DATABASEPROPERTIES; -TOK_DATABASELOCATION; -TOK_DATABASE_MANAGEDLOCATION; -TOK_DBPROPLIST; -TOK_ALTERDATABASE_PROPERTIES; -TOK_ALTERDATABASE_OWNER; -TOK_ALTERDATABASE_LOCATION; -TOK_ALTERDATABASE_MANAGEDLOCATION; -TOK_DBNAME; -TOK_TABNAME; -TOK_TABSRC; -TOK_RESTRICT; -TOK_CASCADE; -TOK_FORCE; -TOK_TABLESKEWED; -TOK_TABCOLVALUE; -TOK_TABCOLVALUE_PAIR; -TOK_TABCOLVALUES; -TOK_SKEWED_LOCATIONS; -TOK_SKEWED_LOCATION_LIST; -TOK_SKEWED_LOCATION_MAP; -TOK_STOREDASDIRS; -TOK_PARTITIONINGSPEC; -TOK_PTBLFUNCTION; -TOK_WINDOWDEF; -TOK_WINDOWSPEC; -TOK_WINDOWVALUES; -TOK_WINDOWRANGE; -TOK_SUBQUERY_EXPR; -TOK_SUBQUERY_OP; -TOK_SUBQUERY_OP_NOTIN; -TOK_SUBQUERY_OP_NOTEXISTS; -TOK_DB_TYPE; -TOK_TABLE_TYPE; -TOK_CTE; -TOK_ARCHIVE; -TOK_FILE; -TOK_JAR; -TOK_RESOURCE_URI; -TOK_RESOURCE_LIST; -TOK_SHOW_COMPACTIONS; -TOK_SHOW_TRANSACTIONS; -TOK_DELETE_FROM; -TOK_UPDATE_TABLE; -TOK_SET_COLUMNS_CLAUSE; -TOK_COL_NAME; -TOK_URI_TYPE; -TOK_SERVER_TYPE; -TOK_SHOWVIEWS; -TOK_SHOWMATERIALIZEDVIEWS; -TOK_START_TRANSACTION; -TOK_ISOLATION_LEVEL; -TOK_ISOLATION_SNAPSHOT; -TOK_TXN_ACCESS_MODE; -TOK_TXN_READ_ONLY; -TOK_TXN_READ_WRITE; -TOK_COMMIT; -TOK_ROLLBACK; -TOK_SET_AUTOCOMMIT; -TOK_CACHE_METADATA; -TOK_ABORT_TRANSACTIONS; -TOK_MERGE; -TOK_MATCHED; -TOK_NOT_MATCHED; -TOK_UPDATE; -TOK_DELETE; -TOK_REPL_DUMP; -TOK_REPL_LOAD; -TOK_REPL_STATUS; -TOK_REPL_CONFIG; -TOK_REPL_CONFIG_LIST; -TOK_REPL_TABLES; -TOK_REPL_TABLES_LIST; -TOK_TO; -TOK_ONLY; -TOK_SUMMARY; -TOK_OPERATOR; -TOK_EXPRESSION; -TOK_DETAIL; -TOK_BLOCKING; -TOK_KILL_QUERY; -TOK_CREATE_RP; -TOK_SHOW_RP; -TOK_ALTER_RP_ENABLE; -TOK_ALTER_RP_DISABLE; -TOK_ALTER_RP_RENAME; -TOK_ALTER_RP_SET; -TOK_ALTER_RP_UNSET; -TOK_ALTER_RP_REPLACE; -TOK_ALTER_RP_VALIDATE; -TOK_DROP_RP; -TOK_ACTIVATE; -TOK_QUERY_PARALLELISM; -TOK_RENAME; -TOK_DEFAULT_POOL; -TOK_CREATE_TRIGGER; -TOK_ALTER_TRIGGER; -TOK_DROP_TRIGGER; -TOK_TRIGGER_EXPRESSION; -TOK_CREATE_POOL; -TOK_ALTER_POOL; -TOK_ALTER_POOL_ADD_TRIGGER; -TOK_ALTER_POOL_DROP_TRIGGER; -TOK_DROP_POOL; -TOK_ALLOC_FRACTION; -TOK_SCHEDULING_POLICY; -TOK_PATH; -TOK_CREATE_MAPPING; -TOK_ALTER_MAPPING; -TOK_DROP_MAPPING; -TOK_ADD_TRIGGER; -TOK_REPLACE; -TOK_LIKERP; -TOK_UNMANAGED; -TOK_INPUTFORMAT; -TOK_WITHIN_GROUP; -TOK_CRON; -TOK_EXECUTED_AS; -TOK_EXECUTE; -TOK_SCHEDULE; -TOK_EVERY; -} - - -// Package headers @header { package org.apache.hadoop.hive.ql.parse; - -import java.util.Arrays; -import java.util.Collection; -import java.util.HashMap; -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hive.conf.HiveConf; -} - - -@members { - ArrayList errors = new ArrayList(); - Stack msgs = new Stack(); - - private static HashMap xlateMap; - static { - //this is used to support auto completion in CLI - xlateMap = new HashMap(); - - // Keywords - xlateMap.put("KW_TRUE", "TRUE"); - xlateMap.put("KW_FALSE", "FALSE"); - xlateMap.put("KW_UNKNOWN", "UNKNOWN"); - xlateMap.put("KW_ALL", "ALL"); - xlateMap.put("KW_NONE", "NONE"); - xlateMap.put("KW_AND", "AND"); - xlateMap.put("KW_OR", "OR"); - xlateMap.put("KW_NOT", "NOT"); - xlateMap.put("KW_LIKE", "LIKE"); - - xlateMap.put("KW_ASC", "ASC"); - xlateMap.put("KW_DESC", "DESC"); - xlateMap.put("KW_NULLS", "NULLS"); - xlateMap.put("KW_LAST", "LAST"); - xlateMap.put("KW_ORDER", "ORDER"); - xlateMap.put("KW_BY", "BY"); - xlateMap.put("KW_GROUP", "GROUP"); - xlateMap.put("KW_WHERE", "WHERE"); - xlateMap.put("KW_FROM", "FROM"); - xlateMap.put("KW_AS", "AS"); - xlateMap.put("KW_SELECT", "SELECT"); - xlateMap.put("KW_DISTINCT", "DISTINCT"); - xlateMap.put("KW_INSERT", "INSERT"); - xlateMap.put("KW_OVERWRITE", "OVERWRITE"); - xlateMap.put("KW_OUTER", "OUTER"); - xlateMap.put("KW_JOIN", "JOIN"); - xlateMap.put("KW_LEFT", "LEFT"); - xlateMap.put("KW_RIGHT", "RIGHT"); - xlateMap.put("KW_FULL", "FULL"); - xlateMap.put("KW_ON", "ON"); - xlateMap.put("KW_PARTITION", "PARTITION"); - xlateMap.put("KW_PARTITIONS", "PARTITIONS"); - xlateMap.put("KW_TABLE", "TABLE"); - xlateMap.put("KW_TABLES", "TABLES"); - xlateMap.put("KW_TBLPROPERTIES", "TBLPROPERTIES"); - xlateMap.put("KW_SHOW", "SHOW"); - xlateMap.put("KW_MSCK", "MSCK"); - xlateMap.put("KW_DIRECTORY", "DIRECTORY"); - xlateMap.put("KW_LOCAL", "LOCAL"); - xlateMap.put("KW_TRANSFORM", "TRANSFORM"); - xlateMap.put("KW_USING", "USING"); - xlateMap.put("KW_CLUSTER", "CLUSTER"); - xlateMap.put("KW_DISTRIBUTE", "DISTRIBUTE"); - xlateMap.put("KW_SORT", "SORT"); - xlateMap.put("KW_SYNC", "SYNC"); - xlateMap.put("KW_UNION", "UNION"); - xlateMap.put("KW_INTERSECT", "INTERSECT"); - xlateMap.put("KW_EXCEPT", "EXCEPT"); - xlateMap.put("KW_LOAD", "LOAD"); - xlateMap.put("KW_DATA", "DATA"); - xlateMap.put("KW_INPATH", "INPATH"); - xlateMap.put("KW_IS", "IS"); - xlateMap.put("KW_NULL", "NULL"); - xlateMap.put("KW_CREATE", "CREATE"); - xlateMap.put("KW_EXTERNAL", "EXTERNAL"); - xlateMap.put("KW_ALTER", "ALTER"); - xlateMap.put("KW_DESCRIBE", "DESCRIBE"); - xlateMap.put("KW_DROP", "DROP"); - xlateMap.put("KW_RENAME", "RENAME"); - xlateMap.put("KW_TO", "TO"); - xlateMap.put("KW_COMMENT", "COMMENT"); - xlateMap.put("KW_BOOLEAN", "BOOLEAN"); - xlateMap.put("KW_TINYINT", "TINYINT"); - xlateMap.put("KW_SMALLINT", "SMALLINT"); - xlateMap.put("KW_INT", "INT"); - xlateMap.put("KW_BIGINT", "BIGINT"); - xlateMap.put("KW_FLOAT", "FLOAT"); - xlateMap.put("KW_REAL", "REAL"); - xlateMap.put("KW_DOUBLE", "DOUBLE"); - xlateMap.put("KW_PRECISION", "PRECISION"); - xlateMap.put("KW_DATE", "DATE"); - xlateMap.put("KW_DATETIME", "DATETIME"); - xlateMap.put("KW_TIMESTAMP", "TIMESTAMP"); - xlateMap.put("KW_TIMESTAMPLOCALTZ", "TIMESTAMPLOCALTZ"); - xlateMap.put("KW_TIME", "TIME"); - xlateMap.put("KW_ZONE", "ZONE"); - xlateMap.put("KW_STRING", "STRING"); - xlateMap.put("KW_BINARY", "BINARY"); - xlateMap.put("KW_ARRAY", "ARRAY"); - xlateMap.put("KW_MAP", "MAP"); - xlateMap.put("KW_REDUCE", "REDUCE"); - xlateMap.put("KW_PARTITIONED", "PARTITIONED"); - xlateMap.put("KW_CLUSTERED", "CLUSTERED"); - xlateMap.put("KW_SORTED", "SORTED"); - xlateMap.put("KW_INTO", "INTO"); - xlateMap.put("KW_BUCKETS", "BUCKETS"); - xlateMap.put("KW_ROW", "ROW"); - xlateMap.put("KW_FORMAT", "FORMAT"); - xlateMap.put("KW_DELIMITED", "DELIMITED"); - xlateMap.put("KW_FIELDS", "FIELDS"); - xlateMap.put("KW_TERMINATED", "TERMINATED"); - xlateMap.put("KW_COLLECTION", "COLLECTION"); - xlateMap.put("KW_ITEMS", "ITEMS"); - xlateMap.put("KW_KEYS", "KEYS"); - xlateMap.put("KW_KEY_TYPE", "\$KEY\$"); - xlateMap.put("KW_LINES", "LINES"); - xlateMap.put("KW_STORED", "STORED"); - xlateMap.put("KW_SEQUENCEFILE", "SEQUENCEFILE"); - xlateMap.put("KW_TEXTFILE", "TEXTFILE"); - xlateMap.put("KW_INPUTFORMAT", "INPUTFORMAT"); - xlateMap.put("KW_OUTPUTFORMAT", "OUTPUTFORMAT"); - xlateMap.put("KW_LOCATION", "LOCATION"); - xlateMap.put("KW_MANAGEDLOCATION", "MANAGEDLOCATION"); - xlateMap.put("KW_TABLESAMPLE", "TABLESAMPLE"); - xlateMap.put("KW_BUCKET", "BUCKET"); - xlateMap.put("KW_OUT", "OUT"); - xlateMap.put("KW_OF", "OF"); - xlateMap.put("KW_CAST", "CAST"); - xlateMap.put("KW_ADD", "ADD"); - xlateMap.put("KW_REPLACE", "REPLACE"); - xlateMap.put("KW_COLUMNS", "COLUMNS"); - xlateMap.put("KW_RLIKE", "RLIKE"); - xlateMap.put("KW_REGEXP", "REGEXP"); - xlateMap.put("KW_TEMPORARY", "TEMPORARY"); - xlateMap.put("KW_FUNCTION", "FUNCTION"); - xlateMap.put("KW_FUNCTIONS", "FUNCTIONS"); - xlateMap.put("KW_EXPLAIN", "EXPLAIN"); - xlateMap.put("KW_EXTENDED", "EXTENDED"); - xlateMap.put("KW_DEBUG", "DEBUG"); - xlateMap.put("KW_SERDE", "SERDE"); - xlateMap.put("KW_WITH", "WITH"); - xlateMap.put("KW_SERDEPROPERTIES", "SERDEPROPERTIES"); - xlateMap.put("KW_LIMIT", "LIMIT"); - xlateMap.put("KW_OFFSET", "OFFSET"); - xlateMap.put("KW_SET", "SET"); - xlateMap.put("KW_PROPERTIES", "TBLPROPERTIES"); - xlateMap.put("KW_VALUE_TYPE", "\$VALUE\$"); - xlateMap.put("KW_ELEM_TYPE", "\$ELEM\$"); - xlateMap.put("KW_DEFINED", "DEFINED"); - xlateMap.put("KW_SUBQUERY", "SUBQUERY"); - xlateMap.put("KW_REWRITE", "REWRITE"); - xlateMap.put("KW_UPDATE", "UPDATE"); - xlateMap.put("KW_VALUES", "VALUES"); - xlateMap.put("KW_PURGE", "PURGE"); - xlateMap.put("KW_UNIQUE", "UNIQUE"); - xlateMap.put("KW_PRIMARY", "PRIMARY"); - xlateMap.put("KW_FOREIGN", "FOREIGN"); - xlateMap.put("KW_KEY", "KEY"); - xlateMap.put("KW_REFERENCES", "REFERENCES"); - xlateMap.put("KW_CONSTRAINT", "CONSTRAINT"); - xlateMap.put("KW_ENABLE", "ENABLE"); - xlateMap.put("KW_DISABLE", "DISABLE"); - xlateMap.put("KW_VALIDATE", "VALIDATE"); - xlateMap.put("KW_NOVALIDATE", "NOVALIDATE"); - xlateMap.put("KW_RELY", "RELY"); - xlateMap.put("KW_NORELY", "NORELY"); - xlateMap.put("KW_ABORT", "ABORT"); - xlateMap.put("KW_TRANSACTIONS", "TRANSACTIONS"); - xlateMap.put("KW_COMPACTIONS", "COMPACTIONS"); - xlateMap.put("KW_COMPACT", "COMPACT"); - xlateMap.put("KW_WAIT", "WAIT"); - xlateMap.put("KW_KILL", "KILL"); - xlateMap.put("KW_QUERY", "QUERY"); - xlateMap.put("KW_RESOURCE", "RESOURCE"); - xlateMap.put("KW_PLAN", "PLAN"); - xlateMap.put("KW_QUERY_PARALLELISM", "QUERY_PARALLELISM"); - xlateMap.put("KW_PLANS", "PLANS"); - xlateMap.put("KW_ACTIVATE", "ACTIVATE"); - xlateMap.put("KW_DEFAULT", "DEFAULT"); - xlateMap.put("KW_CHECK", "CHECK"); - xlateMap.put("KW_POOL", "POOL"); - xlateMap.put("KW_MOVE", "MOVE"); - xlateMap.put("KW_DO", "DO"); - xlateMap.put("KW_ALLOC_FRACTION", "ALLOC_FRACTION"); - xlateMap.put("KW_SCHEDULING_POLICY", "SCHEDULING_POLICY"); - xlateMap.put("KW_PATH", "PATH"); - xlateMap.put("KW_AST", "AST"); - xlateMap.put("KW_TRANSACTIONAL", "TRANSACTIONAL"); - - // Operators - xlateMap.put("DOT", "."); - xlateMap.put("COLON", ":"); - xlateMap.put("COMMA", ","); - xlateMap.put("SEMICOLON", ");"); - - xlateMap.put("LPAREN", "("); - xlateMap.put("RPAREN", ")"); - xlateMap.put("LSQUARE", "["); - xlateMap.put("RSQUARE", "]"); - - xlateMap.put("EQUAL", "="); - xlateMap.put("NOTEQUAL", "<>"); - xlateMap.put("EQUAL_NS", "<=>"); - xlateMap.put("LESSTHANOREQUALTO", "<="); - xlateMap.put("LESSTHAN", "<"); - xlateMap.put("GREATERTHANOREQUALTO", ">="); - xlateMap.put("GREATERTHAN", ">"); - - xlateMap.put("DIVIDE", "/"); - xlateMap.put("PLUS", "+"); - xlateMap.put("MINUS", "-"); - xlateMap.put("STAR", "*"); - xlateMap.put("MOD", "\%"); - - xlateMap.put("AMPERSAND", "&"); - xlateMap.put("TILDE", "~"); - xlateMap.put("BITWISEOR", "|"); - xlateMap.put("BITWISEXOR", "^"); - xlateMap.put("CharSetLiteral", "\\'"); - } - - public static Collection getKeywords() { - return xlateMap.values(); - } - - private static String xlate(String name) { - - String ret = xlateMap.get(name); - if (ret == null) { - ret = name; - } - - return ret; - } - - @Override - public Object recoverFromMismatchedSet(IntStream input, - RecognitionException re, BitSet follow) throws RecognitionException { - throw re; - } - - @Override - public void displayRecognitionError(String[] tokenNames, - RecognitionException e) { - errors.add(new ParseError(this, e, tokenNames)); - } - - @Override - public String getErrorHeader(RecognitionException e) { - String header = null; - if (e.charPositionInLine < 0 && input.LT(-1) != null) { - Token t = input.LT(-1); - header = "line " + t.getLine() + ":" + t.getCharPositionInLine(); - } else { - header = super.getErrorHeader(e); - } - - return header; - } - - @Override - public String getErrorMessage(RecognitionException e, String[] tokenNames) { - String msg = null; - - // Translate the token names to something that the user can understand - String[] xlateNames = new String[tokenNames.length]; - for (int i = 0; i < tokenNames.length; ++i) { - xlateNames[i] = HiveParser.xlate(tokenNames[i]); - } - - if (e instanceof NoViableAltException) { - @SuppressWarnings("unused") - NoViableAltException nvae = (NoViableAltException) e; - // for development, can add - // "decision=<<"+nvae.grammarDecisionDescription+">>" - // and "(decision="+nvae.decisionNumber+") and - // "state "+nvae.stateNumber - msg = "cannot recognize input near" - + (input.LT(1) != null ? " " + getTokenErrorDisplay(input.LT(1)) : "") - + (input.LT(2) != null ? " " + getTokenErrorDisplay(input.LT(2)) : "") - + (input.LT(3) != null ? " " + getTokenErrorDisplay(input.LT(3)) : ""); - } else if (e instanceof MismatchedTokenException) { - MismatchedTokenException mte = (MismatchedTokenException) e; - msg = super.getErrorMessage(e, xlateNames) + (input.LT(-1) == null ? "":" near '" + input.LT(-1).getText()) + "'"; - } else if (e instanceof FailedPredicateException) { - FailedPredicateException fpe = (FailedPredicateException) e; - msg = "Failed to recognize predicate '" + fpe.token.getText() + "'. Failed rule: '" + fpe.ruleName + "'"; - } else { - msg = super.getErrorMessage(e, xlateNames); - } - - if (msgs.size() > 0) { - msg = msg + " in " + msgs.peek(); - } - return msg; - } - - public void pushMsg(String msg, RecognizerSharedState state) { - // ANTLR generated code does not wrap the @init code wit this backtracking check, - // even if the matching @after has it. If we have parser rules with that are doing - // some lookahead with syntactic predicates this can cause the push() and pop() calls - // to become unbalanced, so make sure both push/pop check the backtracking state. - if (state.backtracking == 0) { - msgs.push(msg); - } - } - - public void popMsg(RecognizerSharedState state) { - if (state.backtracking == 0) { - Object o = msgs.pop(); - } - } - - // counter to generate unique union aliases - private int aliasCounter; - private String generateUnionAlias() { - return "__u" + (++aliasCounter); - } - private char [] excludedCharForColumnName = {'.', ':'}; - private boolean containExcludedCharForCreateTableColumnName(String input) { - for(char c : excludedCharForColumnName) { - if(input.indexOf(c)>-1) { - return true; - } - } - return false; - } - private CommonTree throwSetOpException() throws RecognitionException { - throw new FailedPredicateException(input, "orderByClause clusterByClause distributeByClause sortByClause limitClause can only be applied to the whole union.", ""); - } - private CommonTree throwColumnNameException() throws RecognitionException { - throw new FailedPredicateException(input, Arrays.toString(excludedCharForColumnName) + " can not be used in column name in create table statement.", ""); - } - private Configuration hiveConf; - public void setHiveConf(Configuration hiveConf) { - this.hiveConf = hiveConf; - } - protected boolean nullsLast() { - if(hiveConf == null){ - return false; - } - return HiveConf.getBoolVar(hiveConf, HiveConf.ConfVars.HIVE_DEFAULT_NULLS_LAST); - } -} - -@rulecatch { -catch (RecognitionException e) { - reportError(e); - throw e; -} } // starting rule @@ -822,2411 +36,3 @@ statement : explainStatement EOF | execStatement EOF ; - -explainStatement -@init { pushMsg("explain statement", state); } -@after { popMsg(state); } - : KW_EXPLAIN ( - explainOption* execStatement -> ^(TOK_EXPLAIN execStatement explainOption*) - | - KW_REWRITE queryStatementExpression -> ^(TOK_EXPLAIN_SQ_REWRITE queryStatementExpression) - ) - ; - -explainOption -@init { msgs.push("explain option"); } -@after { msgs.pop(); } - : KW_EXTENDED - | KW_FORMATTED - | KW_DEPENDENCY - | KW_CBO (KW_COST | KW_JOINCOST)? - | KW_LOGICAL - | KW_AUTHORIZATION - | KW_ANALYZE - | KW_REOPTIMIZATION - | KW_LOCKS - | KW_AST - | (KW_VECTORIZATION vectorizationOnly? vectorizatonDetail?) - | KW_DEBUG - ; - -vectorizationOnly -@init { pushMsg("vectorization's only clause", state); } -@after { popMsg(state); } - : KW_ONLY - -> ^(TOK_ONLY) - ; - -vectorizatonDetail -@init { pushMsg("vectorization's detail level clause", state); } -@after { popMsg(state); } - : KW_SUMMARY - -> ^(TOK_SUMMARY) - | KW_OPERATOR - -> ^(TOK_OPERATOR) - | KW_EXPRESSION - -> ^(TOK_EXPRESSION) - | KW_DETAIL - -> ^(TOK_DETAIL) - ; - -execStatement -@init { pushMsg("statement", state); } -@after { popMsg(state); } - : queryStatementExpression - | loadStatement - | exportStatement - | importStatement - | replDumpStatement - | replLoadStatement - | replStatusStatement - | ddlStatement - | deleteStatement - | updateStatement - | sqlTransactionStatement - | mergeStatement - ; - -loadStatement -@init { pushMsg("load statement", state); } -@after { popMsg(state); } - : KW_LOAD KW_DATA (islocal=KW_LOCAL)? KW_INPATH (path=StringLiteral) (isoverwrite=KW_OVERWRITE)? KW_INTO KW_TABLE (tab=tableOrPartition) inputFileFormat? - -> ^(TOK_LOAD $path $tab $islocal? $isoverwrite? inputFileFormat?) - ; - -replicationClause -@init { pushMsg("replication clause", state); } -@after { popMsg(state); } - : KW_FOR (isMetadataOnly=KW_METADATA)? KW_REPLICATION LPAREN (replId=StringLiteral) RPAREN - -> ^(TOK_REPLICATION $replId $isMetadataOnly?) - ; - -exportStatement -@init { pushMsg("export statement", state); } -@after { popMsg(state); } - : KW_EXPORT - KW_TABLE (tab=tableOrPartition) - KW_TO (path=StringLiteral) - replicationClause? - -> ^(TOK_EXPORT $tab $path replicationClause?) - ; - -importStatement -@init { pushMsg("import statement", state); } -@after { popMsg(state); } - : KW_IMPORT - ((ext=KW_EXTERNAL)? KW_TABLE (tab=tableOrPartition))? - KW_FROM (path=StringLiteral) - tableLocation? - -> ^(TOK_IMPORT $path $tab? $ext? tableLocation?) - ; - -replDumpStatement -@init { pushMsg("Replication dump statement", state); } -@after { popMsg(state); } - : KW_REPL KW_DUMP - (dbPolicy=replDbPolicy) - (KW_REPLACE oldDbPolicy=replDbPolicy)? - (KW_WITH replConf=replConfigs)? - -> ^(TOK_REPL_DUMP $dbPolicy ^(TOK_REPLACE $oldDbPolicy)? $replConf?) - ; - -replDbPolicy -@init { pushMsg("Repl dump DB replication policy", state); } -@after { popMsg(state); } - : - (dbName=identifier) (DOT tablePolicy=replTableLevelPolicy)? -> $dbName $tablePolicy? - ; - -replLoadStatement -@init { pushMsg("Replication load statement", state); } -@after { popMsg(state); } - : KW_REPL KW_LOAD - (sourceDbPolicy=replDbPolicy) - (KW_INTO dbName=identifier)? - (KW_WITH replConf=replConfigs)? - -> ^(TOK_REPL_LOAD $sourceDbPolicy ^(TOK_DBNAME $dbName)? $replConf?) - ; - -replConfigs -@init { pushMsg("Repl configurations", state); } -@after { popMsg(state); } - : - LPAREN replConfigsList RPAREN -> ^(TOK_REPL_CONFIG replConfigsList) - ; - -replConfigsList -@init { pushMsg("Repl configurations list", state); } -@after { popMsg(state); } - : - keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_REPL_CONFIG_LIST keyValueProperty+) - ; - -replTableLevelPolicy -@init { pushMsg("Replication table level policy definition", state); } -@after { popMsg(state); } - : - ((replTablesIncludeList=StringLiteral) (DOT replTablesExcludeList=StringLiteral)?) - -> ^(TOK_REPL_TABLES $replTablesIncludeList $replTablesExcludeList?) - ; - -replStatusStatement -@init { pushMsg("replication status statement", state); } -@after { popMsg(state); } - : KW_REPL KW_STATUS - (dbName=identifier) - (KW_WITH replConf=replConfigs)? - -> ^(TOK_REPL_STATUS $dbName $replConf?) - ; - -ddlStatement -@init { pushMsg("ddl statement", state); } -@after { popMsg(state); } - : createDatabaseStatement - | switchDatabaseStatement - | dropDatabaseStatement - | createTableStatement - | dropTableStatement - | truncateTableStatement - | alterStatement - | descStatement - | showStatement - | metastoreCheck - | createViewStatement - | createMaterializedViewStatement - | createScheduledQueryStatement - | alterScheduledQueryStatement - | dropScheduledQueryStatement - | dropViewStatement - | dropMaterializedViewStatement - | createFunctionStatement - | createMacroStatement - | dropFunctionStatement - | reloadFunctionsStatement - | dropMacroStatement - | analyzeStatement - | lockStatement - | unlockStatement - | lockDatabase - | unlockDatabase - | createRoleStatement - | dropRoleStatement - | (grantPrivileges) => grantPrivileges - | (revokePrivileges) => revokePrivileges - | showGrants - | showRoleGrants - | showRolePrincipals - | showRoles - | grantRole - | revokeRole - | setRole - | showCurrentRole - | abortTransactionStatement - | killQueryStatement - | resourcePlanDdlStatements - ; - -ifExists -@init { pushMsg("if exists clause", state); } -@after { popMsg(state); } - : KW_IF KW_EXISTS - -> ^(TOK_IFEXISTS) - ; - -restrictOrCascade -@init { pushMsg("restrict or cascade clause", state); } -@after { popMsg(state); } - : KW_RESTRICT - -> ^(TOK_RESTRICT) - | KW_CASCADE - -> ^(TOK_CASCADE) - ; - -ifNotExists -@init { pushMsg("if not exists clause", state); } -@after { popMsg(state); } - : KW_IF KW_NOT KW_EXISTS - -> ^(TOK_IFNOTEXISTS) - ; - -force -@init { msgs.push("force clause"); } -@after { msgs.pop(); } - : KW_FORCE - -> ^(TOK_FORCE) - ; - -rewriteEnabled -@init { pushMsg("rewrite enabled clause", state); } -@after { popMsg(state); } - : KW_ENABLE KW_REWRITE - -> ^(TOK_REWRITE_ENABLED) - ; - -rewriteDisabled -@init { pushMsg("rewrite disabled clause", state); } -@after { popMsg(state); } - : KW_DISABLE KW_REWRITE - -> ^(TOK_REWRITE_DISABLED) - ; - -storedAsDirs -@init { pushMsg("stored as directories", state); } -@after { popMsg(state); } - : KW_STORED KW_AS KW_DIRECTORIES - -> ^(TOK_STOREDASDIRS) - ; - -orReplace -@init { pushMsg("or replace clause", state); } -@after { popMsg(state); } - : KW_OR KW_REPLACE - -> ^(TOK_ORREPLACE) - ; - -createDatabaseStatement -@init { pushMsg("create database statement", state); } -@after { popMsg(state); } - : KW_CREATE (KW_DATABASE|KW_SCHEMA) - ifNotExists? - name=identifier - databaseComment? - dbLocation? - dbManagedLocation? - (KW_WITH KW_DBPROPERTIES dbprops=dbProperties)? - -> ^(TOK_CREATEDATABASE $name ifNotExists? dbLocation? dbManagedLocation? databaseComment? $dbprops?) - ; - -dbLocation -@init { pushMsg("database location specification", state); } -@after { popMsg(state); } - : - KW_LOCATION locn=StringLiteral -> ^(TOK_DATABASELOCATION $locn) - ; - -dbManagedLocation -@init { pushMsg("database managed location specification", state); } -@after { popMsg(state); } - : - KW_MANAGEDLOCATION locn=StringLiteral -> ^(TOK_DATABASE_MANAGEDLOCATION $locn) - ; - -dbProperties -@init { pushMsg("dbproperties", state); } -@after { popMsg(state); } - : - LPAREN dbPropertiesList RPAREN -> ^(TOK_DATABASEPROPERTIES dbPropertiesList) - ; - -dbPropertiesList -@init { pushMsg("database properties list", state); } -@after { popMsg(state); } - : - keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_DBPROPLIST keyValueProperty+) - ; - - -switchDatabaseStatement -@init { pushMsg("switch database statement", state); } -@after { popMsg(state); } - : KW_USE identifier - -> ^(TOK_SWITCHDATABASE identifier) - ; - -dropDatabaseStatement -@init { pushMsg("drop database statement", state); } -@after { popMsg(state); } - : KW_DROP (KW_DATABASE|KW_SCHEMA) ifExists? identifier restrictOrCascade? - -> ^(TOK_DROPDATABASE identifier ifExists? restrictOrCascade?) - ; - -databaseComment -@init { pushMsg("database's comment", state); } -@after { popMsg(state); } - : KW_COMMENT comment=StringLiteral - -> ^(TOK_DATABASECOMMENT $comment) - ; - -createTableStatement -@init { pushMsg("create table statement", state); } -@after { popMsg(state); } - : KW_CREATE (temp=KW_TEMPORARY)? (trans=KW_TRANSACTIONAL)? (ext=KW_EXTERNAL)? KW_TABLE ifNotExists? name=tableName - ( like=KW_LIKE likeName=tableName - tableRowFormat? - tableFileFormat? - tableLocation? - tablePropertiesPrefixed? - | (LPAREN columnNameTypeOrConstraintList RPAREN)? - tableComment? - createTablePartitionSpec? - tableBuckets? - tableSkewed? - tableRowFormat? - tableFileFormat? - tableLocation? - tablePropertiesPrefixed? - (KW_AS selectStatementWithCTE)? - ) - -> ^(TOK_CREATETABLE $name $temp? $trans? $ext? ifNotExists? - ^(TOK_LIKETABLE $likeName?) - columnNameTypeOrConstraintList? - tableComment? - createTablePartitionSpec? - tableBuckets? - tableSkewed? - tableRowFormat? - tableFileFormat? - tableLocation? - tablePropertiesPrefixed? - selectStatementWithCTE? - ) - ; - -truncateTableStatement -@init { pushMsg("truncate table statement", state); } -@after { popMsg(state); } - : KW_TRUNCATE KW_TABLE? tablePartitionPrefix (KW_COLUMNS LPAREN columnNameList RPAREN)? force? - -> ^(TOK_TRUNCATETABLE tablePartitionPrefix columnNameList? force?); - -dropTableStatement -@init { pushMsg("drop statement", state); } -@after { popMsg(state); } - : KW_DROP KW_TABLE ifExists? tableName KW_PURGE? replicationClause? - -> ^(TOK_DROPTABLE tableName ifExists? KW_PURGE? replicationClause?) - ; - -alterStatement -@init { pushMsg("alter statement", state); } -@after { popMsg(state); } - : KW_ALTER KW_TABLE tableName alterTableStatementSuffix -> ^(TOK_ALTERTABLE tableName alterTableStatementSuffix) - | KW_ALTER KW_VIEW tableName KW_AS? alterViewStatementSuffix -> ^(TOK_ALTERVIEW tableName alterViewStatementSuffix) - | KW_ALTER KW_MATERIALIZED KW_VIEW tableNameTree=tableName alterMaterializedViewStatementSuffix[$tableNameTree.tree] -> alterMaterializedViewStatementSuffix - | KW_ALTER (KW_DATABASE|KW_SCHEMA) alterDatabaseStatementSuffix -> alterDatabaseStatementSuffix - ; - -alterTableStatementSuffix -@init { pushMsg("alter table statement", state); } -@after { popMsg(state); } - : (alterStatementSuffixRename[true]) => alterStatementSuffixRename[true] - | alterStatementSuffixDropPartitions[true] - | alterStatementSuffixAddPartitions[true] - | alterStatementSuffixTouch - | alterStatementSuffixArchive - | alterStatementSuffixUnArchive - | alterStatementSuffixProperties - | alterStatementSuffixSkewedby - | alterStatementSuffixExchangePartition - | alterStatementPartitionKeyType - | alterStatementSuffixDropConstraint - | alterStatementSuffixAddConstraint - | alterTblPartitionStatementSuffix[false] - | partitionSpec alterTblPartitionStatementSuffix[true] -> alterTblPartitionStatementSuffix partitionSpec - | alterStatementSuffixSetOwner - ; - -alterTblPartitionStatementSuffix[boolean partition] -@init {pushMsg("alter table partition statement suffix", state);} -@after {popMsg(state);} - : alterStatementSuffixFileFormat[partition] - | alterStatementSuffixLocation[partition] - | alterStatementSuffixMergeFiles[partition] - | alterStatementSuffixSerdeProperties[partition] - | alterStatementSuffixRenamePart - | alterStatementSuffixBucketNum[partition] - | alterTblPartitionStatementSuffixSkewedLocation - | alterStatementSuffixClusterbySortby - | alterStatementSuffixCompact - | alterStatementSuffixUpdateStatsCol[partition] - | alterStatementSuffixUpdateStats[partition] - | alterStatementSuffixRenameCol - | alterStatementSuffixAddCol - | alterStatementSuffixUpdateColumns - ; - -alterStatementPartitionKeyType -@init {msgs.push("alter partition key type"); } -@after {msgs.pop();} - : KW_PARTITION KW_COLUMN LPAREN columnNameType RPAREN - -> ^(TOK_ALTERTABLE_PARTCOLTYPE columnNameType) - ; - -alterViewStatementSuffix -@init { pushMsg("alter view statement", state); } -@after { popMsg(state); } - : alterViewSuffixProperties - | alterStatementSuffixRename[false] - | alterStatementSuffixAddPartitions[false] - | alterStatementSuffixDropPartitions[false] - | selectStatementWithCTE - ; - -alterMaterializedViewStatementSuffix[CommonTree tableNameTree] -@init { pushMsg("alter materialized view statement", state); } -@after { popMsg(state); } - : alterMaterializedViewSuffixRewrite[tableNameTree] - | alterMaterializedViewSuffixRebuild[tableNameTree] - ; - -alterMaterializedViewSuffixRewrite[CommonTree tableNameTree] -@init { pushMsg("alter materialized view rewrite statement", state); } -@after { popMsg(state); } - : (mvRewriteFlag=rewriteEnabled | mvRewriteFlag=rewriteDisabled) - -> ^(TOK_ALTER_MATERIALIZED_VIEW_REWRITE {$tableNameTree} $mvRewriteFlag) - ; - -alterMaterializedViewSuffixRebuild[CommonTree tableNameTree] -@init { pushMsg("alter materialized view rebuild statement", state); } -@after { popMsg(state); } - : KW_REBUILD -> ^(TOK_ALTER_MATERIALIZED_VIEW_REBUILD {$tableNameTree}) - ; - -alterDatabaseStatementSuffix -@init { pushMsg("alter database statement", state); } -@after { popMsg(state); } - : alterDatabaseSuffixProperties - | alterDatabaseSuffixSetOwner - | alterDatabaseSuffixSetLocation - ; - -alterDatabaseSuffixProperties -@init { pushMsg("alter database properties statement", state); } -@after { popMsg(state); } - : name=identifier KW_SET KW_DBPROPERTIES dbProperties - -> ^(TOK_ALTERDATABASE_PROPERTIES $name dbProperties) - ; - -alterDatabaseSuffixSetOwner -@init { pushMsg("alter database set owner", state); } -@after { popMsg(state); } - : dbName=identifier KW_SET KW_OWNER principalName - -> ^(TOK_ALTERDATABASE_OWNER $dbName principalName) - ; - -alterDatabaseSuffixSetLocation -@init { pushMsg("alter database set location", state); } -@after { popMsg(state); } - : dbName=identifier KW_SET KW_LOCATION newLocation=StringLiteral - -> ^(TOK_ALTERDATABASE_LOCATION $dbName $newLocation) - | dbName=identifier KW_SET KW_MANAGEDLOCATION newLocation=StringLiteral - -> ^(TOK_ALTERDATABASE_MANAGEDLOCATION $dbName $newLocation) - ; - -alterDatabaseSuffixSetManagedLocation -@init { pushMsg("alter database set managed location", state); } -@after { popMsg(state); } - : dbName=identifier KW_SET KW_MANAGEDLOCATION newLocation=StringLiteral - -> ^(TOK_ALTERDATABASE_MANAGEDLOCATION $dbName $newLocation) - ; - -alterStatementSuffixRename[boolean table] -@init { pushMsg("rename statement", state); } -@after { popMsg(state); } - : KW_RENAME KW_TO tableName - -> { table }? ^(TOK_ALTERTABLE_RENAME tableName) - -> ^(TOK_ALTERVIEW_RENAME tableName) - ; - -alterStatementSuffixAddCol -@init { pushMsg("add column statement", state); } -@after { popMsg(state); } - : (add=KW_ADD | replace=KW_REPLACE) KW_COLUMNS LPAREN columnNameTypeList RPAREN restrictOrCascade? - -> {$add != null}? ^(TOK_ALTERTABLE_ADDCOLS columnNameTypeList restrictOrCascade?) - -> ^(TOK_ALTERTABLE_REPLACECOLS columnNameTypeList restrictOrCascade?) - ; - -alterStatementSuffixAddConstraint -@init { pushMsg("add constraint statement", state); } -@after { popMsg(state); } - : KW_ADD (fk=alterForeignKeyWithName | alterConstraintWithName) - -> {fk != null}? ^(TOK_ALTERTABLE_ADDCONSTRAINT alterForeignKeyWithName) - -> ^(TOK_ALTERTABLE_ADDCONSTRAINT alterConstraintWithName) - ; - -alterStatementSuffixUpdateColumns -@init { pushMsg("update columns statement", state); } -@after { popMsg(state); } - : KW_UPDATE KW_COLUMNS restrictOrCascade? - -> ^(TOK_ALTERTABLE_UPDATECOLUMNS restrictOrCascade?) - ; - -alterStatementSuffixDropConstraint -@init { pushMsg("drop constraint statement", state); } -@after { popMsg(state); } - : KW_DROP KW_CONSTRAINT cName=identifier - ->^(TOK_ALTERTABLE_DROPCONSTRAINT $cName) - ; - -alterStatementSuffixRenameCol -@init { pushMsg("rename column name", state); } -@after { popMsg(state); } - : KW_CHANGE KW_COLUMN? oldName=identifier newName=identifier colType alterColumnConstraint[$newName.tree]? (KW_COMMENT comment=StringLiteral)? alterStatementChangeColPosition? restrictOrCascade? - ->^(TOK_ALTERTABLE_RENAMECOL $oldName $newName colType $comment? alterColumnConstraint? alterStatementChangeColPosition? restrictOrCascade?) - ; - -alterStatementSuffixUpdateStatsCol[boolean partition] -@init { pushMsg("update column statistics", state); } -@after { popMsg(state); } - : KW_UPDATE KW_STATISTICS KW_FOR KW_COLUMN? colName=identifier KW_SET tableProperties (KW_COMMENT comment=StringLiteral)? - -> {partition}? ^(TOK_ALTERPARTITION_UPDATECOLSTATS $colName tableProperties $comment?) - -> ^(TOK_ALTERTABLE_UPDATECOLSTATS $colName tableProperties $comment?) - ; - -alterStatementSuffixUpdateStats[boolean partition] -@init { pushMsg("update basic statistics", state); } -@after { popMsg(state); } - : KW_UPDATE KW_STATISTICS KW_SET tableProperties - -> {partition}? ^(TOK_ALTERPARTITION_UPDATESTATS tableProperties) - -> ^(TOK_ALTERTABLE_UPDATESTATS tableProperties) - ; - -alterStatementChangeColPosition - : first=KW_FIRST|KW_AFTER afterCol=identifier - ->{$first != null}? ^(TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION ) - -> ^(TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION $afterCol) - ; - -alterStatementSuffixAddPartitions[boolean table] -@init { pushMsg("add partition statement", state); } -@after { popMsg(state); } - : KW_ADD ifNotExists? alterStatementSuffixAddPartitionsElement+ - -> { table }? ^(TOK_ALTERTABLE_ADDPARTS ifNotExists? alterStatementSuffixAddPartitionsElement+) - -> ^(TOK_ALTERVIEW_ADDPARTS ifNotExists? alterStatementSuffixAddPartitionsElement+) - ; - -alterStatementSuffixAddPartitionsElement - : partitionSpec partitionLocation? - ; - -alterStatementSuffixTouch -@init { pushMsg("touch statement", state); } -@after { popMsg(state); } - : KW_TOUCH (partitionSpec)* - -> ^(TOK_ALTERTABLE_TOUCH (partitionSpec)*) - ; - -alterStatementSuffixArchive -@init { pushMsg("archive statement", state); } -@after { popMsg(state); } - : KW_ARCHIVE (partitionSpec)* - -> ^(TOK_ALTERTABLE_ARCHIVE (partitionSpec)*) - ; - -alterStatementSuffixUnArchive -@init { pushMsg("unarchive statement", state); } -@after { popMsg(state); } - : KW_UNARCHIVE (partitionSpec)* - -> ^(TOK_ALTERTABLE_UNARCHIVE (partitionSpec)*) - ; - -partitionLocation -@init { pushMsg("partition location", state); } -@after { popMsg(state); } - : - KW_LOCATION locn=StringLiteral -> ^(TOK_PARTITIONLOCATION $locn) - ; - -alterStatementSuffixDropPartitions[boolean table] -@init { pushMsg("drop partition statement", state); } -@after { popMsg(state); } - : KW_DROP ifExists? dropPartitionSpec (COMMA dropPartitionSpec)* KW_PURGE? replicationClause? - -> { table }? ^(TOK_ALTERTABLE_DROPPARTS dropPartitionSpec+ ifExists? KW_PURGE? replicationClause?) - -> ^(TOK_ALTERVIEW_DROPPARTS dropPartitionSpec+ ifExists? replicationClause?) - ; - -alterStatementSuffixProperties -@init { pushMsg("alter properties statement", state); } -@after { popMsg(state); } - : KW_SET KW_TBLPROPERTIES tableProperties - -> ^(TOK_ALTERTABLE_PROPERTIES tableProperties) - | KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties - -> ^(TOK_ALTERTABLE_DROPPROPERTIES tableProperties ifExists?) - ; - -alterViewSuffixProperties -@init { pushMsg("alter view properties statement", state); } -@after { popMsg(state); } - : KW_SET KW_TBLPROPERTIES tableProperties - -> ^(TOK_ALTERVIEW_PROPERTIES tableProperties) - | KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties - -> ^(TOK_ALTERVIEW_DROPPROPERTIES tableProperties ifExists?) - ; - -alterStatementSuffixSerdeProperties[boolean partition] -@init { pushMsg("alter serdes statement", state); } -@after { popMsg(state); } - : KW_SET KW_SERDE serdeName=StringLiteral (KW_WITH KW_SERDEPROPERTIES tableProperties)? - -> {partition}? ^(TOK_ALTERPARTITION_SERIALIZER $serdeName tableProperties?) - -> ^(TOK_ALTERTABLE_SERIALIZER $serdeName tableProperties?) - | KW_SET KW_SERDEPROPERTIES tableProperties - -> {partition}? ^(TOK_ALTERPARTITION_SERDEPROPERTIES tableProperties) - -> ^(TOK_ALTERTABLE_SERDEPROPERTIES tableProperties) - ; - -tablePartitionPrefix -@init {pushMsg("table partition prefix", state);} -@after {popMsg(state);} - : tableName partitionSpec? - ->^(TOK_TABLE_PARTITION tableName partitionSpec?) - ; - -alterStatementSuffixFileFormat[boolean partition] -@init {pushMsg("alter fileformat statement", state); } -@after {popMsg(state);} - : KW_SET KW_FILEFORMAT fileFormat - -> {partition}? ^(TOK_ALTERPARTITION_FILEFORMAT fileFormat) - -> ^(TOK_ALTERTABLE_FILEFORMAT fileFormat) - ; - -alterStatementSuffixClusterbySortby -@init {pushMsg("alter partition cluster by sort by statement", state);} -@after {popMsg(state);} - : KW_NOT KW_CLUSTERED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_CLUSTERED) - | KW_NOT KW_SORTED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_SORTED) - | tableBuckets -> ^(TOK_ALTERTABLE_CLUSTER_SORT tableBuckets) - ; - -alterTblPartitionStatementSuffixSkewedLocation -@init {pushMsg("alter partition skewed location", state);} -@after {popMsg(state);} - : KW_SET KW_SKEWED KW_LOCATION skewedLocations - -> ^(TOK_ALTERTABLE_SKEWED_LOCATION skewedLocations) - ; - -skewedLocations -@init { pushMsg("skewed locations", state); } -@after { popMsg(state); } - : - LPAREN skewedLocationsList RPAREN -> ^(TOK_SKEWED_LOCATIONS skewedLocationsList) - ; - -skewedLocationsList -@init { pushMsg("skewed locations list", state); } -@after { popMsg(state); } - : - skewedLocationMap (COMMA skewedLocationMap)* -> ^(TOK_SKEWED_LOCATION_LIST skewedLocationMap+) - ; - -skewedLocationMap -@init { pushMsg("specifying skewed location map", state); } -@after { popMsg(state); } - : - key=skewedValueLocationElement EQUAL value=StringLiteral -> ^(TOK_SKEWED_LOCATION_MAP $key $value) - ; - -alterStatementSuffixLocation[boolean partition] -@init {pushMsg("alter location", state);} -@after {popMsg(state);} - : KW_SET KW_LOCATION newLoc=StringLiteral - -> {partition}? ^(TOK_ALTERPARTITION_LOCATION $newLoc) - -> ^(TOK_ALTERTABLE_LOCATION $newLoc) - ; - - -alterStatementSuffixSkewedby -@init {pushMsg("alter skewed by statement", state);} -@after{popMsg(state);} - : tableSkewed - ->^(TOK_ALTERTABLE_SKEWED tableSkewed) - | - KW_NOT KW_SKEWED - ->^(TOK_ALTERTABLE_SKEWED) - | - KW_NOT storedAsDirs - ->^(TOK_ALTERTABLE_SKEWED storedAsDirs) - ; - -alterStatementSuffixExchangePartition -@init {pushMsg("alter exchange partition", state);} -@after{popMsg(state);} - : KW_EXCHANGE partitionSpec KW_WITH KW_TABLE exchangename=tableName - -> ^(TOK_ALTERTABLE_EXCHANGEPARTITION partitionSpec $exchangename) - ; - -alterStatementSuffixRenamePart -@init { pushMsg("alter table rename partition statement", state); } -@after { popMsg(state); } - : KW_RENAME KW_TO partitionSpec - ->^(TOK_ALTERTABLE_RENAMEPART partitionSpec) - ; - -alterStatementSuffixStatsPart -@init { pushMsg("alter table stats partition statement", state); } -@after { popMsg(state); } - : KW_UPDATE KW_STATISTICS KW_FOR KW_COLUMN? colName=identifier KW_SET tableProperties (KW_COMMENT comment=StringLiteral)? - ->^(TOK_ALTERTABLE_UPDATECOLSTATS $colName tableProperties $comment?) - ; - -alterStatementSuffixMergeFiles[boolean partition] -@init { pushMsg("", state); } -@after { popMsg(state); } - : KW_CONCATENATE - -> {partition}? ^(TOK_ALTERPARTITION_MERGEFILES) - -> ^(TOK_ALTERTABLE_MERGEFILES) - ; - -alterStatementSuffixBucketNum[boolean partition] -@init { pushMsg("", state); } -@after { popMsg(state); } - : KW_INTO num=Number KW_BUCKETS - -> {partition}? ^(TOK_ALTERPARTITION_BUCKETS $num) - -> ^(TOK_ALTERTABLE_BUCKETS $num) - ; - -blocking - : KW_AND KW_WAIT - -> TOK_BLOCKING - ; - -alterStatementSuffixCompact -@init { msgs.push("compaction request"); } -@after { msgs.pop(); } - : KW_COMPACT compactType=StringLiteral blocking? (KW_WITH KW_OVERWRITE KW_TBLPROPERTIES tableProperties)? - -> ^(TOK_ALTERTABLE_COMPACT $compactType blocking? tableProperties?) - ; - -alterStatementSuffixSetOwner -@init { pushMsg("alter table set owner", state); } -@after { popMsg(state); } - : KW_SET KW_OWNER principalName - -> ^(TOK_ALTERTABLE_OWNER principalName) - ; - -fileFormat -@init { pushMsg("file format specification", state); } -@after { popMsg(state); } - : KW_INPUTFORMAT inFmt=StringLiteral KW_OUTPUTFORMAT outFmt=StringLiteral KW_SERDE serdeCls=StringLiteral (KW_INPUTDRIVER inDriver=StringLiteral KW_OUTPUTDRIVER outDriver=StringLiteral)? - -> ^(TOK_TABLEFILEFORMAT $inFmt $outFmt $serdeCls $inDriver? $outDriver?) - | genericSpec=identifier -> ^(TOK_FILEFORMAT_GENERIC $genericSpec) - ; - -inputFileFormat -@init { pushMsg("Load Data input file format specification", state); } -@after { popMsg(state); } - : KW_INPUTFORMAT inFmt=StringLiteral KW_SERDE serdeCls=StringLiteral - -> ^(TOK_INPUTFORMAT $inFmt $serdeCls) - ; - -tabTypeExpr -@init { pushMsg("specifying table types", state); } -@after { popMsg(state); } - : identifier (DOT^ identifier)? - (identifier (DOT^ - ( - (KW_ELEM_TYPE) => KW_ELEM_TYPE - | - (KW_KEY_TYPE) => KW_KEY_TYPE - | - (KW_VALUE_TYPE) => KW_VALUE_TYPE - | identifier - ))* - )? - ; - -partTypeExpr -@init { pushMsg("specifying table partitions", state); } -@after { popMsg(state); } - : tabTypeExpr partitionSpec? -> ^(TOK_TABTYPE tabTypeExpr partitionSpec?) - ; - -tabPartColTypeExpr -@init { pushMsg("specifying table partitions columnName", state); } -@after { popMsg(state); } - : tableName partitionSpec? extColumnName? -> ^(TOK_TABTYPE tableName partitionSpec? extColumnName?) - ; - -descStatement -@init { pushMsg("describe statement", state); } -@after { popMsg(state); } - : - (KW_DESCRIBE|KW_DESC) - ( - (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) KW_EXTENDED? (dbName=identifier) -> ^(TOK_DESCDATABASE $dbName KW_EXTENDED?) - | - (KW_FUNCTION) => KW_FUNCTION KW_EXTENDED? (name=descFuncNames) -> ^(TOK_DESCFUNCTION $name KW_EXTENDED?) - | - (KW_FORMATTED|KW_EXTENDED) => ((descOptions=KW_FORMATTED|descOptions=KW_EXTENDED) parttype=tabPartColTypeExpr) -> ^(TOK_DESCTABLE $parttype $descOptions) - | - parttype=tabPartColTypeExpr -> ^(TOK_DESCTABLE $parttype) - ) - ; - -analyzeStatement -@init { pushMsg("analyze statement", state); } -@after { popMsg(state); } - : KW_ANALYZE KW_TABLE (parttype=tableOrPartition) - ( - (KW_COMPUTE) => KW_COMPUTE KW_STATISTICS ((noscan=KW_NOSCAN) - | (KW_FOR KW_COLUMNS (statsColumnName=columnNameList)?))? - -> ^(TOK_ANALYZE $parttype $noscan? KW_COLUMNS? $statsColumnName?) - | - (KW_CACHE) => KW_CACHE KW_METADATA -> ^(TOK_CACHE_METADATA $parttype) - ) - ; - -showStatement -@init { pushMsg("show statement", state); } -@after { popMsg(state); } - : KW_SHOW (KW_DATABASES|KW_SCHEMAS) (KW_LIKE showStmtIdentifier)? -> ^(TOK_SHOWDATABASES showStmtIdentifier?) - | KW_SHOW (isExtended=KW_EXTENDED)? KW_TABLES ((KW_FROM|KW_IN) db_name=identifier)? (filter=showTablesFilterExpr)? - -> ^(TOK_SHOWTABLES (TOK_FROM $db_name)? $filter? $isExtended?) - | KW_SHOW KW_VIEWS ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? -> ^(TOK_SHOWVIEWS (TOK_FROM $db_name)? showStmtIdentifier?) - | KW_SHOW KW_MATERIALIZED KW_VIEWS ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? -> ^(TOK_SHOWMATERIALIZEDVIEWS (TOK_FROM $db_name)? showStmtIdentifier?) - | KW_SHOW KW_COLUMNS (KW_FROM|KW_IN) tableName ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? - -> ^(TOK_SHOWCOLUMNS tableName (TOK_FROM $db_name)? showStmtIdentifier?) - | KW_SHOW KW_FUNCTIONS (KW_LIKE showFunctionIdentifier)? -> ^(TOK_SHOWFUNCTIONS KW_LIKE? showFunctionIdentifier?) - | KW_SHOW KW_PARTITIONS tabName=tableName partitionSpec? -> ^(TOK_SHOWPARTITIONS $tabName partitionSpec?) - | KW_SHOW KW_CREATE ( - (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) db_name=identifier -> ^(TOK_SHOW_CREATEDATABASE $db_name) - | - KW_TABLE tabName=tableName -> ^(TOK_SHOW_CREATETABLE $tabName) - ) - | KW_SHOW KW_TABLE KW_EXTENDED ((KW_FROM|KW_IN) db_name=identifier)? KW_LIKE showStmtIdentifier partitionSpec? - -> ^(TOK_SHOW_TABLESTATUS showStmtIdentifier $db_name? partitionSpec?) - | KW_SHOW KW_TBLPROPERTIES tableName (LPAREN prptyName=StringLiteral RPAREN)? -> ^(TOK_SHOW_TBLPROPERTIES tableName $prptyName?) - | KW_SHOW KW_LOCKS - ( - (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) (dbName=identifier) (isExtended=KW_EXTENDED)? -> ^(TOK_SHOWDBLOCKS $dbName $isExtended?) - | - (parttype=partTypeExpr)? (isExtended=KW_EXTENDED)? -> ^(TOK_SHOWLOCKS $parttype? $isExtended?) - ) - | KW_SHOW KW_COMPACTIONS -> ^(TOK_SHOW_COMPACTIONS) - | KW_SHOW KW_TRANSACTIONS -> ^(TOK_SHOW_TRANSACTIONS) - | KW_SHOW KW_CONF StringLiteral -> ^(TOK_SHOWCONF StringLiteral) - | KW_SHOW KW_RESOURCE - ( - (KW_PLAN rp_name=identifier -> ^(TOK_SHOW_RP $rp_name)) - | (KW_PLANS -> ^(TOK_SHOW_RP)) - ) - ; - -showTablesFilterExpr -@init { pushMsg("show tables filter expr", state); } -@after { popMsg(state); } - : KW_WHERE identifier EQUAL StringLiteral - -> ^(TOK_TABLE_TYPE identifier StringLiteral) - | KW_LIKE showStmtIdentifier|showStmtIdentifier - -> showStmtIdentifier - ; - -lockStatement -@init { pushMsg("lock statement", state); } -@after { popMsg(state); } - : KW_LOCK KW_TABLE tableName partitionSpec? lockMode -> ^(TOK_LOCKTABLE tableName lockMode partitionSpec?) - ; - -lockDatabase -@init { pushMsg("lock database statement", state); } -@after { popMsg(state); } - : KW_LOCK (KW_DATABASE|KW_SCHEMA) (dbName=identifier) lockMode -> ^(TOK_LOCKDB $dbName lockMode) - ; - -lockMode -@init { pushMsg("lock mode", state); } -@after { popMsg(state); } - : KW_SHARED | KW_EXCLUSIVE - ; - -unlockStatement -@init { pushMsg("unlock statement", state); } -@after { popMsg(state); } - : KW_UNLOCK KW_TABLE tableName partitionSpec? -> ^(TOK_UNLOCKTABLE tableName partitionSpec?) - ; - -unlockDatabase -@init { pushMsg("unlock database statement", state); } -@after { popMsg(state); } - : KW_UNLOCK (KW_DATABASE|KW_SCHEMA) (dbName=identifier) -> ^(TOK_UNLOCKDB $dbName) - ; - -createRoleStatement -@init { pushMsg("create role", state); } -@after { popMsg(state); } - : KW_CREATE KW_ROLE roleName=identifier - -> ^(TOK_CREATEROLE $roleName) - ; - -dropRoleStatement -@init {pushMsg("drop role", state);} -@after {popMsg(state);} - : KW_DROP KW_ROLE roleName=identifier - -> ^(TOK_DROPROLE $roleName) - ; - -grantPrivileges -@init {pushMsg("grant privileges", state);} -@after {popMsg(state);} - : KW_GRANT privList=privilegeList - privilegeObject? - KW_TO principalSpecification - withGrantOption? - -> ^(TOK_GRANT $privList principalSpecification privilegeObject? withGrantOption?) - ; - -revokePrivileges -@init {pushMsg("revoke privileges", state);} -@afer {popMsg(state);} - : KW_REVOKE grantOptionFor? privilegeList privilegeObject? KW_FROM principalSpecification - -> ^(TOK_REVOKE privilegeList principalSpecification privilegeObject? grantOptionFor?) - ; - -grantRole -@init {pushMsg("grant role", state);} -@after {popMsg(state);} - : KW_GRANT KW_ROLE? identifier (COMMA identifier)* KW_TO principalSpecification withAdminOption? - -> ^(TOK_GRANT_ROLE principalSpecification withAdminOption? identifier+) - ; - -revokeRole -@init {pushMsg("revoke role", state);} -@after {popMsg(state);} - : KW_REVOKE adminOptionFor? KW_ROLE? identifier (COMMA identifier)* KW_FROM principalSpecification - -> ^(TOK_REVOKE_ROLE principalSpecification adminOptionFor? identifier+) - ; - -showRoleGrants -@init {pushMsg("show role grants", state);} -@after {popMsg(state);} - : KW_SHOW KW_ROLE KW_GRANT principalName - -> ^(TOK_SHOW_ROLE_GRANT principalName) - ; - - -showRoles -@init {pushMsg("show roles", state);} -@after {popMsg(state);} - : KW_SHOW KW_ROLES - -> ^(TOK_SHOW_ROLES) - ; - -showCurrentRole -@init {pushMsg("show current role", state);} -@after {popMsg(state);} - : KW_SHOW KW_CURRENT KW_ROLES - -> ^(TOK_SHOW_CURRENT_ROLE) - ; - -setRole -@init {pushMsg("set role", state);} -@after {popMsg(state);} - : KW_SET KW_ROLE - ( - (KW_ALL) => (all=KW_ALL) -> ^(TOK_SET_ROLE Identifier[$all.text]) - | - (KW_NONE) => (none=KW_NONE) -> ^(TOK_SET_ROLE Identifier[$none.text]) - | - identifier -> ^(TOK_SET_ROLE identifier) - ) - ; - -showGrants -@init {pushMsg("show grants", state);} -@after {popMsg(state);} - : KW_SHOW KW_GRANT principalName? (KW_ON privilegeIncludeColObject)? - -> ^(TOK_SHOW_GRANT principalName? privilegeIncludeColObject?) - ; - -showRolePrincipals -@init {pushMsg("show role principals", state);} -@after {popMsg(state);} - : KW_SHOW KW_PRINCIPALS roleName=identifier - -> ^(TOK_SHOW_ROLE_PRINCIPALS $roleName) - ; - - -privilegeIncludeColObject -@init {pushMsg("privilege object including columns", state);} -@after {popMsg(state);} - : (KW_ALL) => KW_ALL -> ^(TOK_RESOURCE_ALL) - | privObjectCols -> ^(TOK_PRIV_OBJECT_COL privObjectCols) - ; - -privilegeObject -@init {pushMsg("privilege object", state);} -@after {popMsg(state);} - : KW_ON privObject -> ^(TOK_PRIV_OBJECT privObject) - ; - -// database or table type. Type is optional, default type is table -privObject - : (KW_DATABASE|KW_SCHEMA) identifier -> ^(TOK_DB_TYPE identifier) - | KW_TABLE? tableName partitionSpec? -> ^(TOK_TABLE_TYPE tableName partitionSpec?) - | KW_URI (path=StringLiteral) -> ^(TOK_URI_TYPE $path) - | KW_SERVER identifier -> ^(TOK_SERVER_TYPE identifier) - ; - -privObjectCols - : (KW_DATABASE|KW_SCHEMA) identifier -> ^(TOK_DB_TYPE identifier) - | KW_TABLE? tableName (LPAREN cols=columnNameList RPAREN)? partitionSpec? -> ^(TOK_TABLE_TYPE tableName $cols? partitionSpec?) - | KW_URI (path=StringLiteral) -> ^(TOK_URI_TYPE $path) - | KW_SERVER identifier -> ^(TOK_SERVER_TYPE identifier) - ; - -privilegeList -@init {pushMsg("grant privilege list", state);} -@after {popMsg(state);} - : privlegeDef (COMMA privlegeDef)* - -> ^(TOK_PRIVILEGE_LIST privlegeDef+) - ; - -privlegeDef -@init {pushMsg("grant privilege", state);} -@after {popMsg(state);} - : privilegeType (LPAREN cols=columnNameList RPAREN)? - -> ^(TOK_PRIVILEGE privilegeType $cols?) - ; - -privilegeType -@init {pushMsg("privilege type", state);} -@after {popMsg(state);} - : KW_ALL -> ^(TOK_PRIV_ALL) - | KW_ALTER -> ^(TOK_PRIV_ALTER_METADATA) - | KW_UPDATE -> ^(TOK_PRIV_ALTER_DATA) - | KW_CREATE -> ^(TOK_PRIV_CREATE) - | KW_DROP -> ^(TOK_PRIV_DROP) - | KW_LOCK -> ^(TOK_PRIV_LOCK) - | KW_SELECT -> ^(TOK_PRIV_SELECT) - | KW_SHOW_DATABASE -> ^(TOK_PRIV_SHOW_DATABASE) - | KW_INSERT -> ^(TOK_PRIV_INSERT) - | KW_DELETE -> ^(TOK_PRIV_DELETE) - ; - -principalSpecification -@init { pushMsg("user/group/role name list", state); } -@after { popMsg(state); } - : principalName (COMMA principalName)* -> ^(TOK_PRINCIPAL_NAME principalName+) - ; - -principalName -@init {pushMsg("user|group|role name", state);} -@after {popMsg(state);} - : KW_USER principalIdentifier -> ^(TOK_USER principalIdentifier) - | KW_GROUP principalIdentifier -> ^(TOK_GROUP principalIdentifier) - | KW_ROLE identifier -> ^(TOK_ROLE identifier) - ; - -withGrantOption -@init {pushMsg("with grant option", state);} -@after {popMsg(state);} - : KW_WITH KW_GRANT KW_OPTION - -> ^(TOK_GRANT_WITH_OPTION) - ; - -grantOptionFor -@init {pushMsg("grant option for", state);} -@after {popMsg(state);} - : KW_GRANT KW_OPTION KW_FOR - -> ^(TOK_GRANT_OPTION_FOR) -; - -adminOptionFor -@init {pushMsg("admin option for", state);} -@after {popMsg(state);} - : KW_ADMIN KW_OPTION KW_FOR - -> ^(TOK_ADMIN_OPTION_FOR) -; - -withAdminOption -@init {pushMsg("with admin option", state);} -@after {popMsg(state);} - : KW_WITH KW_ADMIN KW_OPTION - -> ^(TOK_GRANT_WITH_ADMIN_OPTION) - ; - -metastoreCheck -@init { pushMsg("metastore check statement", state); } -@after { popMsg(state); } - : KW_MSCK (repair=KW_REPAIR)? - (KW_TABLE tableName - ((add=KW_ADD | drop=KW_DROP | sync=KW_SYNC) (parts=KW_PARTITIONS))? | - (partitionSpec)?) - -> ^(TOK_MSCK $repair? tableName? $add? $drop? $sync? (partitionSpec*)?) - ; - -resourceList -@init { pushMsg("resource list", state); } -@after { popMsg(state); } - : - resource (COMMA resource)* -> ^(TOK_RESOURCE_LIST resource+) - ; - -resource -@init { pushMsg("resource", state); } -@after { popMsg(state); } - : - resType=resourceType resPath=StringLiteral -> ^(TOK_RESOURCE_URI $resType $resPath) - ; - -resourceType -@init { pushMsg("resource type", state); } -@after { popMsg(state); } - : - KW_JAR -> ^(TOK_JAR) - | - KW_FILE -> ^(TOK_FILE) - | - KW_ARCHIVE -> ^(TOK_ARCHIVE) - ; - -createFunctionStatement -@init { pushMsg("create function statement", state); } -@after { popMsg(state); } - : KW_CREATE (temp=KW_TEMPORARY)? KW_FUNCTION functionIdentifier KW_AS StringLiteral - (KW_USING rList=resourceList)? - -> {$temp != null}? ^(TOK_CREATEFUNCTION functionIdentifier StringLiteral $rList? TOK_TEMPORARY) - -> ^(TOK_CREATEFUNCTION functionIdentifier StringLiteral $rList?) - ; - -dropFunctionStatement -@init { pushMsg("drop function statement", state); } -@after { popMsg(state); } - : KW_DROP (temp=KW_TEMPORARY)? KW_FUNCTION ifExists? functionIdentifier - -> {$temp != null}? ^(TOK_DROPFUNCTION functionIdentifier ifExists? TOK_TEMPORARY) - -> ^(TOK_DROPFUNCTION functionIdentifier ifExists?) - ; - -reloadFunctionsStatement -@init { pushMsg("reload functions statement", state); } -@after { popMsg(state); } - : KW_RELOAD (KW_FUNCTIONS|KW_FUNCTION) -> ^(TOK_RELOADFUNCTIONS); - -createMacroStatement -@init { pushMsg("create macro statement", state); } -@after { popMsg(state); } - : KW_CREATE KW_TEMPORARY KW_MACRO Identifier - LPAREN columnNameTypeList? RPAREN expression - -> ^(TOK_CREATEMACRO Identifier columnNameTypeList? expression) - ; - -dropMacroStatement -@init { pushMsg("drop macro statement", state); } -@after { popMsg(state); } - : KW_DROP KW_TEMPORARY KW_MACRO ifExists? Identifier - -> ^(TOK_DROPMACRO Identifier ifExists?) - ; - -createViewStatement -@init { - pushMsg("create view statement", state); -} -@after { popMsg(state); } - : KW_CREATE (orReplace)? KW_VIEW (ifNotExists)? name=tableName - (LPAREN columnNameCommentList RPAREN)? tableComment? viewPartition? - tablePropertiesPrefixed? - KW_AS - selectStatementWithCTE - -> ^(TOK_CREATEVIEW $name orReplace? - ifNotExists? - columnNameCommentList? - tableComment? - viewPartition? - tablePropertiesPrefixed? - selectStatementWithCTE - ) - ; - -viewPartition -@init { pushMsg("view partition specification", state); } -@after { popMsg(state); } - : KW_PARTITIONED KW_ON LPAREN columnNameList RPAREN - -> ^(TOK_VIEWPARTCOLS columnNameList) - ; - -viewOrganization -@init { pushMsg("view organization specification", state); } -@after { popMsg(state); } - : viewClusterSpec - | viewComplexSpec - ; - -viewClusterSpec -@init { pushMsg("view cluster specification", state); } -@after { popMsg(state); } - : KW_CLUSTERED KW_ON LPAREN columnNameList RPAREN - -> ^(TOK_VIEWCLUSTERCOLS columnNameList) - ; - -viewComplexSpec -@init { pushMsg("view complex specification", state); } -@after { popMsg(state); } - : viewDistSpec viewSortSpec - ; - -viewDistSpec -@init { pushMsg("view distribute specification", state); } -@after { popMsg(state); } - : KW_DISTRIBUTED KW_ON LPAREN colList=columnNameList RPAREN - -> ^(TOK_VIEWDISTRIBUTECOLS $colList) - ; - -viewSortSpec -@init { pushMsg("view sort specification", state); } -@after { popMsg(state); } - : KW_SORTED KW_ON LPAREN colList=columnNameList RPAREN - -> ^(TOK_VIEWSORTCOLS $colList) - ; - -dropViewStatement -@init { pushMsg("drop view statement", state); } -@after { popMsg(state); } - : KW_DROP KW_VIEW ifExists? viewName -> ^(TOK_DROPVIEW viewName ifExists?) - ; - -createMaterializedViewStatement -@init { - pushMsg("create materialized view statement", state); -} -@after { popMsg(state); } - : KW_CREATE KW_MATERIALIZED KW_VIEW (ifNotExists)? name=tableName - rewriteDisabled? tableComment? viewPartition? viewOrganization? - tableRowFormat? tableFileFormat? tableLocation? - tablePropertiesPrefixed? KW_AS selectStatementWithCTE - -> ^(TOK_CREATE_MATERIALIZED_VIEW $name - ifNotExists? - rewriteDisabled? - tableComment? - tableRowFormat? - tableFileFormat? - tableLocation? - viewPartition? - viewOrganization? - tablePropertiesPrefixed? - selectStatementWithCTE - ) - ; - -dropMaterializedViewStatement -@init { pushMsg("drop materialized view statement", state); } -@after { popMsg(state); } - : KW_DROP KW_MATERIALIZED KW_VIEW ifExists? viewName -> ^(TOK_DROP_MATERIALIZED_VIEW viewName ifExists?) - ; - -createScheduledQueryStatement -@init { pushMsg("create scheduled query statement", state); } -@after { popMsg(state); } - : KW_CREATE KW_SCHEDULED KW_QUERY name=identifier - scheduleSpec - executedAsSpec? - enableSpecification? - definedAsSpec - -> ^(TOK_CREATE_SCHEDULED_QUERY - $name - scheduleSpec - executedAsSpec? - enableSpecification? - definedAsSpec - ) - ; - -dropScheduledQueryStatement -@init { pushMsg("drop scheduled query statement", state); } -@after { popMsg(state); } - : KW_DROP KW_SCHEDULED KW_QUERY name=identifier - -> ^(TOK_DROP_SCHEDULED_QUERY - $name - ) - ; - - -alterScheduledQueryStatement -@init { pushMsg("alter scheduled query statement", state); } -@after { popMsg(state); } - : KW_ALTER KW_SCHEDULED KW_QUERY name=identifier - mod=alterScheduledQueryChange - -> ^(TOK_ALTER_SCHEDULED_QUERY - $name - $mod - ) - ; - -alterScheduledQueryChange -@init { pushMsg("alter scheduled query change", state); } -@after { popMsg(state); } - : scheduleSpec - | executedAsSpec - | enableSpecification - | definedAsSpec - | KW_EXECUTE -> ^(TOK_EXECUTE) - ; - -scheduleSpec -@init { pushMsg("schedule specification", state); } -@after { popMsg(state); } - : KW_CRON cronString=StringLiteral -> ^(TOK_CRON $cronString) - | KW_EVERY value=Number? qualifier=intervalQualifiers - ((KW_AT|KW_OFFSET KW_BY) offsetTs=StringLiteral)? -> ^(TOK_SCHEDULE ^(TOK_EVERY $value?) $qualifier $offsetTs?) - ; - -executedAsSpec -@init { pushMsg("executedAs specification", state); } -@after { popMsg(state); } - : KW_EXECUTED KW_AS executedAs=StringLiteral -> ^(TOK_EXECUTED_AS $executedAs) - ; - -definedAsSpec -@init { pushMsg("definedAs specification", state); } -@after { popMsg(state); } - : KW_DEFINED? KW_AS statement -> ^(TOK_QUERY statement) - ; - -showFunctionIdentifier -@init { pushMsg("identifier for show function statement", state); } -@after { popMsg(state); } - : functionIdentifier - | StringLiteral - ; - -showStmtIdentifier -@init { pushMsg("identifier for show statement", state); } -@after { popMsg(state); } - : identifier - | StringLiteral - ; - -tableComment -@init { pushMsg("table's comment", state); } -@after { popMsg(state); } - : - KW_COMMENT comment=StringLiteral -> ^(TOK_TABLECOMMENT $comment) - ; - -createTablePartitionSpec -@init { pushMsg("create table partition specification", state); } -@after { popMsg(state); } - : KW_PARTITIONED KW_BY LPAREN (opt1 = createTablePartitionColumnTypeSpec | opt2 = createTablePartitionColumnSpec) RPAREN - -> {$opt1.tree != null}? $opt1 - -> $opt2 - ; - -createTablePartitionColumnTypeSpec -@init { pushMsg("create table partition specification", state); } -@after { popMsg(state); } - : columnNameTypeConstraint (COMMA columnNameTypeConstraint)* - -> ^(TOK_TABLEPARTCOLS columnNameTypeConstraint+) - ; - -createTablePartitionColumnSpec -@init { pushMsg("create table partition specification", state); } -@after { popMsg(state); } - : columnName (COMMA columnName)* - -> ^(TOK_TABLEPARTCOLNAMES columnName+) - ; - -tableBuckets -@init { pushMsg("table buckets specification", state); } -@after { popMsg(state); } - : - KW_CLUSTERED KW_BY LPAREN bucketCols=columnNameList RPAREN (KW_SORTED KW_BY LPAREN sortCols=columnNameOrderList RPAREN)? KW_INTO num=Number KW_BUCKETS - -> ^(TOK_ALTERTABLE_BUCKETS $bucketCols $sortCols? $num) - ; - -tableSkewed -@init { pushMsg("table skewed specification", state); } -@after { popMsg(state); } - : - KW_SKEWED KW_BY LPAREN skewedCols=columnNameList RPAREN KW_ON LPAREN (skewedValues=skewedValueElement) RPAREN ((storedAsDirs) => storedAsDirs)? - -> ^(TOK_TABLESKEWED $skewedCols $skewedValues storedAsDirs?) - ; - -rowFormat -@init { pushMsg("serde specification", state); } -@after { popMsg(state); } - : rowFormatSerde -> ^(TOK_SERDE rowFormatSerde) - | rowFormatDelimited -> ^(TOK_SERDE rowFormatDelimited) - | -> ^(TOK_SERDE) - ; - -recordReader -@init { pushMsg("record reader specification", state); } -@after { popMsg(state); } - : KW_RECORDREADER StringLiteral -> ^(TOK_RECORDREADER StringLiteral) - | -> ^(TOK_RECORDREADER) - ; - -recordWriter -@init { pushMsg("record writer specification", state); } -@after { popMsg(state); } - : KW_RECORDWRITER StringLiteral -> ^(TOK_RECORDWRITER StringLiteral) - | -> ^(TOK_RECORDWRITER) - ; - -rowFormatSerde -@init { pushMsg("serde format specification", state); } -@after { popMsg(state); } - : KW_ROW KW_FORMAT KW_SERDE name=StringLiteral (KW_WITH KW_SERDEPROPERTIES serdeprops=tableProperties)? - -> ^(TOK_SERDENAME $name $serdeprops?) - ; - -rowFormatDelimited -@init { pushMsg("serde properties specification", state); } -@after { popMsg(state); } - : - KW_ROW KW_FORMAT KW_DELIMITED tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat? - -> ^(TOK_SERDEPROPS tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat?) - ; - -tableRowFormat -@init { pushMsg("table row format specification", state); } -@after { popMsg(state); } - : - rowFormatDelimited - -> ^(TOK_TABLEROWFORMAT rowFormatDelimited) - | rowFormatSerde - -> ^(TOK_TABLESERIALIZER rowFormatSerde) - ; - -tablePropertiesPrefixed -@init { pushMsg("table properties with prefix", state); } -@after { popMsg(state); } - : - KW_TBLPROPERTIES! tableProperties - ; - -tableProperties -@init { pushMsg("table properties", state); } -@after { popMsg(state); } - : - LPAREN tablePropertiesList RPAREN -> ^(TOK_TABLEPROPERTIES tablePropertiesList) - ; - -tablePropertiesList -@init { pushMsg("table properties list", state); } -@after { popMsg(state); } - : - keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_TABLEPROPLIST keyValueProperty+) - | - keyProperty (COMMA keyProperty)* -> ^(TOK_TABLEPROPLIST keyProperty+) - ; - -keyValueProperty -@init { pushMsg("specifying key/value property", state); } -@after { popMsg(state); } - : - key=StringLiteral EQUAL value=StringLiteral -> ^(TOK_TABLEPROPERTY $key $value) - ; - -keyProperty -@init { pushMsg("specifying key property", state); } -@after { popMsg(state); } - : - key=StringLiteral -> ^(TOK_TABLEPROPERTY $key TOK_NULL) - ; - -tableRowFormatFieldIdentifier -@init { pushMsg("table row format's field separator", state); } -@after { popMsg(state); } - : - KW_FIELDS KW_TERMINATED KW_BY fldIdnt=StringLiteral (KW_ESCAPED KW_BY fldEscape=StringLiteral)? - -> ^(TOK_TABLEROWFORMATFIELD $fldIdnt $fldEscape?) - ; - -tableRowFormatCollItemsIdentifier -@init { pushMsg("table row format's column separator", state); } -@after { popMsg(state); } - : - KW_COLLECTION KW_ITEMS KW_TERMINATED KW_BY collIdnt=StringLiteral - -> ^(TOK_TABLEROWFORMATCOLLITEMS $collIdnt) - ; - -tableRowFormatMapKeysIdentifier -@init { pushMsg("table row format's map key separator", state); } -@after { popMsg(state); } - : - KW_MAP KW_KEYS KW_TERMINATED KW_BY mapKeysIdnt=StringLiteral - -> ^(TOK_TABLEROWFORMATMAPKEYS $mapKeysIdnt) - ; - -tableRowFormatLinesIdentifier -@init { pushMsg("table row format's line separator", state); } -@after { popMsg(state); } - : - KW_LINES KW_TERMINATED KW_BY linesIdnt=StringLiteral - -> ^(TOK_TABLEROWFORMATLINES $linesIdnt) - ; - -tableRowNullFormat -@init { pushMsg("table row format's null specifier", state); } -@after { popMsg(state); } - : - KW_NULL KW_DEFINED KW_AS nullIdnt=StringLiteral - -> ^(TOK_TABLEROWFORMATNULL $nullIdnt) - ; -tableFileFormat -@init { pushMsg("table file format specification", state); } -@after { popMsg(state); } - : - (KW_STORED KW_AS KW_INPUTFORMAT) => KW_STORED KW_AS KW_INPUTFORMAT inFmt=StringLiteral KW_OUTPUTFORMAT outFmt=StringLiteral (KW_INPUTDRIVER inDriver=StringLiteral KW_OUTPUTDRIVER outDriver=StringLiteral)? - -> ^(TOK_TABLEFILEFORMAT $inFmt $outFmt $inDriver? $outDriver?) - | KW_STORED KW_BY storageHandler=StringLiteral - (KW_WITH KW_SERDEPROPERTIES serdeprops=tableProperties)? - -> ^(TOK_STORAGEHANDLER $storageHandler $serdeprops?) - | KW_STORED KW_AS genericSpec=identifier - -> ^(TOK_FILEFORMAT_GENERIC $genericSpec) - ; - -tableLocation -@init { pushMsg("table location specification", state); } -@after { popMsg(state); } - : - KW_LOCATION locn=StringLiteral -> ^(TOK_TABLELOCATION $locn) - ; - -columnNameTypeList -@init { pushMsg("column name type list", state); } -@after { popMsg(state); } - : columnNameType (COMMA columnNameType)* -> ^(TOK_TABCOLLIST columnNameType+) - ; - -columnNameTypeOrConstraintList -@init { pushMsg("column name type and constraints list", state); } -@after { popMsg(state); } - : columnNameTypeOrConstraint (COMMA columnNameTypeOrConstraint)* -> ^(TOK_TABCOLLIST columnNameTypeOrConstraint+) - ; - -columnNameColonTypeList -@init { pushMsg("column name type list", state); } -@after { popMsg(state); } - : columnNameColonType (COMMA columnNameColonType)* -> ^(TOK_TABCOLLIST columnNameColonType+) - ; - -columnNameList -@init { pushMsg("column name list", state); } -@after { popMsg(state); } - : columnName (COMMA columnName)* -> ^(TOK_TABCOLNAME columnName+) - ; - -columnName -@init { pushMsg("column name", state); } -@after { popMsg(state); } - : - identifier - ; - -extColumnName -@init { pushMsg("column name for complex types", state); } -@after { popMsg(state); } - : - identifier (DOT^ ((KW_ELEM_TYPE) => KW_ELEM_TYPE | (KW_KEY_TYPE) => KW_KEY_TYPE | (KW_VALUE_TYPE) => KW_VALUE_TYPE | identifier))* - ; - -columnNameOrderList -@init { pushMsg("column name order list", state); } -@after { popMsg(state); } - : columnNameOrder (COMMA columnNameOrder)* -> ^(TOK_TABCOLNAME columnNameOrder+) - ; - -columnParenthesesList -@init { pushMsg("column parentheses list", state); } -@after { popMsg(state); } - : LPAREN! columnNameList RPAREN! - ; - -enableValidateSpecification -@init { pushMsg("enable specification", state); } -@after { popMsg(state); } - : enableSpecification validateSpecification? - | enforcedSpecification - ; - -enableSpecification -@init { pushMsg("enable specification", state); } -@after { popMsg(state); } - : KW_ENABLE -> ^(TOK_ENABLE) - | KW_DISABLE -> ^(TOK_DISABLE) - ; - -validateSpecification -@init { pushMsg("validate specification", state); } -@after { popMsg(state); } - : KW_VALIDATE -> ^(TOK_VALIDATE) - | KW_NOVALIDATE -> ^(TOK_NOVALIDATE) - ; - -enforcedSpecification -@init { pushMsg("enforced specification", state); } -@after { popMsg(state); } - : KW_ENFORCED -> ^(TOK_ENABLE) - | KW_NOT KW_ENFORCED -> ^(TOK_DISABLE) - ; - -relySpecification -@init { pushMsg("rely specification", state); } -@after { popMsg(state); } - : KW_RELY -> ^(TOK_RELY) - | KW_NORELY -> ^(TOK_NORELY) - ; - -createConstraint -@init { pushMsg("pk or uk or nn constraint", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? tableLevelConstraint constraintOptsCreate? - -> {$constraintName.tree != null}? - ^({$tableLevelConstraint.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsCreate?) - -> ^({$tableLevelConstraint.tree} constraintOptsCreate?) - ; - -alterConstraintWithName -@init { pushMsg("pk or uk or nn constraint with name", state); } -@after { popMsg(state); } - : KW_CONSTRAINT constraintName=identifier tableLevelConstraint constraintOptsAlter? - ->^({$tableLevelConstraint.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsAlter?) - ; - -tableLevelConstraint - : pkUkConstraint - | checkConstraint - ; - -pkUkConstraint -@init { pushMsg("pk or uk table level constraint", state); } -@after { popMsg(state); } - : tableConstraintType pkCols=columnParenthesesList - -> ^(tableConstraintType $pkCols) - ; - -checkConstraint -@init { pushMsg("CHECK constraint", state); } -@after { popMsg(state); } - : KW_CHECK LPAREN expression RPAREN - -> ^(TOK_CHECK_CONSTRAINT expression) - ; - -createForeignKey -@init { pushMsg("foreign key", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? KW_FOREIGN KW_KEY fkCols=columnParenthesesList KW_REFERENCES tabName=tableName parCols=columnParenthesesList constraintOptsCreate? - -> {$constraintName.tree != null}? - ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) $fkCols $tabName $parCols constraintOptsCreate?) - -> ^(TOK_FOREIGN_KEY $fkCols $tabName $parCols constraintOptsCreate?) - ; - -alterForeignKeyWithName -@init { pushMsg("foreign key with key name", state); } -@after { popMsg(state); } - : KW_CONSTRAINT constraintName=identifier KW_FOREIGN KW_KEY fkCols=columnParenthesesList KW_REFERENCES tabName=tableName parCols=columnParenthesesList constraintOptsAlter? - -> ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) $fkCols $tabName $parCols constraintOptsAlter?) - ; - -skewedValueElement -@init { pushMsg("skewed value element", state); } -@after { popMsg(state); } - : - skewedColumnValues - | skewedColumnValuePairList - ; - -skewedColumnValuePairList -@init { pushMsg("column value pair list", state); } -@after { popMsg(state); } - : skewedColumnValuePair (COMMA skewedColumnValuePair)* -> ^(TOK_TABCOLVALUE_PAIR skewedColumnValuePair+) - ; - -skewedColumnValuePair -@init { pushMsg("column value pair", state); } -@after { popMsg(state); } - : - LPAREN colValues=skewedColumnValues RPAREN - -> ^(TOK_TABCOLVALUES $colValues) - ; - -skewedColumnValues -@init { pushMsg("column values", state); } -@after { popMsg(state); } - : skewedColumnValue (COMMA skewedColumnValue)* -> ^(TOK_TABCOLVALUE skewedColumnValue+) - ; - -skewedColumnValue -@init { pushMsg("column value", state); } -@after { popMsg(state); } - : - constant - ; - -skewedValueLocationElement -@init { pushMsg("skewed value location element", state); } -@after { popMsg(state); } - : - skewedColumnValue - | skewedColumnValuePair - ; - -orderSpecification -@init { pushMsg("order specification", state); } -@after { popMsg(state); } - : KW_ASC | KW_DESC ; - -nullOrdering -@init { pushMsg("nulls ordering", state); } -@after { popMsg(state); } - : KW_NULLS KW_FIRST -> ^(TOK_NULLS_FIRST) - | KW_NULLS KW_LAST -> ^(TOK_NULLS_LAST) - ; - -columnNameOrder -@init { pushMsg("column name order", state); } -@after { popMsg(state); } - : identifier orderSpec=orderSpecification? nullSpec=nullOrdering? - -> {$orderSpec.tree == null && $nullSpec.tree == null}? - ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST identifier)) - -> {$orderSpec.tree == null}? - ^(TOK_TABSORTCOLNAMEASC ^($nullSpec identifier)) - -> {$nullSpec.tree == null && $orderSpec.tree.getType()==HiveParser.KW_ASC}? - ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST identifier)) - -> {$nullSpec.tree == null && $orderSpec.tree.getType()==HiveParser.KW_DESC}? - ^(TOK_TABSORTCOLNAMEDESC ^(TOK_NULLS_LAST identifier)) - -> {$orderSpec.tree.getType()==HiveParser.KW_ASC}? - ^(TOK_TABSORTCOLNAMEASC ^($nullSpec identifier)) - -> ^(TOK_TABSORTCOLNAMEDESC ^($nullSpec identifier)) - ; - -columnNameCommentList -@init { pushMsg("column name comment list", state); } -@after { popMsg(state); } - : columnNameComment (COMMA columnNameComment)* -> ^(TOK_TABCOLNAME columnNameComment+) - ; - -columnNameComment -@init { pushMsg("column name comment", state); } -@after { popMsg(state); } - : colName=identifier (KW_COMMENT comment=StringLiteral)? - -> ^(TOK_TABCOL $colName TOK_NULL $comment?) - ; - -orderSpecificationRewrite -@init { pushMsg("order specification", state); } -@after { popMsg(state); } - : KW_ASC -> ^(TOK_TABSORTCOLNAMEASC) - | KW_DESC -> ^(TOK_TABSORTCOLNAMEDESC) - ; - -columnRefOrder -@init { pushMsg("column order", state); } -@after { popMsg(state); } - : expression orderSpec=orderSpecificationRewrite? nullSpec=nullOrdering? - // ORDER not present, NULLS ORDER not present and default is NULLS LAST ex.: ORDER BY col0 - -> {$orderSpec.tree == null && $nullSpec.tree == null && nullsLast()}? - ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_LAST expression)) - // ORDER not present, NULLS ORDER not present and default is NULLS FIRST ex.: ORDER BY col0 - -> {$orderSpec.tree == null && $nullSpec.tree == null}? - ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST expression)) - // ORDER not present but NULLS ORDER present ex.: ORDER BY col0 NULLS FIRST - -> {$orderSpec.tree == null}? - ^(TOK_TABSORTCOLNAMEASC ^($nullSpec expression)) - // ORDER present but NULLS ORDER not present and default is NULLS LAST ex.: ORDER BY col0 ASC - -> {$nullSpec.tree == null && nullsLast()}? - ^($orderSpec ^(TOK_NULLS_LAST expression)) - // ORDER present, NULLS ORDER not present and default is NULLS FIRST ex.: ORDER BY col0 ASC - -> {$nullSpec.tree == null}? - ^($orderSpec ^(TOK_NULLS_FIRST expression)) - // both ORDER and NULLS ORDER present ex.: ORDER BY col0 ASC NULLS LAST - -> ^($orderSpec ^($nullSpec expression)) - ; - -columnNameType -@init { pushMsg("column specification", state); } -@after { popMsg(state); } - : colName=identifier colType (KW_COMMENT comment=StringLiteral)? - -> {containExcludedCharForCreateTableColumnName($colName.text)}? {throwColumnNameException()} - -> {$comment == null}? ^(TOK_TABCOL $colName colType) - -> ^(TOK_TABCOL $colName colType $comment) - ; - -columnNameTypeOrConstraint -@init { pushMsg("column name or constraint", state); } -@after { popMsg(state); } - : ( tableConstraint ) - | ( columnNameTypeConstraint ) - ; - -tableConstraint -@init { pushMsg("table constraint", state); } -@after { popMsg(state); } - : ( createForeignKey ) - | ( createConstraint ) - ; - -columnNameTypeConstraint -@init { pushMsg("column specification", state); } -@after { popMsg(state); } - : colName=identifier colType columnConstraint[$colName.tree]? (KW_COMMENT comment=StringLiteral)? - -> {containExcludedCharForCreateTableColumnName($colName.text)}? {throwColumnNameException()} - -> ^(TOK_TABCOL $colName colType $comment? columnConstraint?) - ; - -columnConstraint[CommonTree fkColName] -@init { pushMsg("column constraint", state); } -@after { popMsg(state); } - : ( foreignKeyConstraint[$fkColName] ) - | ( colConstraint ) - ; - -foreignKeyConstraint[CommonTree fkColName] -@init { pushMsg("column constraint", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? KW_REFERENCES tabName=tableName LPAREN colName=columnName RPAREN constraintOptsCreate? - -> {$constraintName.tree != null}? - ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsCreate?) - -> ^(TOK_FOREIGN_KEY ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsCreate?) - ; - -colConstraint -@init { pushMsg("column constraint", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? columnConstraintType constraintOptsCreate? - -> {$constraintName.tree != null}? - ^({$columnConstraintType.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsCreate?) - -> ^({$columnConstraintType.tree} constraintOptsCreate?) - ; - -alterColumnConstraint[CommonTree fkColName] -@init { pushMsg("alter column constraint", state); } -@after { popMsg(state); } - : ( alterForeignKeyConstraint[$fkColName] ) - | ( alterColConstraint ) - ; - -alterForeignKeyConstraint[CommonTree fkColName] -@init { pushMsg("alter column constraint", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? KW_REFERENCES tabName=tableName LPAREN colName=columnName RPAREN constraintOptsAlter? - -> {$constraintName.tree != null}? - ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsAlter?) - -> ^(TOK_FOREIGN_KEY ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsAlter?) - ; - -alterColConstraint -@init { pushMsg("alter column constraint", state); } -@after { popMsg(state); } - : (KW_CONSTRAINT constraintName=identifier)? columnConstraintType constraintOptsAlter? - -> {$constraintName.tree != null}? - ^({$columnConstraintType.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsAlter?) - -> ^({$columnConstraintType.tree} constraintOptsAlter?) - ; - -columnConstraintType - : KW_NOT KW_NULL -> TOK_NOT_NULL - | KW_DEFAULT defaultVal-> ^(TOK_DEFAULT_VALUE defaultVal) - | checkConstraint - | tableConstraintType - ; - -defaultVal - : constant - | function - | castExpression - ; - -tableConstraintType - : KW_PRIMARY KW_KEY -> TOK_PRIMARY_KEY - | KW_UNIQUE -> TOK_UNIQUE - ; - -constraintOptsCreate - : enableValidateSpecification relySpecification? - ; - -constraintOptsAlter - : enableValidateSpecification relySpecification? - ; - -columnNameColonType -@init { pushMsg("column specification", state); } -@after { popMsg(state); } - : colName=identifier COLON colType (KW_COMMENT comment=StringLiteral)? - -> {$comment == null}? ^(TOK_TABCOL $colName colType) - -> ^(TOK_TABCOL $colName colType $comment) - ; - -colType -@init { pushMsg("column type", state); } -@after { popMsg(state); } - : type - ; - -colTypeList -@init { pushMsg("column type list", state); } -@after { popMsg(state); } - : colType (COMMA colType)* -> ^(TOK_COLTYPELIST colType+) - ; - -type - : primitiveType - | listType - | structType - | mapType - | unionType; - -primitiveType -@init { pushMsg("primitive type specification", state); } -@after { popMsg(state); } - : KW_TINYINT -> TOK_TINYINT - | KW_SMALLINT -> TOK_SMALLINT - | KW_INT -> TOK_INT - | KW_BIGINT -> TOK_BIGINT - | KW_BOOLEAN -> TOK_BOOLEAN - | KW_FLOAT -> TOK_FLOAT - | KW_REAL -> TOK_FLOAT - | KW_DOUBLE KW_PRECISION? -> TOK_DOUBLE - | KW_DATE -> TOK_DATE - | KW_DATETIME -> TOK_DATETIME - | KW_TIMESTAMP -> TOK_TIMESTAMP - | KW_TIMESTAMPLOCALTZ -> TOK_TIMESTAMPLOCALTZ - //| KW_TIMESTAMPTZ -> TOK_TIMESTAMPTZ - | KW_TIMESTAMP KW_WITH KW_LOCAL KW_TIME KW_ZONE -> TOK_TIMESTAMPLOCALTZ - //| KW_TIMESTAMP KW_WITH KW_TIME KW_ZONE -> TOK_TIMESTAMPTZ - // Uncomment to allow intervals as table column types - //| KW_INTERVAL KW_YEAR KW_TO KW_MONTH -> TOK_INTERVAL_YEAR_MONTH - //| KW_INTERVAL KW_DAY KW_TO KW_SECOND -> TOK_INTERVAL_DAY_TIME - | KW_STRING -> TOK_STRING - | KW_BINARY -> TOK_BINARY - | KW_DECIMAL (LPAREN prec=Number (COMMA scale=Number)? RPAREN)? -> ^(TOK_DECIMAL $prec? $scale?) - | KW_VARCHAR LPAREN length=Number RPAREN -> ^(TOK_VARCHAR $length) - | KW_CHAR LPAREN length=Number RPAREN -> ^(TOK_CHAR $length) - ; - -listType -@init { pushMsg("list type", state); } -@after { popMsg(state); } - : KW_ARRAY LESSTHAN type GREATERTHAN -> ^(TOK_LIST type) - ; - -structType -@init { pushMsg("struct type", state); } -@after { popMsg(state); } - : KW_STRUCT LESSTHAN columnNameColonTypeList GREATERTHAN -> ^(TOK_STRUCT columnNameColonTypeList) - ; - -mapType -@init { pushMsg("map type", state); } -@after { popMsg(state); } - : KW_MAP LESSTHAN left=primitiveType COMMA right=type GREATERTHAN - -> ^(TOK_MAP $left $right) - ; - -unionType -@init { pushMsg("uniontype type", state); } -@after { popMsg(state); } - : KW_UNIONTYPE LESSTHAN colTypeList GREATERTHAN -> ^(TOK_UNIONTYPE colTypeList) - ; - -setOperator -@init { pushMsg("set operator", state); } -@after { popMsg(state); } - : KW_UNION KW_ALL -> ^(TOK_UNIONALL) - | KW_UNION KW_DISTINCT? -> ^(TOK_UNIONDISTINCT) - | KW_INTERSECT KW_ALL -> ^(TOK_INTERSECTALL) - | KW_INTERSECT KW_DISTINCT? -> ^(TOK_INTERSECTDISTINCT) - | KW_EXCEPT KW_ALL -> ^(TOK_EXCEPTALL) - | KW_EXCEPT KW_DISTINCT? -> ^(TOK_EXCEPTDISTINCT) - | KW_MINUS KW_ALL -> ^(TOK_EXCEPTALL) - | KW_MINUS KW_DISTINCT? -> ^(TOK_EXCEPTDISTINCT) - ; - -queryStatementExpression - : - /* Would be nice to do this as a gated semantic perdicate - But the predicate gets pushed as a lookahead decision. - Calling rule doesnot know about topLevel - */ - (w=withClause)? - queryStatementExpressionBody { - if ($w.tree != null) { - $queryStatementExpressionBody.tree.insertChild(0, $w.tree); - } - } - -> queryStatementExpressionBody - ; - -queryStatementExpressionBody - : - fromStatement - | regularBody - ; - -withClause - : - KW_WITH cteStatement (COMMA cteStatement)* -> ^(TOK_CTE cteStatement+) -; - -cteStatement - : - identifier KW_AS LPAREN queryStatementExpression RPAREN - -> ^(TOK_SUBQUERY queryStatementExpression identifier) -; - -fromStatement -: (singleFromStatement -> singleFromStatement) - (u=setOperator r=singleFromStatement - -> ^($u {$fromStatement.tree} $r) - )* - -> {u != null}? ^(TOK_QUERY - ^(TOK_FROM - ^(TOK_SUBQUERY - {$fromStatement.tree} - {adaptor.create(Identifier, generateUnionAlias())} - ) - ) - ^(TOK_INSERT - ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) - ) - ) - -> {$fromStatement.tree} - ; - - -singleFromStatement - : - fromClause - ( b+=body )+ -> ^(TOK_QUERY fromClause body+) - ; - -/* -The valuesClause rule below ensures that the parse tree for -"insert into table FOO values (1,2),(3,4)" looks the same as -"insert into table FOO select a,b from (values(1,2),(3,4)) as BAR(a,b)" which itself is made to look -very similar to the tree for "insert into table FOO select a,b from BAR". -*/ -regularBody - : - i=insertClause - ( - s=selectStatement - {$s.tree.getFirstChildWithType(TOK_INSERT).replaceChildren(0, 0, $i.tree);} -> {$s.tree} - | - valuesClause - -> ^(TOK_QUERY - ^(TOK_INSERT {$i.tree} ^(TOK_SELECT ^(TOK_SELEXPR ^(TOK_FUNCTION Identifier["inline"] valuesClause)))) - ) - ) - | - selectStatement - ; - -atomSelectStatement - : - s=selectClause - f=fromClause? - w=whereClause? - g=groupByClause? - h=havingClause? - win=window_clause? - -> ^(TOK_QUERY $f? ^(TOK_INSERT ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - $s $w? $g? $h? $win?)) - | - LPAREN! selectStatement RPAREN! - ; - -selectStatement - : - a=atomSelectStatement - set=setOpSelectStatement[$atomSelectStatement.tree]? - o=orderByClause? - c=clusterByClause? - d=distributeByClause? - sort=sortByClause? - l=limitClause? - { - if(set == null){ - $a.tree.getFirstChildWithType(TOK_INSERT).addChild($o.tree); - $a.tree.getFirstChildWithType(TOK_INSERT).addChild($c.tree); - $a.tree.getFirstChildWithType(TOK_INSERT).addChild($d.tree); - $a.tree.getFirstChildWithType(TOK_INSERT).addChild($sort.tree); - $a.tree.getFirstChildWithType(TOK_INSERT).addChild($l.tree); - } - } - -> {set == null}? - {$a.tree} - -> {o==null && c==null && d==null && sort==null && l==null}? - {$set.tree} - -> ^(TOK_QUERY - ^(TOK_FROM - ^(TOK_SUBQUERY - {$set.tree} - {adaptor.create(Identifier, generateUnionAlias())} - ) - ) - ^(TOK_INSERT - ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) - $o? $c? $d? $sort? $l? - ) - ) - ; - -setOpSelectStatement[CommonTree t] - : - (u=setOperator b=atomSelectStatement - -> {$setOpSelectStatement.tree != null && ((CommonTree)u.getTree()).getType()==HiveParser.TOK_UNIONDISTINCT}? - ^(TOK_QUERY - ^(TOK_FROM - ^(TOK_SUBQUERY - ^(TOK_UNIONALL {$setOpSelectStatement.tree} $b) - {adaptor.create(Identifier, generateUnionAlias())} - ) - ) - ^(TOK_INSERT - ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - ^(TOK_SELECTDI ^(TOK_SELEXPR TOK_SETCOLREF)) - ) - ) - -> {$setOpSelectStatement.tree != null && ((CommonTree)u.getTree()).getType()!=HiveParser.TOK_UNIONDISTINCT}? - ^($u {$setOpSelectStatement.tree} $b) - -> {$setOpSelectStatement.tree == null && ((CommonTree)u.getTree()).getType()==HiveParser.TOK_UNIONDISTINCT}? - ^(TOK_QUERY - ^(TOK_FROM - ^(TOK_SUBQUERY - ^(TOK_UNIONALL {$t} $b) - {adaptor.create(Identifier, generateUnionAlias())} - ) - ) - ^(TOK_INSERT - ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - ^(TOK_SELECTDI ^(TOK_SELEXPR TOK_SETCOLREF)) - ) - ) - -> ^($u {$t} $b) - )+ - -> {$setOpSelectStatement.tree.getChild(0).getType()==HiveParser.TOK_UNIONALL - ||$setOpSelectStatement.tree.getChild(0).getType()==HiveParser.TOK_INTERSECTDISTINCT - ||$setOpSelectStatement.tree.getChild(0).getType()==HiveParser.TOK_INTERSECTALL - ||$setOpSelectStatement.tree.getChild(0).getType()==HiveParser.TOK_EXCEPTDISTINCT - ||$setOpSelectStatement.tree.getChild(0).getType()==HiveParser.TOK_EXCEPTALL}? - ^(TOK_QUERY - ^(TOK_FROM - ^(TOK_SUBQUERY - {$setOpSelectStatement.tree} - {adaptor.create(Identifier, generateUnionAlias())} - ) - ) - ^(TOK_INSERT - ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) - ) - ) - -> {$setOpSelectStatement.tree} - ; - -selectStatementWithCTE - : - (w=withClause)? - selectStatement { - if ($w.tree != null) { - $selectStatement.tree.insertChild(0, $w.tree); - } - } - -> selectStatement - ; - -body - : - insertClause - selectClause - lateralView? - whereClause? - groupByClause? - havingClause? - window_clause? - orderByClause? - clusterByClause? - distributeByClause? - sortByClause? - limitClause? -> ^(TOK_INSERT insertClause - selectClause lateralView? whereClause? groupByClause? havingClause? orderByClause? clusterByClause? - distributeByClause? sortByClause? window_clause? limitClause?) - | - selectClause - lateralView? - whereClause? - groupByClause? - havingClause? - window_clause? - orderByClause? - clusterByClause? - distributeByClause? - sortByClause? - limitClause? -> ^(TOK_INSERT ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) - selectClause lateralView? whereClause? groupByClause? havingClause? orderByClause? clusterByClause? - distributeByClause? sortByClause? window_clause? limitClause?) - ; - -insertClause -@init { pushMsg("insert clause", state); } -@after { popMsg(state); } - : - KW_INSERT KW_OVERWRITE destination ifNotExists? -> ^(TOK_DESTINATION destination ifNotExists?) - | KW_INSERT KW_INTO KW_TABLE? tableOrPartition (LPAREN targetCols=columnNameList RPAREN)? - -> ^(TOK_INSERT_INTO tableOrPartition $targetCols?) - ; - -destination -@init { pushMsg("destination specification", state); } -@after { popMsg(state); } - : - (local = KW_LOCAL)? KW_DIRECTORY StringLiteral tableRowFormat? tableFileFormat? - -> ^(TOK_DIR StringLiteral $local? tableRowFormat? tableFileFormat?) - | KW_TABLE tableOrPartition -> tableOrPartition - ; - -limitClause -@init { pushMsg("limit clause", state); } -@after { popMsg(state); } - : - KW_LIMIT ((offset=Number COMMA)? num=Number) -> ^(TOK_LIMIT ($offset)? $num) - | KW_LIMIT num=Number KW_OFFSET offset=Number -> ^(TOK_LIMIT ($offset)? $num) - ; - -//DELETE FROM WHERE ...; -deleteStatement -@init { pushMsg("delete statement", state); } -@after { popMsg(state); } - : - KW_DELETE KW_FROM tableName (whereClause)? -> ^(TOK_DELETE_FROM tableName whereClause?) - ; - -/*SET = (3 + col2)*/ -columnAssignmentClause - : - tableOrColumn EQUAL^ precedencePlusExpression - ; - -/*SET col1 = 5, col2 = (4 + col4), ...*/ -setColumnsClause - : - KW_SET columnAssignmentClause (COMMA columnAssignmentClause)* -> ^(TOK_SET_COLUMNS_CLAUSE columnAssignmentClause* ) - ; - -/* - UPDATE - SET col1 = val1, col2 = val2... WHERE ... -*/ -updateStatement -@init { pushMsg("update statement", state); } -@after { popMsg(state); } - : - KW_UPDATE tableName setColumnsClause whereClause? -> ^(TOK_UPDATE_TABLE tableName setColumnsClause whereClause?) - ; - -/* -BEGIN user defined transaction boundaries; follows SQL 2003 standard exactly except for addition of -"setAutoCommitStatement" which is not in the standard doc but is supported by most SQL engines. -*/ -sqlTransactionStatement -@init { pushMsg("transaction statement", state); } -@after { popMsg(state); } - : - startTransactionStatement - | commitStatement - | rollbackStatement - | setAutoCommitStatement - ; - -startTransactionStatement - : - KW_START KW_TRANSACTION ( transactionMode ( COMMA transactionMode )* )? -> ^(TOK_START_TRANSACTION transactionMode*) - ; - -transactionMode - : - isolationLevel - | transactionAccessMode -> ^(TOK_TXN_ACCESS_MODE transactionAccessMode) - ; - -transactionAccessMode - : - KW_READ KW_ONLY -> TOK_TXN_READ_ONLY - | KW_READ KW_WRITE -> TOK_TXN_READ_WRITE - ; - -isolationLevel - : - KW_ISOLATION KW_LEVEL levelOfIsolation -> ^(TOK_ISOLATION_LEVEL levelOfIsolation) - ; - -/*READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE may be supported later*/ -levelOfIsolation - : - KW_SNAPSHOT -> TOK_ISOLATION_SNAPSHOT - ; - -commitStatement - : - KW_COMMIT ( KW_WORK )? -> TOK_COMMIT - ; - -rollbackStatement - : - KW_ROLLBACK ( KW_WORK )? -> TOK_ROLLBACK - ; -setAutoCommitStatement - : - KW_SET KW_AUTOCOMMIT booleanValueTok -> ^(TOK_SET_AUTOCOMMIT booleanValueTok) - ; -/* -END user defined transaction boundaries -*/ - -abortTransactionStatement -@init { pushMsg("abort transactions statement", state); } -@after { popMsg(state); } - : - KW_ABORT KW_TRANSACTIONS ( Number )+ -> ^(TOK_ABORT_TRANSACTIONS ( Number )+) - ; - - -/* -BEGIN SQL Merge statement -*/ -mergeStatement -@init { pushMsg("MERGE statement", state); } -@after { popMsg(state); } - : - KW_MERGE QUERY_HINT? KW_INTO tableName (KW_AS? identifier)? KW_USING joinSourcePart KW_ON expression whenClauses - -> ^(TOK_MERGE ^(TOK_TABREF tableName identifier?) joinSourcePart expression QUERY_HINT? whenClauses) - ; -/* -Allow 0,1 or 2 WHEN MATCHED clauses and 0 or 1 WHEN NOT MATCHED -Each WHEN clause may have AND . -If 2 WHEN MATCHED clauses are present, 1 must be UPDATE the other DELETE and the 1st one -must have AND -*/ -whenClauses - : - (whenMatchedAndClause|whenMatchedThenClause)* whenNotMatchedClause? - ; -whenNotMatchedClause -@init { pushMsg("WHEN NOT MATCHED clause", state); } -@after { popMsg(state); } - : - KW_WHEN KW_NOT KW_MATCHED (KW_AND expression)? KW_THEN KW_INSERT (targetCols=columnParenthesesList)? KW_VALUES valueRowConstructor -> - ^(TOK_NOT_MATCHED ^(TOK_INSERT $targetCols? valueRowConstructor) expression?) - ; -whenMatchedAndClause -@init { pushMsg("WHEN MATCHED AND clause", state); } -@after { popMsg(state); } - : - KW_WHEN KW_MATCHED KW_AND expression KW_THEN updateOrDelete -> - ^(TOK_MATCHED updateOrDelete expression) - ; -whenMatchedThenClause -@init { pushMsg("WHEN MATCHED THEN clause", state); } -@after { popMsg(state); } - : - KW_WHEN KW_MATCHED KW_THEN updateOrDelete -> - ^(TOK_MATCHED updateOrDelete) - ; -updateOrDelete - : - KW_UPDATE setColumnsClause -> ^(TOK_UPDATE setColumnsClause) - | - KW_DELETE -> TOK_DELETE - ; -/* -END SQL Merge statement -*/ - -killQueryStatement -@init { pushMsg("kill query statement", state); } -@after { popMsg(state); } - : - KW_KILL KW_QUERY ( StringLiteral )+ -> ^(TOK_KILL_QUERY ( StringLiteral )+) - ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserParent.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserParent.g new file mode 100644 index 0000000000..54f5b82e9f --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserParent.g @@ -0,0 +1,2883 @@ +/** + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +parser grammar HiveParserParent; + +options +{ +output=AST; +ASTLabelType=ASTNode; +backtrack=false; +k=3; +} +import SelectClauseParser, FromClauseParser, IdentifiersParser, ResourcePlanParser; + +tokens { +TOK_INSERT; +TOK_QUERY; +TOK_SELECT; +TOK_SELECTDI; +TOK_SELEXPR; +TOK_FROM; +TOK_TAB; +TOK_PARTSPEC; +TOK_PARTVAL; +TOK_DIR; +TOK_TABREF; +TOK_SUBQUERY; +TOK_INSERT_INTO; +TOK_DESTINATION; +TOK_ALLCOLREF; +TOK_SETCOLREF; +TOK_TABLE_OR_COL; +TOK_FUNCTION; +TOK_FUNCTIONDI; +TOK_FUNCTIONSTAR; +TOK_WHERE; +TOK_OP_EQ; +TOK_OP_NE; +TOK_OP_LE; +TOK_OP_LT; +TOK_OP_GE; +TOK_OP_GT; +TOK_OP_DIV; +TOK_OP_ADD; +TOK_OP_SUB; +TOK_OP_MUL; +TOK_OP_MOD; +TOK_OP_BITAND; +TOK_OP_BITNOT; +TOK_OP_BITOR; +TOK_OP_BITXOR; +TOK_OP_AND; +TOK_OP_OR; +TOK_OP_NOT; +TOK_OP_LIKE; +TOK_TRUE; +TOK_FALSE; +TOK_UNKNOWN; +TOK_TRANSFORM; +TOK_SERDE; +TOK_SERDENAME; +TOK_SERDEPROPS; +TOK_EXPLIST; +TOK_ALIASLIST; +TOK_GROUPBY; +TOK_ROLLUP_GROUPBY; +TOK_CUBE_GROUPBY; +TOK_GROUPING_SETS; +TOK_GROUPING_SETS_EXPRESSION; +TOK_HAVING; +TOK_ORDERBY; +TOK_NULLS_FIRST; +TOK_NULLS_LAST; +TOK_CLUSTERBY; +TOK_DISTRIBUTEBY; +TOK_SORTBY; +TOK_UNIONALL; +TOK_UNIONDISTINCT; +TOK_INTERSECTALL; +TOK_INTERSECTDISTINCT; +TOK_EXCEPTALL; +TOK_EXCEPTDISTINCT; +TOK_JOIN; +TOK_LEFTOUTERJOIN; +TOK_RIGHTOUTERJOIN; +TOK_FULLOUTERJOIN; +TOK_UNIQUEJOIN; +TOK_CROSSJOIN; +TOK_LOAD; +TOK_EXPORT; +TOK_IMPORT; +TOK_REPLICATION; +TOK_METADATA; +TOK_NULL; +TOK_NOT_NULL; +TOK_UNIQUE; +TOK_PRIMARY_KEY; +TOK_FOREIGN_KEY; +TOK_DEFAULT_VALUE; +TOK_CHECK_CONSTRAINT; +TOK_VALIDATE; +TOK_NOVALIDATE; +TOK_RELY; +TOK_NORELY; +TOK_CONSTRAINT_NAME; +TOK_TINYINT; +TOK_SMALLINT; +TOK_INT; +TOK_BIGINT; +TOK_BOOLEAN; +TOK_FLOAT; +TOK_REAL; +TOK_DOUBLE; +TOK_DATE; +TOK_DATELITERAL; +TOK_DATETIME; +TOK_TIMESTAMP; +TOK_TIMESTAMPLITERAL; +TOK_TIMESTAMPLOCALTZ; +TOK_TIMESTAMPLOCALTZLITERAL; +TOK_INTERVAL_YEAR_MONTH; +TOK_INTERVAL_YEAR_MONTH_LITERAL; +TOK_INTERVAL_DAY_TIME; +TOK_INTERVAL_DAY_TIME_LITERAL; +TOK_INTERVAL_YEAR_LITERAL; +TOK_INTERVAL_MONTH_LITERAL; +TOK_INTERVAL_DAY_LITERAL; +TOK_INTERVAL_HOUR_LITERAL; +TOK_INTERVAL_MINUTE_LITERAL; +TOK_INTERVAL_SECOND_LITERAL; +TOK_STRING; +TOK_CHAR; +TOK_VARCHAR; +TOK_BINARY; +TOK_DECIMAL; +TOK_LIST; +TOK_STRUCT; +TOK_MAP; +TOK_UNIONTYPE; +TOK_COLTYPELIST; +TOK_CREATEDATABASE; +TOK_CREATETABLE; +TOK_TRUNCATETABLE; +TOK_LIKETABLE; +TOK_DESCTABLE; +TOK_DESCFUNCTION; +TOK_ALTERTABLE; +TOK_ALTERTABLE_RENAME; +TOK_ALTERTABLE_ADDCOLS; +TOK_ALTERTABLE_RENAMECOL; +TOK_ALTERTABLE_RENAMEPART; +TOK_ALTERTABLE_REPLACECOLS; +TOK_ALTERTABLE_ADDPARTS; +TOK_ALTERTABLE_DROPPARTS; +TOK_ALTERTABLE_PARTCOLTYPE; +TOK_ALTERTABLE_MERGEFILES; +TOK_ALTERPARTITION_MERGEFILES; +TOK_ALTERTABLE_TOUCH; +TOK_ALTERTABLE_ARCHIVE; +TOK_ALTERTABLE_UNARCHIVE; +TOK_ALTERTABLE_SERDEPROPERTIES; +TOK_ALTERPARTITION_SERDEPROPERTIES; +TOK_ALTERTABLE_SERIALIZER; +TOK_ALTERPARTITION_SERIALIZER; +TOK_ALTERTABLE_UPDATECOLSTATS; +TOK_ALTERPARTITION_UPDATECOLSTATS; +TOK_ALTERTABLE_UPDATESTATS; +TOK_ALTERPARTITION_UPDATESTATS; +TOK_TABLE_PARTITION; +TOK_ALTERTABLE_FILEFORMAT; +TOK_ALTERPARTITION_FILEFORMAT; +TOK_ALTERTABLE_LOCATION; +TOK_ALTERPARTITION_LOCATION; +TOK_ALTERTABLE_PROPERTIES; +TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION; +TOK_ALTERTABLE_DROPPROPERTIES; +TOK_ALTERTABLE_SKEWED; +TOK_ALTERTABLE_EXCHANGEPARTITION; +TOK_ALTERTABLE_SKEWED_LOCATION; +TOK_ALTERTABLE_BUCKETS; +TOK_ALTERPARTITION_BUCKETS; +TOK_ALTERTABLE_CLUSTER_SORT; +TOK_ALTERTABLE_COMPACT; +TOK_ALTERTABLE_DROPCONSTRAINT; +TOK_ALTERTABLE_ADDCONSTRAINT; +TOK_ALTERTABLE_UPDATECOLUMNS; +TOK_ALTERTABLE_OWNER; +TOK_MSCK; +TOK_SHOWDATABASES; +TOK_SHOWTABLES; +TOK_SHOWCOLUMNS; +TOK_SHOWFUNCTIONS; +TOK_SHOWPARTITIONS; +TOK_SHOW_CREATEDATABASE; +TOK_SHOW_CREATETABLE; +TOK_SHOW_TABLESTATUS; +TOK_SHOW_TBLPROPERTIES; +TOK_SHOWLOCKS; +TOK_SHOWCONF; +TOK_LOCKTABLE; +TOK_UNLOCKTABLE; +TOK_LOCKDB; +TOK_UNLOCKDB; +TOK_SWITCHDATABASE; +TOK_DROPDATABASE; +TOK_DROPTABLE; +TOK_DATABASECOMMENT; +TOK_TABCOLLIST; +TOK_TABCOL; +TOK_TABLECOMMENT; +TOK_TABLEPARTCOLS; +TOK_TABLEPARTCOLNAMES; +TOK_TABLEROWFORMAT; +TOK_TABLEROWFORMATFIELD; +TOK_TABLEROWFORMATCOLLITEMS; +TOK_TABLEROWFORMATMAPKEYS; +TOK_TABLEROWFORMATLINES; +TOK_TABLEROWFORMATNULL; +TOK_TABLEFILEFORMAT; +TOK_FILEFORMAT_GENERIC; +TOK_OFFLINE; +TOK_ENABLE; +TOK_DISABLE; +TOK_READONLY; +TOK_NO_DROP; +TOK_STORAGEHANDLER; +TOK_NOT_CLUSTERED; +TOK_NOT_SORTED; +TOK_TABCOLNAME; +TOK_TABLELOCATION; +TOK_PARTITIONLOCATION; +TOK_TABLEBUCKETSAMPLE; +TOK_TABLESPLITSAMPLE; +TOK_PERCENT; +TOK_LENGTH; +TOK_ROWCOUNT; +TOK_TMP_FILE; +TOK_TABSORTCOLNAMEASC; +TOK_TABSORTCOLNAMEDESC; +TOK_STRINGLITERALSEQUENCE; +TOK_CHARSETLITERAL; +TOK_CREATEFUNCTION; +TOK_DROPFUNCTION; +TOK_RELOADFUNCTIONS; +TOK_CREATEMACRO; +TOK_DROPMACRO; +TOK_TEMPORARY; +TOK_CREATEVIEW; +TOK_DROPVIEW; +TOK_ALTERVIEW; +TOK_ALTERVIEW_PROPERTIES; +TOK_ALTERVIEW_DROPPROPERTIES; +TOK_ALTERVIEW_ADDPARTS; +TOK_ALTERVIEW_DROPPARTS; +TOK_ALTERVIEW_RENAME; +TOK_CREATE_MATERIALIZED_VIEW; +TOK_DROP_MATERIALIZED_VIEW; +TOK_ALTER_MATERIALIZED_VIEW; +TOK_ALTER_MATERIALIZED_VIEW_REWRITE; +TOK_ALTER_MATERIALIZED_VIEW_REBUILD; +TOK_CREATE_SCHEDULED_QUERY; +TOK_ALTER_SCHEDULED_QUERY; +TOK_DROP_SCHEDULED_QUERY; +TOK_REWRITE_ENABLED; +TOK_REWRITE_DISABLED; +TOK_VIEWPARTCOLS; +TOK_VIEWCLUSTERCOLS; +TOK_VIEWDISTRIBUTECOLS; +TOK_VIEWSORTCOLS; +TOK_EXPLAIN; +TOK_EXPLAIN_SQ_REWRITE; +TOK_TABLESERIALIZER; +TOK_TABLEPROPERTIES; +TOK_TABLEPROPLIST; +TOK_TABTYPE; +TOK_LIMIT; +TOK_OFFSET; +TOK_TABLEPROPERTY; +TOK_IFEXISTS; +TOK_IFNOTEXISTS; +TOK_ORREPLACE; +TOK_USERSCRIPTCOLNAMES; +TOK_USERSCRIPTCOLSCHEMA; +TOK_RECORDREADER; +TOK_RECORDWRITER; +TOK_LEFTSEMIJOIN; +TOK_LATERAL_VIEW; +TOK_LATERAL_VIEW_OUTER; +TOK_TABALIAS; +TOK_ANALYZE; +TOK_CREATEROLE; +TOK_DROPROLE; +TOK_GRANT; +TOK_REVOKE; +TOK_SHOW_GRANT; +TOK_PRIVILEGE_LIST; +TOK_PRIVILEGE; +TOK_PRINCIPAL_NAME; +TOK_USER; +TOK_GROUP; +TOK_ROLE; +TOK_RESOURCE_ALL; +TOK_GRANT_WITH_OPTION; +TOK_GRANT_WITH_ADMIN_OPTION; +TOK_ADMIN_OPTION_FOR; +TOK_GRANT_OPTION_FOR; +TOK_PRIV_ALL; +TOK_PRIV_ALTER_METADATA; +TOK_PRIV_ALTER_DATA; +TOK_PRIV_DELETE; +TOK_PRIV_DROP; +TOK_PRIV_INSERT; +TOK_PRIV_LOCK; +TOK_PRIV_SELECT; +TOK_PRIV_SHOW_DATABASE; +TOK_PRIV_CREATE; +TOK_PRIV_OBJECT; +TOK_PRIV_OBJECT_COL; +TOK_GRANT_ROLE; +TOK_REVOKE_ROLE; +TOK_SET_ROLE; +TOK_SHOW_ROLE_GRANT; +TOK_SHOW_ROLES; +TOK_SHOW_CURRENT_ROLE; +TOK_SHOW_ROLE_PRINCIPALS; +TOK_SHOWDBLOCKS; +TOK_DESCDATABASE; +TOK_DATABASEPROPERTIES; +TOK_DATABASELOCATION; +TOK_DATABASE_MANAGEDLOCATION; +TOK_DBPROPLIST; +TOK_ALTERDATABASE_PROPERTIES; +TOK_ALTERDATABASE_OWNER; +TOK_ALTERDATABASE_LOCATION; +TOK_ALTERDATABASE_MANAGEDLOCATION; +TOK_DBNAME; +TOK_TABNAME; +TOK_TABSRC; +TOK_RESTRICT; +TOK_CASCADE; +TOK_FORCE; +TOK_TABLESKEWED; +TOK_TABCOLVALUE; +TOK_TABCOLVALUE_PAIR; +TOK_TABCOLVALUES; +TOK_SKEWED_LOCATIONS; +TOK_SKEWED_LOCATION_LIST; +TOK_SKEWED_LOCATION_MAP; +TOK_STOREDASDIRS; +TOK_PARTITIONINGSPEC; +TOK_PTBLFUNCTION; +TOK_WINDOWDEF; +TOK_WINDOWSPEC; +TOK_WINDOWVALUES; +TOK_WINDOWRANGE; +TOK_SUBQUERY_EXPR; +TOK_SUBQUERY_OP; +TOK_SUBQUERY_OP_NOTIN; +TOK_SUBQUERY_OP_NOTEXISTS; +TOK_DB_TYPE; +TOK_TABLE_TYPE; +TOK_CTE; +TOK_ARCHIVE; +TOK_FILE; +TOK_JAR; +TOK_RESOURCE_URI; +TOK_RESOURCE_LIST; +TOK_SHOW_COMPACTIONS; +TOK_SHOW_TRANSACTIONS; +TOK_DELETE_FROM; +TOK_UPDATE_TABLE; +TOK_SET_COLUMNS_CLAUSE; +TOK_COL_NAME; +TOK_URI_TYPE; +TOK_SERVER_TYPE; +TOK_SHOWVIEWS; +TOK_SHOWMATERIALIZEDVIEWS; +TOK_START_TRANSACTION; +TOK_ISOLATION_LEVEL; +TOK_ISOLATION_SNAPSHOT; +TOK_TXN_ACCESS_MODE; +TOK_TXN_READ_ONLY; +TOK_TXN_READ_WRITE; +TOK_COMMIT; +TOK_ROLLBACK; +TOK_SET_AUTOCOMMIT; +TOK_CACHE_METADATA; +TOK_ABORT_TRANSACTIONS; +TOK_MERGE; +TOK_MATCHED; +TOK_NOT_MATCHED; +TOK_UPDATE; +TOK_DELETE; +TOK_REPL_DUMP; +TOK_REPL_LOAD; +TOK_REPL_STATUS; +TOK_REPL_CONFIG; +TOK_REPL_CONFIG_LIST; +TOK_REPL_TABLES; +TOK_REPL_TABLES_LIST; +TOK_TO; +TOK_ONLY; +TOK_SUMMARY; +TOK_OPERATOR; +TOK_EXPRESSION; +TOK_DETAIL; +TOK_BLOCKING; +TOK_KILL_QUERY; +TOK_CREATE_RP; +TOK_SHOW_RP; +TOK_ALTER_RP_ENABLE; +TOK_ALTER_RP_DISABLE; +TOK_ALTER_RP_RENAME; +TOK_ALTER_RP_SET; +TOK_ALTER_RP_UNSET; +TOK_ALTER_RP_REPLACE; +TOK_ALTER_RP_VALIDATE; +TOK_DROP_RP; +TOK_ACTIVATE; +TOK_QUERY_PARALLELISM; +TOK_RENAME; +TOK_DEFAULT_POOL; +TOK_CREATE_TRIGGER; +TOK_ALTER_TRIGGER; +TOK_DROP_TRIGGER; +TOK_TRIGGER_EXPRESSION; +TOK_CREATE_POOL; +TOK_ALTER_POOL; +TOK_ALTER_POOL_ADD_TRIGGER; +TOK_ALTER_POOL_DROP_TRIGGER; +TOK_DROP_POOL; +TOK_ALLOC_FRACTION; +TOK_SCHEDULING_POLICY; +TOK_PATH; +TOK_CREATE_MAPPING; +TOK_ALTER_MAPPING; +TOK_DROP_MAPPING; +TOK_ADD_TRIGGER; +TOK_REPLACE; +TOK_LIKERP; +TOK_UNMANAGED; +TOK_INPUTFORMAT; +TOK_WITHIN_GROUP; +TOK_CRON; +TOK_EXECUTED_AS; +TOK_EXECUTE; +TOK_SCHEDULE; +TOK_EVERY; +} + +@rulecatch { +catch (RecognitionException e) { + reportError(e); + throw e; +} +} + +// starting rule +statement + : explainStatement EOF + | execStatement EOF + ; + +explainStatement +@init { pushMsg("explain statement", state); } +@after { popMsg(state); } + : KW_EXPLAIN ( + explainOption* execStatement -> ^(TOK_EXPLAIN execStatement explainOption*) + | + KW_REWRITE queryStatementExpression -> ^(TOK_EXPLAIN_SQ_REWRITE queryStatementExpression) + ) + ; + +explainOption +@init { msgs.push("explain option"); } +@after { msgs.pop(); } + : KW_EXTENDED + | KW_FORMATTED + | KW_DEPENDENCY + | KW_CBO (KW_COST | KW_JOINCOST)? + | KW_LOGICAL + | KW_AUTHORIZATION + | KW_ANALYZE + | KW_REOPTIMIZATION + | KW_LOCKS + | KW_AST + | (KW_VECTORIZATION vectorizationOnly? vectorizatonDetail?) + | KW_DEBUG + ; + +vectorizationOnly +@init { pushMsg("vectorization's only clause", state); } +@after { popMsg(state); } + : KW_ONLY + -> ^(TOK_ONLY) + ; + +vectorizatonDetail +@init { pushMsg("vectorization's detail level clause", state); } +@after { popMsg(state); } + : KW_SUMMARY + -> ^(TOK_SUMMARY) + | KW_OPERATOR + -> ^(TOK_OPERATOR) + | KW_EXPRESSION + -> ^(TOK_EXPRESSION) + | KW_DETAIL + -> ^(TOK_DETAIL) + ; + +execStatement +@init { pushMsg("statement", state); } +@after { popMsg(state); } + : queryStatementExpression + | loadStatement + | exportStatement + | importStatement + | replDumpStatement + | replLoadStatement + | replStatusStatement + | ddlStatement + | deleteStatement + | updateStatement + | sqlTransactionStatement + | mergeStatement + ; + +loadStatement +@init { pushMsg("load statement", state); } +@after { popMsg(state); } + : KW_LOAD KW_DATA (islocal=KW_LOCAL)? KW_INPATH (path=StringLiteral) (isoverwrite=KW_OVERWRITE)? KW_INTO KW_TABLE (tab=tableOrPartition) inputFileFormat? + -> ^(TOK_LOAD $path $tab $islocal? $isoverwrite? inputFileFormat?) + ; + +replicationClause +@init { pushMsg("replication clause", state); } +@after { popMsg(state); } + : KW_FOR (isMetadataOnly=KW_METADATA)? KW_REPLICATION LPAREN (replId=StringLiteral) RPAREN + -> ^(TOK_REPLICATION $replId $isMetadataOnly?) + ; + +exportStatement +@init { pushMsg("export statement", state); } +@after { popMsg(state); } + : KW_EXPORT + KW_TABLE (tab=tableOrPartition) + KW_TO (path=StringLiteral) + replicationClause? + -> ^(TOK_EXPORT $tab $path replicationClause?) + ; + +importStatement +@init { pushMsg("import statement", state); } +@after { popMsg(state); } + : KW_IMPORT + ((ext=KW_EXTERNAL)? KW_TABLE (tab=tableOrPartition))? + KW_FROM (path=StringLiteral) + tableLocation? + -> ^(TOK_IMPORT $path $tab? $ext? tableLocation?) + ; + +replDumpStatement +@init { pushMsg("Replication dump statement", state); } +@after { popMsg(state); } + : KW_REPL KW_DUMP + (dbPolicy=replDbPolicy) + (KW_REPLACE oldDbPolicy=replDbPolicy)? + (KW_WITH replConf=replConfigs)? + -> ^(TOK_REPL_DUMP $dbPolicy ^(TOK_REPLACE $oldDbPolicy)? $replConf?) + ; + +replDbPolicy +@init { pushMsg("Repl dump DB replication policy", state); } +@after { popMsg(state); } + : + (dbName=identifier) (DOT tablePolicy=replTableLevelPolicy)? -> $dbName $tablePolicy? + ; + +replLoadStatement +@init { pushMsg("Replication load statement", state); } +@after { popMsg(state); } + : KW_REPL KW_LOAD + (sourceDbPolicy=replDbPolicy) + (KW_INTO dbName=identifier)? + (KW_WITH replConf=replConfigs)? + -> ^(TOK_REPL_LOAD $sourceDbPolicy ^(TOK_DBNAME $dbName)? $replConf?) + ; + +replConfigs +@init { pushMsg("Repl configurations", state); } +@after { popMsg(state); } + : + LPAREN replConfigsList RPAREN -> ^(TOK_REPL_CONFIG replConfigsList) + ; + +replConfigsList +@init { pushMsg("Repl configurations list", state); } +@after { popMsg(state); } + : + keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_REPL_CONFIG_LIST keyValueProperty+) + ; + +replTableLevelPolicy +@init { pushMsg("Replication table level policy definition", state); } +@after { popMsg(state); } + : + ((replTablesIncludeList=StringLiteral) (DOT replTablesExcludeList=StringLiteral)?) + -> ^(TOK_REPL_TABLES $replTablesIncludeList $replTablesExcludeList?) + ; + +replStatusStatement +@init { pushMsg("replication status statement", state); } +@after { popMsg(state); } + : KW_REPL KW_STATUS + (dbName=identifier) + (KW_WITH replConf=replConfigs)? + -> ^(TOK_REPL_STATUS $dbName $replConf?) + ; + +ddlStatement +@init { pushMsg("ddl statement", state); } +@after { popMsg(state); } + : createDatabaseStatement + | switchDatabaseStatement + | dropDatabaseStatement + | createTableStatement + | dropTableStatement + | truncateTableStatement + | alterStatement + | descStatement + | showStatement + | metastoreCheck + | createViewStatement + | createMaterializedViewStatement + | createScheduledQueryStatement + | alterScheduledQueryStatement + | dropScheduledQueryStatement + | dropViewStatement + | dropMaterializedViewStatement + | createFunctionStatement + | createMacroStatement + | dropFunctionStatement + | reloadFunctionsStatement + | dropMacroStatement + | analyzeStatement + | lockStatement + | unlockStatement + | lockDatabase + | unlockDatabase + | createRoleStatement + | dropRoleStatement + | (grantPrivileges) => grantPrivileges + | (revokePrivileges) => revokePrivileges + | showGrants + | showRoleGrants + | showRolePrincipals + | showRoles + | grantRole + | revokeRole + | setRole + | showCurrentRole + | abortTransactionStatement + | killQueryStatement + | resourcePlanDdlStatements + ; + +ifExists +@init { pushMsg("if exists clause", state); } +@after { popMsg(state); } + : KW_IF KW_EXISTS + -> ^(TOK_IFEXISTS) + ; + +restrictOrCascade +@init { pushMsg("restrict or cascade clause", state); } +@after { popMsg(state); } + : KW_RESTRICT + -> ^(TOK_RESTRICT) + | KW_CASCADE + -> ^(TOK_CASCADE) + ; + +ifNotExists +@init { pushMsg("if not exists clause", state); } +@after { popMsg(state); } + : KW_IF KW_NOT KW_EXISTS + -> ^(TOK_IFNOTEXISTS) + ; + +force +@init { msgs.push("force clause"); } +@after { msgs.pop(); } + : KW_FORCE + -> ^(TOK_FORCE) + ; + +rewriteEnabled +@init { pushMsg("rewrite enabled clause", state); } +@after { popMsg(state); } + : KW_ENABLE KW_REWRITE + -> ^(TOK_REWRITE_ENABLED) + ; + +rewriteDisabled +@init { pushMsg("rewrite disabled clause", state); } +@after { popMsg(state); } + : KW_DISABLE KW_REWRITE + -> ^(TOK_REWRITE_DISABLED) + ; + +storedAsDirs +@init { pushMsg("stored as directories", state); } +@after { popMsg(state); } + : KW_STORED KW_AS KW_DIRECTORIES + -> ^(TOK_STOREDASDIRS) + ; + +orReplace +@init { pushMsg("or replace clause", state); } +@after { popMsg(state); } + : KW_OR KW_REPLACE + -> ^(TOK_ORREPLACE) + ; + +createDatabaseStatement +@init { pushMsg("create database statement", state); } +@after { popMsg(state); } + : KW_CREATE (KW_DATABASE|KW_SCHEMA) + ifNotExists? + name=identifier + databaseComment? + dbLocation? + dbManagedLocation? + (KW_WITH KW_DBPROPERTIES dbprops=dbProperties)? + -> ^(TOK_CREATEDATABASE $name ifNotExists? dbLocation? dbManagedLocation? databaseComment? $dbprops?) + ; + +dbLocation +@init { pushMsg("database location specification", state); } +@after { popMsg(state); } + : + KW_LOCATION locn=StringLiteral -> ^(TOK_DATABASELOCATION $locn) + ; + +dbManagedLocation +@init { pushMsg("database managed location specification", state); } +@after { popMsg(state); } + : + KW_MANAGEDLOCATION locn=StringLiteral -> ^(TOK_DATABASE_MANAGEDLOCATION $locn) + ; + +dbProperties +@init { pushMsg("dbproperties", state); } +@after { popMsg(state); } + : + LPAREN dbPropertiesList RPAREN -> ^(TOK_DATABASEPROPERTIES dbPropertiesList) + ; + +dbPropertiesList +@init { pushMsg("database properties list", state); } +@after { popMsg(state); } + : + keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_DBPROPLIST keyValueProperty+) + ; + + +switchDatabaseStatement +@init { pushMsg("switch database statement", state); } +@after { popMsg(state); } + : KW_USE identifier + -> ^(TOK_SWITCHDATABASE identifier) + ; + +dropDatabaseStatement +@init { pushMsg("drop database statement", state); } +@after { popMsg(state); } + : KW_DROP (KW_DATABASE|KW_SCHEMA) ifExists? identifier restrictOrCascade? + -> ^(TOK_DROPDATABASE identifier ifExists? restrictOrCascade?) + ; + +databaseComment +@init { pushMsg("database's comment", state); } +@after { popMsg(state); } + : KW_COMMENT comment=StringLiteral + -> ^(TOK_DATABASECOMMENT $comment) + ; + +createTableStatement +@init { pushMsg("create table statement", state); } +@after { popMsg(state); } + : KW_CREATE (temp=KW_TEMPORARY)? (trans=KW_TRANSACTIONAL)? (ext=KW_EXTERNAL)? KW_TABLE ifNotExists? name=tableName + ( like=KW_LIKE likeName=tableName + tableRowFormat? + tableFileFormat? + tableLocation? + tablePropertiesPrefixed? + | (LPAREN columnNameTypeOrConstraintList RPAREN)? + tableComment? + createTablePartitionSpec? + tableBuckets? + tableSkewed? + tableRowFormat? + tableFileFormat? + tableLocation? + tablePropertiesPrefixed? + (KW_AS selectStatementWithCTE)? + ) + -> ^(TOK_CREATETABLE $name $temp? $trans? $ext? ifNotExists? + ^(TOK_LIKETABLE $likeName?) + columnNameTypeOrConstraintList? + tableComment? + createTablePartitionSpec? + tableBuckets? + tableSkewed? + tableRowFormat? + tableFileFormat? + tableLocation? + tablePropertiesPrefixed? + selectStatementWithCTE? + ) + ; + +truncateTableStatement +@init { pushMsg("truncate table statement", state); } +@after { popMsg(state); } + : KW_TRUNCATE KW_TABLE? tablePartitionPrefix (KW_COLUMNS LPAREN columnNameList RPAREN)? force? + -> ^(TOK_TRUNCATETABLE tablePartitionPrefix columnNameList? force?); + +dropTableStatement +@init { pushMsg("drop statement", state); } +@after { popMsg(state); } + : KW_DROP KW_TABLE ifExists? tableName KW_PURGE? replicationClause? + -> ^(TOK_DROPTABLE tableName ifExists? KW_PURGE? replicationClause?) + ; + +alterStatement +@init { pushMsg("alter statement", state); } +@after { popMsg(state); } + : KW_ALTER KW_TABLE tableName alterTableStatementSuffix -> ^(TOK_ALTERTABLE tableName alterTableStatementSuffix) + | KW_ALTER KW_VIEW tableName KW_AS? alterViewStatementSuffix -> ^(TOK_ALTERVIEW tableName alterViewStatementSuffix) + | KW_ALTER KW_MATERIALIZED KW_VIEW tableNameTree=tableName alterMaterializedViewStatementSuffix[$tableNameTree.tree] -> alterMaterializedViewStatementSuffix + | KW_ALTER (KW_DATABASE|KW_SCHEMA) alterDatabaseStatementSuffix -> alterDatabaseStatementSuffix + ; + +alterTableStatementSuffix +@init { pushMsg("alter table statement", state); } +@after { popMsg(state); } + : (alterStatementSuffixRename[true]) => alterStatementSuffixRename[true] + | alterStatementSuffixDropPartitions[true] + | alterStatementSuffixAddPartitions[true] + | alterStatementSuffixTouch + | alterStatementSuffixArchive + | alterStatementSuffixUnArchive + | alterStatementSuffixProperties + | alterStatementSuffixSkewedby + | alterStatementSuffixExchangePartition + | alterStatementPartitionKeyType + | alterStatementSuffixDropConstraint + | alterStatementSuffixAddConstraint + | alterTblPartitionStatementSuffix[false] + | partitionSpec alterTblPartitionStatementSuffix[true] -> alterTblPartitionStatementSuffix partitionSpec + | alterStatementSuffixSetOwner + ; + +alterTblPartitionStatementSuffix[boolean partition] +@init {pushMsg("alter table partition statement suffix", state);} +@after {popMsg(state);} + : alterStatementSuffixFileFormat[partition] + | alterStatementSuffixLocation[partition] + | alterStatementSuffixMergeFiles[partition] + | alterStatementSuffixSerdeProperties[partition] + | alterStatementSuffixRenamePart + | alterStatementSuffixBucketNum[partition] + | alterTblPartitionStatementSuffixSkewedLocation + | alterStatementSuffixClusterbySortby + | alterStatementSuffixCompact + | alterStatementSuffixUpdateStatsCol[partition] + | alterStatementSuffixUpdateStats[partition] + | alterStatementSuffixRenameCol + | alterStatementSuffixAddCol + | alterStatementSuffixUpdateColumns + ; + +alterStatementPartitionKeyType +@init {msgs.push("alter partition key type"); } +@after {msgs.pop();} + : KW_PARTITION KW_COLUMN LPAREN columnNameType RPAREN + -> ^(TOK_ALTERTABLE_PARTCOLTYPE columnNameType) + ; + +alterViewStatementSuffix +@init { pushMsg("alter view statement", state); } +@after { popMsg(state); } + : alterViewSuffixProperties + | alterStatementSuffixRename[false] + | alterStatementSuffixAddPartitions[false] + | alterStatementSuffixDropPartitions[false] + | selectStatementWithCTE + ; + +alterMaterializedViewStatementSuffix[CommonTree tableNameTree] +@init { pushMsg("alter materialized view statement", state); } +@after { popMsg(state); } + : alterMaterializedViewSuffixRewrite[tableNameTree] + | alterMaterializedViewSuffixRebuild[tableNameTree] + ; + +alterMaterializedViewSuffixRewrite[CommonTree tableNameTree] +@init { pushMsg("alter materialized view rewrite statement", state); } +@after { popMsg(state); } + : (mvRewriteFlag=rewriteEnabled | mvRewriteFlag=rewriteDisabled) + -> ^(TOK_ALTER_MATERIALIZED_VIEW_REWRITE {$tableNameTree} $mvRewriteFlag) + ; + +alterMaterializedViewSuffixRebuild[CommonTree tableNameTree] +@init { pushMsg("alter materialized view rebuild statement", state); } +@after { popMsg(state); } + : KW_REBUILD -> ^(TOK_ALTER_MATERIALIZED_VIEW_REBUILD {$tableNameTree}) + ; + +alterDatabaseStatementSuffix +@init { pushMsg("alter database statement", state); } +@after { popMsg(state); } + : alterDatabaseSuffixProperties + | alterDatabaseSuffixSetOwner + | alterDatabaseSuffixSetLocation + ; + +alterDatabaseSuffixProperties +@init { pushMsg("alter database properties statement", state); } +@after { popMsg(state); } + : name=identifier KW_SET KW_DBPROPERTIES dbProperties + -> ^(TOK_ALTERDATABASE_PROPERTIES $name dbProperties) + ; + +alterDatabaseSuffixSetOwner +@init { pushMsg("alter database set owner", state); } +@after { popMsg(state); } + : dbName=identifier KW_SET KW_OWNER principalName + -> ^(TOK_ALTERDATABASE_OWNER $dbName principalName) + ; + +alterDatabaseSuffixSetLocation +@init { pushMsg("alter database set location", state); } +@after { popMsg(state); } + : dbName=identifier KW_SET KW_LOCATION newLocation=StringLiteral + -> ^(TOK_ALTERDATABASE_LOCATION $dbName $newLocation) + | dbName=identifier KW_SET KW_MANAGEDLOCATION newLocation=StringLiteral + -> ^(TOK_ALTERDATABASE_MANAGEDLOCATION $dbName $newLocation) + ; + +alterDatabaseSuffixSetManagedLocation +@init { pushMsg("alter database set managed location", state); } +@after { popMsg(state); } + : dbName=identifier KW_SET KW_MANAGEDLOCATION newLocation=StringLiteral + -> ^(TOK_ALTERDATABASE_MANAGEDLOCATION $dbName $newLocation) + ; + +alterStatementSuffixRename[boolean table] +@init { pushMsg("rename statement", state); } +@after { popMsg(state); } + : KW_RENAME KW_TO tableName + -> { table }? ^(TOK_ALTERTABLE_RENAME tableName) + -> ^(TOK_ALTERVIEW_RENAME tableName) + ; + +alterStatementSuffixAddCol +@init { pushMsg("add column statement", state); } +@after { popMsg(state); } + : (add=KW_ADD | replace=KW_REPLACE) KW_COLUMNS LPAREN columnNameTypeList RPAREN restrictOrCascade? + -> {$add != null}? ^(TOK_ALTERTABLE_ADDCOLS columnNameTypeList restrictOrCascade?) + -> ^(TOK_ALTERTABLE_REPLACECOLS columnNameTypeList restrictOrCascade?) + ; + +alterStatementSuffixAddConstraint +@init { pushMsg("add constraint statement", state); } +@after { popMsg(state); } + : KW_ADD (fk=alterForeignKeyWithName | alterConstraintWithName) + -> {fk != null}? ^(TOK_ALTERTABLE_ADDCONSTRAINT alterForeignKeyWithName) + -> ^(TOK_ALTERTABLE_ADDCONSTRAINT alterConstraintWithName) + ; + +alterStatementSuffixUpdateColumns +@init { pushMsg("update columns statement", state); } +@after { popMsg(state); } + : KW_UPDATE KW_COLUMNS restrictOrCascade? + -> ^(TOK_ALTERTABLE_UPDATECOLUMNS restrictOrCascade?) + ; + +alterStatementSuffixDropConstraint +@init { pushMsg("drop constraint statement", state); } +@after { popMsg(state); } + : KW_DROP KW_CONSTRAINT cName=identifier + ->^(TOK_ALTERTABLE_DROPCONSTRAINT $cName) + ; + +alterStatementSuffixRenameCol +@init { pushMsg("rename column name", state); } +@after { popMsg(state); } + : KW_CHANGE KW_COLUMN? oldName=identifier newName=identifier colType alterColumnConstraint[$newName.tree]? (KW_COMMENT comment=StringLiteral)? alterStatementChangeColPosition? restrictOrCascade? + ->^(TOK_ALTERTABLE_RENAMECOL $oldName $newName colType $comment? alterColumnConstraint? alterStatementChangeColPosition? restrictOrCascade?) + ; + +alterStatementSuffixUpdateStatsCol[boolean partition] +@init { pushMsg("update column statistics", state); } +@after { popMsg(state); } + : KW_UPDATE KW_STATISTICS KW_FOR KW_COLUMN? colName=identifier KW_SET tableProperties (KW_COMMENT comment=StringLiteral)? + -> {partition}? ^(TOK_ALTERPARTITION_UPDATECOLSTATS $colName tableProperties $comment?) + -> ^(TOK_ALTERTABLE_UPDATECOLSTATS $colName tableProperties $comment?) + ; + +alterStatementSuffixUpdateStats[boolean partition] +@init { pushMsg("update basic statistics", state); } +@after { popMsg(state); } + : KW_UPDATE KW_STATISTICS KW_SET tableProperties + -> {partition}? ^(TOK_ALTERPARTITION_UPDATESTATS tableProperties) + -> ^(TOK_ALTERTABLE_UPDATESTATS tableProperties) + ; + +alterStatementChangeColPosition + : first=KW_FIRST|KW_AFTER afterCol=identifier + ->{$first != null}? ^(TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION ) + -> ^(TOK_ALTERTABLE_CHANGECOL_AFTER_POSITION $afterCol) + ; + +alterStatementSuffixAddPartitions[boolean table] +@init { pushMsg("add partition statement", state); } +@after { popMsg(state); } + : KW_ADD ifNotExists? alterStatementSuffixAddPartitionsElement+ + -> { table }? ^(TOK_ALTERTABLE_ADDPARTS ifNotExists? alterStatementSuffixAddPartitionsElement+) + -> ^(TOK_ALTERVIEW_ADDPARTS ifNotExists? alterStatementSuffixAddPartitionsElement+) + ; + +alterStatementSuffixAddPartitionsElement + : partitionSpec partitionLocation? + ; + +alterStatementSuffixTouch +@init { pushMsg("touch statement", state); } +@after { popMsg(state); } + : KW_TOUCH (partitionSpec)* + -> ^(TOK_ALTERTABLE_TOUCH (partitionSpec)*) + ; + +alterStatementSuffixArchive +@init { pushMsg("archive statement", state); } +@after { popMsg(state); } + : KW_ARCHIVE (partitionSpec)* + -> ^(TOK_ALTERTABLE_ARCHIVE (partitionSpec)*) + ; + +alterStatementSuffixUnArchive +@init { pushMsg("unarchive statement", state); } +@after { popMsg(state); } + : KW_UNARCHIVE (partitionSpec)* + -> ^(TOK_ALTERTABLE_UNARCHIVE (partitionSpec)*) + ; + +partitionLocation +@init { pushMsg("partition location", state); } +@after { popMsg(state); } + : + KW_LOCATION locn=StringLiteral -> ^(TOK_PARTITIONLOCATION $locn) + ; + +alterStatementSuffixDropPartitions[boolean table] +@init { pushMsg("drop partition statement", state); } +@after { popMsg(state); } + : KW_DROP ifExists? dropPartitionSpec (COMMA dropPartitionSpec)* KW_PURGE? replicationClause? + -> { table }? ^(TOK_ALTERTABLE_DROPPARTS dropPartitionSpec+ ifExists? KW_PURGE? replicationClause?) + -> ^(TOK_ALTERVIEW_DROPPARTS dropPartitionSpec+ ifExists? replicationClause?) + ; + +alterStatementSuffixProperties +@init { pushMsg("alter properties statement", state); } +@after { popMsg(state); } + : KW_SET KW_TBLPROPERTIES tableProperties + -> ^(TOK_ALTERTABLE_PROPERTIES tableProperties) + | KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties + -> ^(TOK_ALTERTABLE_DROPPROPERTIES tableProperties ifExists?) + ; + +alterViewSuffixProperties +@init { pushMsg("alter view properties statement", state); } +@after { popMsg(state); } + : KW_SET KW_TBLPROPERTIES tableProperties + -> ^(TOK_ALTERVIEW_PROPERTIES tableProperties) + | KW_UNSET KW_TBLPROPERTIES ifExists? tableProperties + -> ^(TOK_ALTERVIEW_DROPPROPERTIES tableProperties ifExists?) + ; + +alterStatementSuffixSerdeProperties[boolean partition] +@init { pushMsg("alter serdes statement", state); } +@after { popMsg(state); } + : KW_SET KW_SERDE serdeName=StringLiteral (KW_WITH KW_SERDEPROPERTIES tableProperties)? + -> {partition}? ^(TOK_ALTERPARTITION_SERIALIZER $serdeName tableProperties?) + -> ^(TOK_ALTERTABLE_SERIALIZER $serdeName tableProperties?) + | KW_SET KW_SERDEPROPERTIES tableProperties + -> {partition}? ^(TOK_ALTERPARTITION_SERDEPROPERTIES tableProperties) + -> ^(TOK_ALTERTABLE_SERDEPROPERTIES tableProperties) + ; + +tablePartitionPrefix +@init {pushMsg("table partition prefix", state);} +@after {popMsg(state);} + : tableName partitionSpec? + ->^(TOK_TABLE_PARTITION tableName partitionSpec?) + ; + +alterStatementSuffixFileFormat[boolean partition] +@init {pushMsg("alter fileformat statement", state); } +@after {popMsg(state);} + : KW_SET KW_FILEFORMAT fileFormat + -> {partition}? ^(TOK_ALTERPARTITION_FILEFORMAT fileFormat) + -> ^(TOK_ALTERTABLE_FILEFORMAT fileFormat) + ; + +alterStatementSuffixClusterbySortby +@init {pushMsg("alter partition cluster by sort by statement", state);} +@after {popMsg(state);} + : KW_NOT KW_CLUSTERED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_CLUSTERED) + | KW_NOT KW_SORTED -> ^(TOK_ALTERTABLE_CLUSTER_SORT TOK_NOT_SORTED) + | tableBuckets -> ^(TOK_ALTERTABLE_CLUSTER_SORT tableBuckets) + ; + +alterTblPartitionStatementSuffixSkewedLocation +@init {pushMsg("alter partition skewed location", state);} +@after {popMsg(state);} + : KW_SET KW_SKEWED KW_LOCATION skewedLocations + -> ^(TOK_ALTERTABLE_SKEWED_LOCATION skewedLocations) + ; + +skewedLocations +@init { pushMsg("skewed locations", state); } +@after { popMsg(state); } + : + LPAREN skewedLocationsList RPAREN -> ^(TOK_SKEWED_LOCATIONS skewedLocationsList) + ; + +skewedLocationsList +@init { pushMsg("skewed locations list", state); } +@after { popMsg(state); } + : + skewedLocationMap (COMMA skewedLocationMap)* -> ^(TOK_SKEWED_LOCATION_LIST skewedLocationMap+) + ; + +skewedLocationMap +@init { pushMsg("specifying skewed location map", state); } +@after { popMsg(state); } + : + key=skewedValueLocationElement EQUAL value=StringLiteral -> ^(TOK_SKEWED_LOCATION_MAP $key $value) + ; + +alterStatementSuffixLocation[boolean partition] +@init {pushMsg("alter location", state);} +@after {popMsg(state);} + : KW_SET KW_LOCATION newLoc=StringLiteral + -> {partition}? ^(TOK_ALTERPARTITION_LOCATION $newLoc) + -> ^(TOK_ALTERTABLE_LOCATION $newLoc) + ; + + +alterStatementSuffixSkewedby +@init {pushMsg("alter skewed by statement", state);} +@after{popMsg(state);} + : tableSkewed + ->^(TOK_ALTERTABLE_SKEWED tableSkewed) + | + KW_NOT KW_SKEWED + ->^(TOK_ALTERTABLE_SKEWED) + | + KW_NOT storedAsDirs + ->^(TOK_ALTERTABLE_SKEWED storedAsDirs) + ; + +alterStatementSuffixExchangePartition +@init {pushMsg("alter exchange partition", state);} +@after{popMsg(state);} + : KW_EXCHANGE partitionSpec KW_WITH KW_TABLE exchangename=tableName + -> ^(TOK_ALTERTABLE_EXCHANGEPARTITION partitionSpec $exchangename) + ; + +alterStatementSuffixRenamePart +@init { pushMsg("alter table rename partition statement", state); } +@after { popMsg(state); } + : KW_RENAME KW_TO partitionSpec + ->^(TOK_ALTERTABLE_RENAMEPART partitionSpec) + ; + +alterStatementSuffixStatsPart +@init { pushMsg("alter table stats partition statement", state); } +@after { popMsg(state); } + : KW_UPDATE KW_STATISTICS KW_FOR KW_COLUMN? colName=identifier KW_SET tableProperties (KW_COMMENT comment=StringLiteral)? + ->^(TOK_ALTERTABLE_UPDATECOLSTATS $colName tableProperties $comment?) + ; + +alterStatementSuffixMergeFiles[boolean partition] +@init { pushMsg("", state); } +@after { popMsg(state); } + : KW_CONCATENATE + -> {partition}? ^(TOK_ALTERPARTITION_MERGEFILES) + -> ^(TOK_ALTERTABLE_MERGEFILES) + ; + +alterStatementSuffixBucketNum[boolean partition] +@init { pushMsg("", state); } +@after { popMsg(state); } + : KW_INTO num=Number KW_BUCKETS + -> {partition}? ^(TOK_ALTERPARTITION_BUCKETS $num) + -> ^(TOK_ALTERTABLE_BUCKETS $num) + ; + +blocking + : KW_AND KW_WAIT + -> TOK_BLOCKING + ; + +alterStatementSuffixCompact +@init { msgs.push("compaction request"); } +@after { msgs.pop(); } + : KW_COMPACT compactType=StringLiteral blocking? (KW_WITH KW_OVERWRITE KW_TBLPROPERTIES tableProperties)? + -> ^(TOK_ALTERTABLE_COMPACT $compactType blocking? tableProperties?) + ; + +alterStatementSuffixSetOwner +@init { pushMsg("alter table set owner", state); } +@after { popMsg(state); } + : KW_SET KW_OWNER principalName + -> ^(TOK_ALTERTABLE_OWNER principalName) + ; + +fileFormat +@init { pushMsg("file format specification", state); } +@after { popMsg(state); } + : KW_INPUTFORMAT inFmt=StringLiteral KW_OUTPUTFORMAT outFmt=StringLiteral KW_SERDE serdeCls=StringLiteral (KW_INPUTDRIVER inDriver=StringLiteral KW_OUTPUTDRIVER outDriver=StringLiteral)? + -> ^(TOK_TABLEFILEFORMAT $inFmt $outFmt $serdeCls $inDriver? $outDriver?) + | genericSpec=identifier -> ^(TOK_FILEFORMAT_GENERIC $genericSpec) + ; + +inputFileFormat +@init { pushMsg("Load Data input file format specification", state); } +@after { popMsg(state); } + : KW_INPUTFORMAT inFmt=StringLiteral KW_SERDE serdeCls=StringLiteral + -> ^(TOK_INPUTFORMAT $inFmt $serdeCls) + ; + +tabTypeExpr +@init { pushMsg("specifying table types", state); } +@after { popMsg(state); } + : identifier (DOT^ identifier)? + (identifier (DOT^ + ( + (KW_ELEM_TYPE) => KW_ELEM_TYPE + | + (KW_KEY_TYPE) => KW_KEY_TYPE + | + (KW_VALUE_TYPE) => KW_VALUE_TYPE + | identifier + ))* + )? + ; + +partTypeExpr +@init { pushMsg("specifying table partitions", state); } +@after { popMsg(state); } + : tabTypeExpr partitionSpec? -> ^(TOK_TABTYPE tabTypeExpr partitionSpec?) + ; + +tabPartColTypeExpr +@init { pushMsg("specifying table partitions columnName", state); } +@after { popMsg(state); } + : tableName partitionSpec? extColumnName? -> ^(TOK_TABTYPE tableName partitionSpec? extColumnName?) + ; + +descStatement +@init { pushMsg("describe statement", state); } +@after { popMsg(state); } + : + (KW_DESCRIBE|KW_DESC) + ( + (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) KW_EXTENDED? (dbName=identifier) -> ^(TOK_DESCDATABASE $dbName KW_EXTENDED?) + | + (KW_FUNCTION) => KW_FUNCTION KW_EXTENDED? (name=descFuncNames) -> ^(TOK_DESCFUNCTION $name KW_EXTENDED?) + | + (KW_FORMATTED|KW_EXTENDED) => ((descOptions=KW_FORMATTED|descOptions=KW_EXTENDED) parttype=tabPartColTypeExpr) -> ^(TOK_DESCTABLE $parttype $descOptions) + | + parttype=tabPartColTypeExpr -> ^(TOK_DESCTABLE $parttype) + ) + ; + +analyzeStatement +@init { pushMsg("analyze statement", state); } +@after { popMsg(state); } + : KW_ANALYZE KW_TABLE (parttype=tableOrPartition) + ( + (KW_COMPUTE) => KW_COMPUTE KW_STATISTICS ((noscan=KW_NOSCAN) + | (KW_FOR KW_COLUMNS (statsColumnName=columnNameList)?))? + -> ^(TOK_ANALYZE $parttype $noscan? KW_COLUMNS? $statsColumnName?) + | + (KW_CACHE) => KW_CACHE KW_METADATA -> ^(TOK_CACHE_METADATA $parttype) + ) + ; + +showStatement +@init { pushMsg("show statement", state); } +@after { popMsg(state); } + : KW_SHOW (KW_DATABASES|KW_SCHEMAS) (KW_LIKE showStmtIdentifier)? -> ^(TOK_SHOWDATABASES showStmtIdentifier?) + | KW_SHOW (isExtended=KW_EXTENDED)? KW_TABLES ((KW_FROM|KW_IN) db_name=identifier)? (filter=showTablesFilterExpr)? + -> ^(TOK_SHOWTABLES (TOK_FROM $db_name)? $filter? $isExtended?) + | KW_SHOW KW_VIEWS ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? -> ^(TOK_SHOWVIEWS (TOK_FROM $db_name)? showStmtIdentifier?) + | KW_SHOW KW_MATERIALIZED KW_VIEWS ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? -> ^(TOK_SHOWMATERIALIZEDVIEWS (TOK_FROM $db_name)? showStmtIdentifier?) + | KW_SHOW KW_COLUMNS (KW_FROM|KW_IN) tableName ((KW_FROM|KW_IN) db_name=identifier)? (KW_LIKE showStmtIdentifier|showStmtIdentifier)? + -> ^(TOK_SHOWCOLUMNS tableName (TOK_FROM $db_name)? showStmtIdentifier?) + | KW_SHOW KW_FUNCTIONS (KW_LIKE showFunctionIdentifier)? -> ^(TOK_SHOWFUNCTIONS KW_LIKE? showFunctionIdentifier?) + | KW_SHOW KW_PARTITIONS tabName=tableName partitionSpec? -> ^(TOK_SHOWPARTITIONS $tabName partitionSpec?) + | KW_SHOW KW_CREATE ( + (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) db_name=identifier -> ^(TOK_SHOW_CREATEDATABASE $db_name) + | + KW_TABLE tabName=tableName -> ^(TOK_SHOW_CREATETABLE $tabName) + ) + | KW_SHOW KW_TABLE KW_EXTENDED ((KW_FROM|KW_IN) db_name=identifier)? KW_LIKE showStmtIdentifier partitionSpec? + -> ^(TOK_SHOW_TABLESTATUS showStmtIdentifier $db_name? partitionSpec?) + | KW_SHOW KW_TBLPROPERTIES tableName (LPAREN prptyName=StringLiteral RPAREN)? -> ^(TOK_SHOW_TBLPROPERTIES tableName $prptyName?) + | KW_SHOW KW_LOCKS + ( + (KW_DATABASE|KW_SCHEMA) => (KW_DATABASE|KW_SCHEMA) (dbName=identifier) (isExtended=KW_EXTENDED)? -> ^(TOK_SHOWDBLOCKS $dbName $isExtended?) + | + (parttype=partTypeExpr)? (isExtended=KW_EXTENDED)? -> ^(TOK_SHOWLOCKS $parttype? $isExtended?) + ) + | KW_SHOW KW_COMPACTIONS -> ^(TOK_SHOW_COMPACTIONS) + | KW_SHOW KW_TRANSACTIONS -> ^(TOK_SHOW_TRANSACTIONS) + | KW_SHOW KW_CONF StringLiteral -> ^(TOK_SHOWCONF StringLiteral) + | KW_SHOW KW_RESOURCE + ( + (KW_PLAN rp_name=identifier -> ^(TOK_SHOW_RP $rp_name)) + | (KW_PLANS -> ^(TOK_SHOW_RP)) + ) + ; + +showTablesFilterExpr +@init { pushMsg("show tables filter expr", state); } +@after { popMsg(state); } + : KW_WHERE identifier EQUAL StringLiteral + -> ^(TOK_TABLE_TYPE identifier StringLiteral) + | KW_LIKE showStmtIdentifier|showStmtIdentifier + -> showStmtIdentifier + ; + +lockStatement +@init { pushMsg("lock statement", state); } +@after { popMsg(state); } + : KW_LOCK KW_TABLE tableName partitionSpec? lockMode -> ^(TOK_LOCKTABLE tableName lockMode partitionSpec?) + ; + +lockDatabase +@init { pushMsg("lock database statement", state); } +@after { popMsg(state); } + : KW_LOCK (KW_DATABASE|KW_SCHEMA) (dbName=identifier) lockMode -> ^(TOK_LOCKDB $dbName lockMode) + ; + +lockMode +@init { pushMsg("lock mode", state); } +@after { popMsg(state); } + : KW_SHARED | KW_EXCLUSIVE + ; + +unlockStatement +@init { pushMsg("unlock statement", state); } +@after { popMsg(state); } + : KW_UNLOCK KW_TABLE tableName partitionSpec? -> ^(TOK_UNLOCKTABLE tableName partitionSpec?) + ; + +unlockDatabase +@init { pushMsg("unlock database statement", state); } +@after { popMsg(state); } + : KW_UNLOCK (KW_DATABASE|KW_SCHEMA) (dbName=identifier) -> ^(TOK_UNLOCKDB $dbName) + ; + +createRoleStatement +@init { pushMsg("create role", state); } +@after { popMsg(state); } + : KW_CREATE KW_ROLE roleName=identifier + -> ^(TOK_CREATEROLE $roleName) + ; + +dropRoleStatement +@init {pushMsg("drop role", state);} +@after {popMsg(state);} + : KW_DROP KW_ROLE roleName=identifier + -> ^(TOK_DROPROLE $roleName) + ; + +grantPrivileges +@init {pushMsg("grant privileges", state);} +@after {popMsg(state);} + : KW_GRANT privList=privilegeList + privilegeObject? + KW_TO principalSpecification + withGrantOption? + -> ^(TOK_GRANT $privList principalSpecification privilegeObject? withGrantOption?) + ; + +revokePrivileges +@init {pushMsg("revoke privileges", state);} +@afer {popMsg(state);} + : KW_REVOKE grantOptionFor? privilegeList privilegeObject? KW_FROM principalSpecification + -> ^(TOK_REVOKE privilegeList principalSpecification privilegeObject? grantOptionFor?) + ; + +grantRole +@init {pushMsg("grant role", state);} +@after {popMsg(state);} + : KW_GRANT KW_ROLE? identifier (COMMA identifier)* KW_TO principalSpecification withAdminOption? + -> ^(TOK_GRANT_ROLE principalSpecification withAdminOption? identifier+) + ; + +revokeRole +@init {pushMsg("revoke role", state);} +@after {popMsg(state);} + : KW_REVOKE adminOptionFor? KW_ROLE? identifier (COMMA identifier)* KW_FROM principalSpecification + -> ^(TOK_REVOKE_ROLE principalSpecification adminOptionFor? identifier+) + ; + +showRoleGrants +@init {pushMsg("show role grants", state);} +@after {popMsg(state);} + : KW_SHOW KW_ROLE KW_GRANT principalName + -> ^(TOK_SHOW_ROLE_GRANT principalName) + ; + + +showRoles +@init {pushMsg("show roles", state);} +@after {popMsg(state);} + : KW_SHOW KW_ROLES + -> ^(TOK_SHOW_ROLES) + ; + +showCurrentRole +@init {pushMsg("show current role", state);} +@after {popMsg(state);} + : KW_SHOW KW_CURRENT KW_ROLES + -> ^(TOK_SHOW_CURRENT_ROLE) + ; + +setRole +@init {pushMsg("set role", state);} +@after {popMsg(state);} + : KW_SET KW_ROLE + ( + (KW_ALL) => (all=KW_ALL) -> ^(TOK_SET_ROLE Identifier[$all.text]) + | + (KW_NONE) => (none=KW_NONE) -> ^(TOK_SET_ROLE Identifier[$none.text]) + | + identifier -> ^(TOK_SET_ROLE identifier) + ) + ; + +showGrants +@init {pushMsg("show grants", state);} +@after {popMsg(state);} + : KW_SHOW KW_GRANT principalName? (KW_ON privilegeIncludeColObject)? + -> ^(TOK_SHOW_GRANT principalName? privilegeIncludeColObject?) + ; + +showRolePrincipals +@init {pushMsg("show role principals", state);} +@after {popMsg(state);} + : KW_SHOW KW_PRINCIPALS roleName=identifier + -> ^(TOK_SHOW_ROLE_PRINCIPALS $roleName) + ; + + +privilegeIncludeColObject +@init {pushMsg("privilege object including columns", state);} +@after {popMsg(state);} + : (KW_ALL) => KW_ALL -> ^(TOK_RESOURCE_ALL) + | privObjectCols -> ^(TOK_PRIV_OBJECT_COL privObjectCols) + ; + +privilegeObject +@init {pushMsg("privilege object", state);} +@after {popMsg(state);} + : KW_ON privObject -> ^(TOK_PRIV_OBJECT privObject) + ; + +// database or table type. Type is optional, default type is table +privObject + : (KW_DATABASE|KW_SCHEMA) identifier -> ^(TOK_DB_TYPE identifier) + | KW_TABLE? tableName partitionSpec? -> ^(TOK_TABLE_TYPE tableName partitionSpec?) + | KW_URI (path=StringLiteral) -> ^(TOK_URI_TYPE $path) + | KW_SERVER identifier -> ^(TOK_SERVER_TYPE identifier) + ; + +privObjectCols + : (KW_DATABASE|KW_SCHEMA) identifier -> ^(TOK_DB_TYPE identifier) + | KW_TABLE? tableName (LPAREN cols=columnNameList RPAREN)? partitionSpec? -> ^(TOK_TABLE_TYPE tableName $cols? partitionSpec?) + | KW_URI (path=StringLiteral) -> ^(TOK_URI_TYPE $path) + | KW_SERVER identifier -> ^(TOK_SERVER_TYPE identifier) + ; + +privilegeList +@init {pushMsg("grant privilege list", state);} +@after {popMsg(state);} + : privlegeDef (COMMA privlegeDef)* + -> ^(TOK_PRIVILEGE_LIST privlegeDef+) + ; + +privlegeDef +@init {pushMsg("grant privilege", state);} +@after {popMsg(state);} + : privilegeType (LPAREN cols=columnNameList RPAREN)? + -> ^(TOK_PRIVILEGE privilegeType $cols?) + ; + +privilegeType +@init {pushMsg("privilege type", state);} +@after {popMsg(state);} + : KW_ALL -> ^(TOK_PRIV_ALL) + | KW_ALTER -> ^(TOK_PRIV_ALTER_METADATA) + | KW_UPDATE -> ^(TOK_PRIV_ALTER_DATA) + | KW_CREATE -> ^(TOK_PRIV_CREATE) + | KW_DROP -> ^(TOK_PRIV_DROP) + | KW_LOCK -> ^(TOK_PRIV_LOCK) + | KW_SELECT -> ^(TOK_PRIV_SELECT) + | KW_SHOW_DATABASE -> ^(TOK_PRIV_SHOW_DATABASE) + | KW_INSERT -> ^(TOK_PRIV_INSERT) + | KW_DELETE -> ^(TOK_PRIV_DELETE) + ; + +principalSpecification +@init { pushMsg("user/group/role name list", state); } +@after { popMsg(state); } + : principalName (COMMA principalName)* -> ^(TOK_PRINCIPAL_NAME principalName+) + ; + +principalName +@init {pushMsg("user|group|role name", state);} +@after {popMsg(state);} + : KW_USER principalIdentifier -> ^(TOK_USER principalIdentifier) + | KW_GROUP principalIdentifier -> ^(TOK_GROUP principalIdentifier) + | KW_ROLE identifier -> ^(TOK_ROLE identifier) + ; + +withGrantOption +@init {pushMsg("with grant option", state);} +@after {popMsg(state);} + : KW_WITH KW_GRANT KW_OPTION + -> ^(TOK_GRANT_WITH_OPTION) + ; + +grantOptionFor +@init {pushMsg("grant option for", state);} +@after {popMsg(state);} + : KW_GRANT KW_OPTION KW_FOR + -> ^(TOK_GRANT_OPTION_FOR) +; + +adminOptionFor +@init {pushMsg("admin option for", state);} +@after {popMsg(state);} + : KW_ADMIN KW_OPTION KW_FOR + -> ^(TOK_ADMIN_OPTION_FOR) +; + +withAdminOption +@init {pushMsg("with admin option", state);} +@after {popMsg(state);} + : KW_WITH KW_ADMIN KW_OPTION + -> ^(TOK_GRANT_WITH_ADMIN_OPTION) + ; + +metastoreCheck +@init { pushMsg("metastore check statement", state); } +@after { popMsg(state); } + : KW_MSCK (repair=KW_REPAIR)? + (KW_TABLE tableName + ((add=KW_ADD | drop=KW_DROP | sync=KW_SYNC) (parts=KW_PARTITIONS))? | + (partitionSpec)?) + -> ^(TOK_MSCK $repair? tableName? $add? $drop? $sync? (partitionSpec*)?) + ; + +resourceList +@init { pushMsg("resource list", state); } +@after { popMsg(state); } + : + resource (COMMA resource)* -> ^(TOK_RESOURCE_LIST resource+) + ; + +resource +@init { pushMsg("resource", state); } +@after { popMsg(state); } + : + resType=resourceType resPath=StringLiteral -> ^(TOK_RESOURCE_URI $resType $resPath) + ; + +resourceType +@init { pushMsg("resource type", state); } +@after { popMsg(state); } + : + KW_JAR -> ^(TOK_JAR) + | + KW_FILE -> ^(TOK_FILE) + | + KW_ARCHIVE -> ^(TOK_ARCHIVE) + ; + +createFunctionStatement +@init { pushMsg("create function statement", state); } +@after { popMsg(state); } + : KW_CREATE (temp=KW_TEMPORARY)? KW_FUNCTION functionIdentifier KW_AS StringLiteral + (KW_USING rList=resourceList)? + -> {$temp != null}? ^(TOK_CREATEFUNCTION functionIdentifier StringLiteral $rList? TOK_TEMPORARY) + -> ^(TOK_CREATEFUNCTION functionIdentifier StringLiteral $rList?) + ; + +dropFunctionStatement +@init { pushMsg("drop function statement", state); } +@after { popMsg(state); } + : KW_DROP (temp=KW_TEMPORARY)? KW_FUNCTION ifExists? functionIdentifier + -> {$temp != null}? ^(TOK_DROPFUNCTION functionIdentifier ifExists? TOK_TEMPORARY) + -> ^(TOK_DROPFUNCTION functionIdentifier ifExists?) + ; + +reloadFunctionsStatement +@init { pushMsg("reload functions statement", state); } +@after { popMsg(state); } + : KW_RELOAD (KW_FUNCTIONS|KW_FUNCTION) -> ^(TOK_RELOADFUNCTIONS); + +createMacroStatement +@init { pushMsg("create macro statement", state); } +@after { popMsg(state); } + : KW_CREATE KW_TEMPORARY KW_MACRO Identifier + LPAREN columnNameTypeList? RPAREN expression + -> ^(TOK_CREATEMACRO Identifier columnNameTypeList? expression) + ; + +dropMacroStatement +@init { pushMsg("drop macro statement", state); } +@after { popMsg(state); } + : KW_DROP KW_TEMPORARY KW_MACRO ifExists? Identifier + -> ^(TOK_DROPMACRO Identifier ifExists?) + ; + +createViewStatement +@init { + pushMsg("create view statement", state); +} +@after { popMsg(state); } + : KW_CREATE (orReplace)? KW_VIEW (ifNotExists)? name=tableName + (LPAREN columnNameCommentList RPAREN)? tableComment? viewPartition? + tablePropertiesPrefixed? + KW_AS + selectStatementWithCTE + -> ^(TOK_CREATEVIEW $name orReplace? + ifNotExists? + columnNameCommentList? + tableComment? + viewPartition? + tablePropertiesPrefixed? + selectStatementWithCTE + ) + ; + +viewPartition +@init { pushMsg("view partition specification", state); } +@after { popMsg(state); } + : KW_PARTITIONED KW_ON LPAREN columnNameList RPAREN + -> ^(TOK_VIEWPARTCOLS columnNameList) + ; + +viewOrganization +@init { pushMsg("view organization specification", state); } +@after { popMsg(state); } + : viewClusterSpec + | viewComplexSpec + ; + +viewClusterSpec +@init { pushMsg("view cluster specification", state); } +@after { popMsg(state); } + : KW_CLUSTERED KW_ON LPAREN columnNameList RPAREN + -> ^(TOK_VIEWCLUSTERCOLS columnNameList) + ; + +viewComplexSpec +@init { pushMsg("view complex specification", state); } +@after { popMsg(state); } + : viewDistSpec viewSortSpec + ; + +viewDistSpec +@init { pushMsg("view distribute specification", state); } +@after { popMsg(state); } + : KW_DISTRIBUTED KW_ON LPAREN colList=columnNameList RPAREN + -> ^(TOK_VIEWDISTRIBUTECOLS $colList) + ; + +viewSortSpec +@init { pushMsg("view sort specification", state); } +@after { popMsg(state); } + : KW_SORTED KW_ON LPAREN colList=columnNameList RPAREN + -> ^(TOK_VIEWSORTCOLS $colList) + ; + +dropViewStatement +@init { pushMsg("drop view statement", state); } +@after { popMsg(state); } + : KW_DROP KW_VIEW ifExists? viewName -> ^(TOK_DROPVIEW viewName ifExists?) + ; + +createMaterializedViewStatement +@init { + pushMsg("create materialized view statement", state); +} +@after { popMsg(state); } + : KW_CREATE KW_MATERIALIZED KW_VIEW (ifNotExists)? name=tableName + rewriteDisabled? tableComment? viewPartition? viewOrganization? + tableRowFormat? tableFileFormat? tableLocation? + tablePropertiesPrefixed? KW_AS selectStatementWithCTE + -> ^(TOK_CREATE_MATERIALIZED_VIEW $name + ifNotExists? + rewriteDisabled? + tableComment? + tableRowFormat? + tableFileFormat? + tableLocation? + viewPartition? + viewOrganization? + tablePropertiesPrefixed? + selectStatementWithCTE + ) + ; + +dropMaterializedViewStatement +@init { pushMsg("drop materialized view statement", state); } +@after { popMsg(state); } + : KW_DROP KW_MATERIALIZED KW_VIEW ifExists? viewName -> ^(TOK_DROP_MATERIALIZED_VIEW viewName ifExists?) + ; + +createScheduledQueryStatement +@init { pushMsg("create scheduled query statement", state); } +@after { popMsg(state); } + : KW_CREATE KW_SCHEDULED KW_QUERY name=identifier + scheduleSpec + executedAsSpec? + enableSpecification? + definedAsSpec + -> ^(TOK_CREATE_SCHEDULED_QUERY + $name + scheduleSpec + executedAsSpec? + enableSpecification? + definedAsSpec + ) + ; + +dropScheduledQueryStatement +@init { pushMsg("drop scheduled query statement", state); } +@after { popMsg(state); } + : KW_DROP KW_SCHEDULED KW_QUERY name=identifier + -> ^(TOK_DROP_SCHEDULED_QUERY + $name + ) + ; + + +alterScheduledQueryStatement +@init { pushMsg("alter scheduled query statement", state); } +@after { popMsg(state); } + : KW_ALTER KW_SCHEDULED KW_QUERY name=identifier + mod=alterScheduledQueryChange + -> ^(TOK_ALTER_SCHEDULED_QUERY + $name + $mod + ) + ; + +alterScheduledQueryChange +@init { pushMsg("alter scheduled query change", state); } +@after { popMsg(state); } + : scheduleSpec + | executedAsSpec + | enableSpecification + | definedAsSpec + | KW_EXECUTE -> ^(TOK_EXECUTE) + ; + +scheduleSpec +@init { pushMsg("schedule specification", state); } +@after { popMsg(state); } + : KW_CRON cronString=StringLiteral -> ^(TOK_CRON $cronString) + | KW_EVERY value=Number? qualifier=intervalQualifiers + ((KW_AT|KW_OFFSET KW_BY) offsetTs=StringLiteral)? -> ^(TOK_SCHEDULE ^(TOK_EVERY $value?) $qualifier $offsetTs?) + ; + +executedAsSpec +@init { pushMsg("executedAs specification", state); } +@after { popMsg(state); } + : KW_EXECUTED KW_AS executedAs=StringLiteral -> ^(TOK_EXECUTED_AS $executedAs) + ; + +definedAsSpec +@init { pushMsg("definedAs specification", state); } +@after { popMsg(state); } + : KW_DEFINED? KW_AS statement -> ^(TOK_QUERY statement) + ; + +showFunctionIdentifier +@init { pushMsg("identifier for show function statement", state); } +@after { popMsg(state); } + : functionIdentifier + | StringLiteral + ; + +showStmtIdentifier +@init { pushMsg("identifier for show statement", state); } +@after { popMsg(state); } + : identifier + | StringLiteral + ; + +tableComment +@init { pushMsg("table's comment", state); } +@after { popMsg(state); } + : + KW_COMMENT comment=StringLiteral -> ^(TOK_TABLECOMMENT $comment) + ; + +createTablePartitionSpec +@init { pushMsg("create table partition specification", state); } +@after { popMsg(state); } + : KW_PARTITIONED KW_BY LPAREN (opt1 = createTablePartitionColumnTypeSpec | opt2 = createTablePartitionColumnSpec) RPAREN + -> {$opt1.tree != null}? $opt1 + -> $opt2 + ; + +createTablePartitionColumnTypeSpec +@init { pushMsg("create table partition specification", state); } +@after { popMsg(state); } + : columnNameTypeConstraint (COMMA columnNameTypeConstraint)* + -> ^(TOK_TABLEPARTCOLS columnNameTypeConstraint+) + ; + +createTablePartitionColumnSpec +@init { pushMsg("create table partition specification", state); } +@after { popMsg(state); } + : columnName (COMMA columnName)* + -> ^(TOK_TABLEPARTCOLNAMES columnName+) + ; + +tableBuckets +@init { pushMsg("table buckets specification", state); } +@after { popMsg(state); } + : + KW_CLUSTERED KW_BY LPAREN bucketCols=columnNameList RPAREN (KW_SORTED KW_BY LPAREN sortCols=columnNameOrderList RPAREN)? KW_INTO num=Number KW_BUCKETS + -> ^(TOK_ALTERTABLE_BUCKETS $bucketCols $sortCols? $num) + ; + +tableSkewed +@init { pushMsg("table skewed specification", state); } +@after { popMsg(state); } + : + KW_SKEWED KW_BY LPAREN skewedCols=columnNameList RPAREN KW_ON LPAREN (skewedValues=skewedValueElement) RPAREN ((storedAsDirs) => storedAsDirs)? + -> ^(TOK_TABLESKEWED $skewedCols $skewedValues storedAsDirs?) + ; + +rowFormat +@init { pushMsg("serde specification", state); } +@after { popMsg(state); } + : rowFormatSerde -> ^(TOK_SERDE rowFormatSerde) + | rowFormatDelimited -> ^(TOK_SERDE rowFormatDelimited) + | -> ^(TOK_SERDE) + ; + +recordReader +@init { pushMsg("record reader specification", state); } +@after { popMsg(state); } + : KW_RECORDREADER StringLiteral -> ^(TOK_RECORDREADER StringLiteral) + | -> ^(TOK_RECORDREADER) + ; + +recordWriter +@init { pushMsg("record writer specification", state); } +@after { popMsg(state); } + : KW_RECORDWRITER StringLiteral -> ^(TOK_RECORDWRITER StringLiteral) + | -> ^(TOK_RECORDWRITER) + ; + +rowFormatSerde +@init { pushMsg("serde format specification", state); } +@after { popMsg(state); } + : KW_ROW KW_FORMAT KW_SERDE name=StringLiteral (KW_WITH KW_SERDEPROPERTIES serdeprops=tableProperties)? + -> ^(TOK_SERDENAME $name $serdeprops?) + ; + +rowFormatDelimited +@init { pushMsg("serde properties specification", state); } +@after { popMsg(state); } + : + KW_ROW KW_FORMAT KW_DELIMITED tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat? + -> ^(TOK_SERDEPROPS tableRowFormatFieldIdentifier? tableRowFormatCollItemsIdentifier? tableRowFormatMapKeysIdentifier? tableRowFormatLinesIdentifier? tableRowNullFormat?) + ; + +tableRowFormat +@init { pushMsg("table row format specification", state); } +@after { popMsg(state); } + : + rowFormatDelimited + -> ^(TOK_TABLEROWFORMAT rowFormatDelimited) + | rowFormatSerde + -> ^(TOK_TABLESERIALIZER rowFormatSerde) + ; + +tablePropertiesPrefixed +@init { pushMsg("table properties with prefix", state); } +@after { popMsg(state); } + : + KW_TBLPROPERTIES! tableProperties + ; + +tableProperties +@init { pushMsg("table properties", state); } +@after { popMsg(state); } + : + LPAREN tablePropertiesList RPAREN -> ^(TOK_TABLEPROPERTIES tablePropertiesList) + ; + +tablePropertiesList +@init { pushMsg("table properties list", state); } +@after { popMsg(state); } + : + keyValueProperty (COMMA keyValueProperty)* -> ^(TOK_TABLEPROPLIST keyValueProperty+) + | + keyProperty (COMMA keyProperty)* -> ^(TOK_TABLEPROPLIST keyProperty+) + ; + +keyValueProperty +@init { pushMsg("specifying key/value property", state); } +@after { popMsg(state); } + : + key=StringLiteral EQUAL value=StringLiteral -> ^(TOK_TABLEPROPERTY $key $value) + ; + +keyProperty +@init { pushMsg("specifying key property", state); } +@after { popMsg(state); } + : + key=StringLiteral -> ^(TOK_TABLEPROPERTY $key TOK_NULL) + ; + +tableRowFormatFieldIdentifier +@init { pushMsg("table row format's field separator", state); } +@after { popMsg(state); } + : + KW_FIELDS KW_TERMINATED KW_BY fldIdnt=StringLiteral (KW_ESCAPED KW_BY fldEscape=StringLiteral)? + -> ^(TOK_TABLEROWFORMATFIELD $fldIdnt $fldEscape?) + ; + +tableRowFormatCollItemsIdentifier +@init { pushMsg("table row format's column separator", state); } +@after { popMsg(state); } + : + KW_COLLECTION KW_ITEMS KW_TERMINATED KW_BY collIdnt=StringLiteral + -> ^(TOK_TABLEROWFORMATCOLLITEMS $collIdnt) + ; + +tableRowFormatMapKeysIdentifier +@init { pushMsg("table row format's map key separator", state); } +@after { popMsg(state); } + : + KW_MAP KW_KEYS KW_TERMINATED KW_BY mapKeysIdnt=StringLiteral + -> ^(TOK_TABLEROWFORMATMAPKEYS $mapKeysIdnt) + ; + +tableRowFormatLinesIdentifier +@init { pushMsg("table row format's line separator", state); } +@after { popMsg(state); } + : + KW_LINES KW_TERMINATED KW_BY linesIdnt=StringLiteral + -> ^(TOK_TABLEROWFORMATLINES $linesIdnt) + ; + +tableRowNullFormat +@init { pushMsg("table row format's null specifier", state); } +@after { popMsg(state); } + : + KW_NULL KW_DEFINED KW_AS nullIdnt=StringLiteral + -> ^(TOK_TABLEROWFORMATNULL $nullIdnt) + ; +tableFileFormat +@init { pushMsg("table file format specification", state); } +@after { popMsg(state); } + : + (KW_STORED KW_AS KW_INPUTFORMAT) => KW_STORED KW_AS KW_INPUTFORMAT inFmt=StringLiteral KW_OUTPUTFORMAT outFmt=StringLiteral (KW_INPUTDRIVER inDriver=StringLiteral KW_OUTPUTDRIVER outDriver=StringLiteral)? + -> ^(TOK_TABLEFILEFORMAT $inFmt $outFmt $inDriver? $outDriver?) + | KW_STORED KW_BY storageHandler=StringLiteral + (KW_WITH KW_SERDEPROPERTIES serdeprops=tableProperties)? + -> ^(TOK_STORAGEHANDLER $storageHandler $serdeprops?) + | KW_STORED KW_AS genericSpec=identifier + -> ^(TOK_FILEFORMAT_GENERIC $genericSpec) + ; + +tableLocation +@init { pushMsg("table location specification", state); } +@after { popMsg(state); } + : + KW_LOCATION locn=StringLiteral -> ^(TOK_TABLELOCATION $locn) + ; + +columnNameTypeList +@init { pushMsg("column name type list", state); } +@after { popMsg(state); } + : columnNameType (COMMA columnNameType)* -> ^(TOK_TABCOLLIST columnNameType+) + ; + +columnNameTypeOrConstraintList +@init { pushMsg("column name type and constraints list", state); } +@after { popMsg(state); } + : columnNameTypeOrConstraint (COMMA columnNameTypeOrConstraint)* -> ^(TOK_TABCOLLIST columnNameTypeOrConstraint+) + ; + +columnNameColonTypeList +@init { pushMsg("column name type list", state); } +@after { popMsg(state); } + : columnNameColonType (COMMA columnNameColonType)* -> ^(TOK_TABCOLLIST columnNameColonType+) + ; + +columnNameList +@init { pushMsg("column name list", state); } +@after { popMsg(state); } + : columnName (COMMA columnName)* -> ^(TOK_TABCOLNAME columnName+) + ; + +columnName +@init { pushMsg("column name", state); } +@after { popMsg(state); } + : + identifier + ; + +extColumnName +@init { pushMsg("column name for complex types", state); } +@after { popMsg(state); } + : + identifier (DOT^ ((KW_ELEM_TYPE) => KW_ELEM_TYPE | (KW_KEY_TYPE) => KW_KEY_TYPE | (KW_VALUE_TYPE) => KW_VALUE_TYPE | identifier))* + ; + +columnNameOrderList +@init { pushMsg("column name order list", state); } +@after { popMsg(state); } + : columnNameOrder (COMMA columnNameOrder)* -> ^(TOK_TABCOLNAME columnNameOrder+) + ; + +columnParenthesesList +@init { pushMsg("column parentheses list", state); } +@after { popMsg(state); } + : LPAREN! columnNameList RPAREN! + ; + +enableValidateSpecification +@init { pushMsg("enable specification", state); } +@after { popMsg(state); } + : enableSpecification validateSpecification? + | enforcedSpecification + ; + +enableSpecification +@init { pushMsg("enable specification", state); } +@after { popMsg(state); } + : KW_ENABLE -> ^(TOK_ENABLE) + | KW_DISABLE -> ^(TOK_DISABLE) + ; + +validateSpecification +@init { pushMsg("validate specification", state); } +@after { popMsg(state); } + : KW_VALIDATE -> ^(TOK_VALIDATE) + | KW_NOVALIDATE -> ^(TOK_NOVALIDATE) + ; + +enforcedSpecification +@init { pushMsg("enforced specification", state); } +@after { popMsg(state); } + : KW_ENFORCED -> ^(TOK_ENABLE) + | KW_NOT KW_ENFORCED -> ^(TOK_DISABLE) + ; + +relySpecification +@init { pushMsg("rely specification", state); } +@after { popMsg(state); } + : KW_RELY -> ^(TOK_RELY) + | KW_NORELY -> ^(TOK_NORELY) + ; + +createConstraint +@init { pushMsg("pk or uk or nn constraint", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? tableLevelConstraint constraintOptsCreate? + -> {$constraintName.tree != null}? + ^({$tableLevelConstraint.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsCreate?) + -> ^({$tableLevelConstraint.tree} constraintOptsCreate?) + ; + +alterConstraintWithName +@init { pushMsg("pk or uk or nn constraint with name", state); } +@after { popMsg(state); } + : KW_CONSTRAINT constraintName=identifier tableLevelConstraint constraintOptsAlter? + ->^({$tableLevelConstraint.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsAlter?) + ; + +tableLevelConstraint + : pkUkConstraint + | checkConstraint + ; + +pkUkConstraint +@init { pushMsg("pk or uk table level constraint", state); } +@after { popMsg(state); } + : tableConstraintType pkCols=columnParenthesesList + -> ^(tableConstraintType $pkCols) + ; + +checkConstraint +@init { pushMsg("CHECK constraint", state); } +@after { popMsg(state); } + : KW_CHECK LPAREN expression RPAREN + -> ^(TOK_CHECK_CONSTRAINT expression) + ; + +createForeignKey +@init { pushMsg("foreign key", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? KW_FOREIGN KW_KEY fkCols=columnParenthesesList KW_REFERENCES tabName=tableName parCols=columnParenthesesList constraintOptsCreate? + -> {$constraintName.tree != null}? + ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) $fkCols $tabName $parCols constraintOptsCreate?) + -> ^(TOK_FOREIGN_KEY $fkCols $tabName $parCols constraintOptsCreate?) + ; + +alterForeignKeyWithName +@init { pushMsg("foreign key with key name", state); } +@after { popMsg(state); } + : KW_CONSTRAINT constraintName=identifier KW_FOREIGN KW_KEY fkCols=columnParenthesesList KW_REFERENCES tabName=tableName parCols=columnParenthesesList constraintOptsAlter? + -> ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) $fkCols $tabName $parCols constraintOptsAlter?) + ; + +skewedValueElement +@init { pushMsg("skewed value element", state); } +@after { popMsg(state); } + : + skewedColumnValues + | skewedColumnValuePairList + ; + +skewedColumnValuePairList +@init { pushMsg("column value pair list", state); } +@after { popMsg(state); } + : skewedColumnValuePair (COMMA skewedColumnValuePair)* -> ^(TOK_TABCOLVALUE_PAIR skewedColumnValuePair+) + ; + +skewedColumnValuePair +@init { pushMsg("column value pair", state); } +@after { popMsg(state); } + : + LPAREN colValues=skewedColumnValues RPAREN + -> ^(TOK_TABCOLVALUES $colValues) + ; + +skewedColumnValues +@init { pushMsg("column values", state); } +@after { popMsg(state); } + : skewedColumnValue (COMMA skewedColumnValue)* -> ^(TOK_TABCOLVALUE skewedColumnValue+) + ; + +skewedColumnValue +@init { pushMsg("column value", state); } +@after { popMsg(state); } + : + constant + ; + +skewedValueLocationElement +@init { pushMsg("skewed value location element", state); } +@after { popMsg(state); } + : + skewedColumnValue + | skewedColumnValuePair + ; + +orderSpecification +@init { pushMsg("order specification", state); } +@after { popMsg(state); } + : KW_ASC | KW_DESC ; + +nullOrdering +@init { pushMsg("nulls ordering", state); } +@after { popMsg(state); } + : KW_NULLS KW_FIRST -> ^(TOK_NULLS_FIRST) + | KW_NULLS KW_LAST -> ^(TOK_NULLS_LAST) + ; + +columnNameOrder +@init { pushMsg("column name order", state); } +@after { popMsg(state); } + : identifier orderSpec=orderSpecification? nullSpec=nullOrdering? + -> {$orderSpec.tree == null && $nullSpec.tree == null}? + ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST identifier)) + -> {$orderSpec.tree == null}? + ^(TOK_TABSORTCOLNAMEASC ^($nullSpec identifier)) + -> {$nullSpec.tree == null && $orderSpec.tree.getType()==this.KW_ASC}? + ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST identifier)) + -> {$nullSpec.tree == null && $orderSpec.tree.getType()==this.KW_DESC}? + ^(TOK_TABSORTCOLNAMEDESC ^(TOK_NULLS_LAST identifier)) + -> {$orderSpec.tree.getType()==this.KW_ASC}? + ^(TOK_TABSORTCOLNAMEASC ^($nullSpec identifier)) + -> ^(TOK_TABSORTCOLNAMEDESC ^($nullSpec identifier)) + ; + +columnNameCommentList +@init { pushMsg("column name comment list", state); } +@after { popMsg(state); } + : columnNameComment (COMMA columnNameComment)* -> ^(TOK_TABCOLNAME columnNameComment+) + ; + +columnNameComment +@init { pushMsg("column name comment", state); } +@after { popMsg(state); } + : colName=identifier (KW_COMMENT comment=StringLiteral)? + -> ^(TOK_TABCOL $colName TOK_NULL $comment?) + ; + +orderSpecificationRewrite +@init { pushMsg("order specification", state); } +@after { popMsg(state); } + : KW_ASC -> ^(TOK_TABSORTCOLNAMEASC) + | KW_DESC -> ^(TOK_TABSORTCOLNAMEDESC) + ; + +columnRefOrder +@init { pushMsg("column order", state); } +@after { popMsg(state); } + : expression orderSpec=orderSpecificationRewrite? nullSpec=nullOrdering? + // ORDER not present, NULLS ORDER not present and default is NULLS LAST ex.: ORDER BY col0 + -> {$orderSpec.tree == null && $nullSpec.tree == null && nullsLast()}? + ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_LAST expression)) + // ORDER not present, NULLS ORDER not present and default is NULLS FIRST ex.: ORDER BY col0 + -> {$orderSpec.tree == null && $nullSpec.tree == null}? + ^(TOK_TABSORTCOLNAMEASC ^(TOK_NULLS_FIRST expression)) + // ORDER not present but NULLS ORDER present ex.: ORDER BY col0 NULLS FIRST + -> {$orderSpec.tree == null}? + ^(TOK_TABSORTCOLNAMEASC ^($nullSpec expression)) + // ORDER present but NULLS ORDER not present and default is NULLS LAST ex.: ORDER BY col0 ASC + -> {$nullSpec.tree == null && nullsLast()}? + ^($orderSpec ^(TOK_NULLS_LAST expression)) + // ORDER present, NULLS ORDER not present and default is NULLS FIRST ex.: ORDER BY col0 ASC + -> {$nullSpec.tree == null}? + ^($orderSpec ^(TOK_NULLS_FIRST expression)) + // both ORDER and NULLS ORDER present ex.: ORDER BY col0 ASC NULLS LAST + -> ^($orderSpec ^($nullSpec expression)) + ; + +columnNameType +@init { pushMsg("column specification", state); } +@after { popMsg(state); } + : colName=identifier colType (KW_COMMENT comment=StringLiteral)? + -> {containExcludedCharForCreateTableColumnName($colName.text)}? {throwColumnNameException()} + -> {$comment == null}? ^(TOK_TABCOL $colName colType) + -> ^(TOK_TABCOL $colName colType $comment) + ; + +columnNameTypeOrConstraint +@init { pushMsg("column name or constraint", state); } +@after { popMsg(state); } + : ( tableConstraint ) + | ( columnNameTypeConstraint ) + ; + +tableConstraint +@init { pushMsg("table constraint", state); } +@after { popMsg(state); } + : ( createForeignKey ) + | ( createConstraint ) + ; + +columnNameTypeConstraint +@init { pushMsg("column specification", state); } +@after { popMsg(state); } + : colName=identifier colType columnConstraint[$colName.tree]? (KW_COMMENT comment=StringLiteral)? + -> {containExcludedCharForCreateTableColumnName($colName.text)}? {throwColumnNameException()} + -> ^(TOK_TABCOL $colName colType $comment? columnConstraint?) + ; + +columnConstraint[CommonTree fkColName] +@init { pushMsg("column constraint", state); } +@after { popMsg(state); } + : ( foreignKeyConstraint[$fkColName] ) + | ( colConstraint ) + ; + +foreignKeyConstraint[CommonTree fkColName] +@init { pushMsg("column constraint", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? KW_REFERENCES tabName=tableName LPAREN colName=columnName RPAREN constraintOptsCreate? + -> {$constraintName.tree != null}? + ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsCreate?) + -> ^(TOK_FOREIGN_KEY ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsCreate?) + ; + +colConstraint +@init { pushMsg("column constraint", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? columnConstraintType constraintOptsCreate? + -> {$constraintName.tree != null}? + ^({$columnConstraintType.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsCreate?) + -> ^({$columnConstraintType.tree} constraintOptsCreate?) + ; + +alterColumnConstraint[CommonTree fkColName] +@init { pushMsg("alter column constraint", state); } +@after { popMsg(state); } + : ( alterForeignKeyConstraint[$fkColName] ) + | ( alterColConstraint ) + ; + +alterForeignKeyConstraint[CommonTree fkColName] +@init { pushMsg("alter column constraint", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? KW_REFERENCES tabName=tableName LPAREN colName=columnName RPAREN constraintOptsAlter? + -> {$constraintName.tree != null}? + ^(TOK_FOREIGN_KEY ^(TOK_CONSTRAINT_NAME $constraintName) ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsAlter?) + -> ^(TOK_FOREIGN_KEY ^(TOK_TABCOLNAME {$fkColName}) $tabName ^(TOK_TABCOLNAME $colName) constraintOptsAlter?) + ; + +alterColConstraint +@init { pushMsg("alter column constraint", state); } +@after { popMsg(state); } + : (KW_CONSTRAINT constraintName=identifier)? columnConstraintType constraintOptsAlter? + -> {$constraintName.tree != null}? + ^({$columnConstraintType.tree} ^(TOK_CONSTRAINT_NAME $constraintName) constraintOptsAlter?) + -> ^({$columnConstraintType.tree} constraintOptsAlter?) + ; + +columnConstraintType + : KW_NOT KW_NULL -> TOK_NOT_NULL + | KW_DEFAULT defaultVal-> ^(TOK_DEFAULT_VALUE defaultVal) + | checkConstraint + | tableConstraintType + ; + +defaultVal + : constant + | function + | castExpression + ; + +tableConstraintType + : KW_PRIMARY KW_KEY -> TOK_PRIMARY_KEY + | KW_UNIQUE -> TOK_UNIQUE + ; + +constraintOptsCreate + : enableValidateSpecification relySpecification? + ; + +constraintOptsAlter + : enableValidateSpecification relySpecification? + ; + +columnNameColonType +@init { pushMsg("column specification", state); } +@after { popMsg(state); } + : colName=identifier COLON colType (KW_COMMENT comment=StringLiteral)? + -> {$comment == null}? ^(TOK_TABCOL $colName colType) + -> ^(TOK_TABCOL $colName colType $comment) + ; + +colType +@init { pushMsg("column type", state); } +@after { popMsg(state); } + : type + ; + +colTypeList +@init { pushMsg("column type list", state); } +@after { popMsg(state); } + : colType (COMMA colType)* -> ^(TOK_COLTYPELIST colType+) + ; + +type + : primitiveType + | listType + | structType + | mapType + | unionType; + +primitiveType +@init { pushMsg("primitive type specification", state); } +@after { popMsg(state); } + : KW_TINYINT -> TOK_TINYINT + | KW_SMALLINT -> TOK_SMALLINT + | KW_INT -> TOK_INT + | KW_BIGINT -> TOK_BIGINT + | KW_BOOLEAN -> TOK_BOOLEAN + | KW_FLOAT -> TOK_FLOAT + | KW_REAL -> TOK_FLOAT + | KW_DOUBLE KW_PRECISION? -> TOK_DOUBLE + | KW_DATE -> TOK_DATE + | KW_DATETIME -> TOK_DATETIME + | KW_TIMESTAMP -> TOK_TIMESTAMP + | KW_TIMESTAMPLOCALTZ -> TOK_TIMESTAMPLOCALTZ + //| KW_TIMESTAMPTZ -> TOK_TIMESTAMPTZ + | KW_TIMESTAMP KW_WITH KW_LOCAL KW_TIME KW_ZONE -> TOK_TIMESTAMPLOCALTZ + //| KW_TIMESTAMP KW_WITH KW_TIME KW_ZONE -> TOK_TIMESTAMPTZ + // Uncomment to allow intervals as table column types + //| KW_INTERVAL KW_YEAR KW_TO KW_MONTH -> TOK_INTERVAL_YEAR_MONTH + //| KW_INTERVAL KW_DAY KW_TO KW_SECOND -> TOK_INTERVAL_DAY_TIME + | KW_STRING -> TOK_STRING + | KW_BINARY -> TOK_BINARY + | KW_DECIMAL (LPAREN prec=Number (COMMA scale=Number)? RPAREN)? -> ^(TOK_DECIMAL $prec? $scale?) + | KW_VARCHAR LPAREN length=Number RPAREN -> ^(TOK_VARCHAR $length) + | KW_CHAR LPAREN length=Number RPAREN -> ^(TOK_CHAR $length) + ; + +listType +@init { pushMsg("list type", state); } +@after { popMsg(state); } + : KW_ARRAY LESSTHAN type GREATERTHAN -> ^(TOK_LIST type) + ; + +structType +@init { pushMsg("struct type", state); } +@after { popMsg(state); } + : KW_STRUCT LESSTHAN columnNameColonTypeList GREATERTHAN -> ^(TOK_STRUCT columnNameColonTypeList) + ; + +mapType +@init { pushMsg("map type", state); } +@after { popMsg(state); } + : KW_MAP LESSTHAN left=primitiveType COMMA right=type GREATERTHAN + -> ^(TOK_MAP $left $right) + ; + +unionType +@init { pushMsg("uniontype type", state); } +@after { popMsg(state); } + : KW_UNIONTYPE LESSTHAN colTypeList GREATERTHAN -> ^(TOK_UNIONTYPE colTypeList) + ; + +setOperator +@init { pushMsg("set operator", state); } +@after { popMsg(state); } + : KW_UNION KW_ALL -> ^(TOK_UNIONALL) + | KW_UNION KW_DISTINCT? -> ^(TOK_UNIONDISTINCT) + | KW_INTERSECT KW_ALL -> ^(TOK_INTERSECTALL) + | KW_INTERSECT KW_DISTINCT? -> ^(TOK_INTERSECTDISTINCT) + | KW_EXCEPT KW_ALL -> ^(TOK_EXCEPTALL) + | KW_EXCEPT KW_DISTINCT? -> ^(TOK_EXCEPTDISTINCT) + | KW_MINUS KW_ALL -> ^(TOK_EXCEPTALL) + | KW_MINUS KW_DISTINCT? -> ^(TOK_EXCEPTDISTINCT) + ; + +queryStatementExpression + : + /* Would be nice to do this as a gated semantic perdicate + But the predicate gets pushed as a lookahead decision. + Calling rule doesnot know about topLevel + */ + (w=withClause)? + queryStatementExpressionBody { + if ($w.tree != null) { + $queryStatementExpressionBody.tree.insertChild(0, $w.tree); + } + } + -> queryStatementExpressionBody + ; + +queryStatementExpressionBody + : + fromStatement + | regularBody + ; + +withClause + : + KW_WITH cteStatement (COMMA cteStatement)* -> ^(TOK_CTE cteStatement+) +; + +cteStatement + : + identifier KW_AS LPAREN queryStatementExpression RPAREN + -> ^(TOK_SUBQUERY queryStatementExpression identifier) +; + +fromStatement +: (singleFromStatement -> singleFromStatement) + (u=setOperator r=singleFromStatement + -> ^($u {$fromStatement.tree} $r) + )* + -> {u != null}? ^(TOK_QUERY + ^(TOK_FROM + ^(TOK_SUBQUERY + {$fromStatement.tree} + {adaptor.create(Identifier, generateUnionAlias())} + ) + ) + ^(TOK_INSERT + ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) + ) + ) + -> {$fromStatement.tree} + ; + + +singleFromStatement + : + fromClause + ( b+=body )+ -> ^(TOK_QUERY fromClause body+) + ; + +/* +The valuesClause rule below ensures that the parse tree for +"insert into table FOO values (1,2),(3,4)" looks the same as +"insert into table FOO select a,b from (values(1,2),(3,4)) as BAR(a,b)" which itself is made to look +very similar to the tree for "insert into table FOO select a,b from BAR". +*/ +regularBody + : + i=insertClause + ( + s=selectStatement + {$s.tree.getFirstChildWithType(TOK_INSERT).replaceChildren(0, 0, $i.tree);} -> {$s.tree} + | + valuesClause + -> ^(TOK_QUERY + ^(TOK_INSERT {$i.tree} ^(TOK_SELECT ^(TOK_SELEXPR ^(TOK_FUNCTION Identifier["inline"] valuesClause)))) + ) + ) + | + selectStatement + ; + +atomSelectStatement + : + s=selectClause + f=fromClause? + w=whereClause? + g=groupByClause? + h=havingClause? + win=window_clause? + -> ^(TOK_QUERY $f? ^(TOK_INSERT ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + $s $w? $g? $h? $win?)) + | + LPAREN! selectStatement RPAREN! + ; + +selectStatement + : + a=atomSelectStatement + set=setOpSelectStatement[$atomSelectStatement.tree]? + o=orderByClause? + c=clusterByClause? + d=distributeByClause? + sort=sortByClause? + l=limitClause? + { + if(set == null){ + $a.tree.getFirstChildWithType(TOK_INSERT).addChild($o.tree); + $a.tree.getFirstChildWithType(TOK_INSERT).addChild($c.tree); + $a.tree.getFirstChildWithType(TOK_INSERT).addChild($d.tree); + $a.tree.getFirstChildWithType(TOK_INSERT).addChild($sort.tree); + $a.tree.getFirstChildWithType(TOK_INSERT).addChild($l.tree); + } + } + -> {set == null}? + {$a.tree} + -> {o==null && c==null && d==null && sort==null && l==null}? + {$set.tree} + -> ^(TOK_QUERY + ^(TOK_FROM + ^(TOK_SUBQUERY + {$set.tree} + {adaptor.create(Identifier, generateUnionAlias())} + ) + ) + ^(TOK_INSERT + ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) + $o? $c? $d? $sort? $l? + ) + ) + ; + +setOpSelectStatement[CommonTree t] + : + (u=setOperator b=atomSelectStatement + -> {$setOpSelectStatement.tree != null && ((CommonTree)u.getTree()).getType()==this.TOK_UNIONDISTINCT}? + ^(TOK_QUERY + ^(TOK_FROM + ^(TOK_SUBQUERY + ^(TOK_UNIONALL {$setOpSelectStatement.tree} $b) + {adaptor.create(Identifier, generateUnionAlias())} + ) + ) + ^(TOK_INSERT + ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + ^(TOK_SELECTDI ^(TOK_SELEXPR TOK_SETCOLREF)) + ) + ) + -> {$setOpSelectStatement.tree != null && ((CommonTree)u.getTree()).getType()!=this.TOK_UNIONDISTINCT}? + ^($u {$setOpSelectStatement.tree} $b) + -> {$setOpSelectStatement.tree == null && ((CommonTree)u.getTree()).getType()==this.TOK_UNIONDISTINCT}? + ^(TOK_QUERY + ^(TOK_FROM + ^(TOK_SUBQUERY + ^(TOK_UNIONALL {$t} $b) + {adaptor.create(Identifier, generateUnionAlias())} + ) + ) + ^(TOK_INSERT + ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + ^(TOK_SELECTDI ^(TOK_SELEXPR TOK_SETCOLREF)) + ) + ) + -> ^($u {$t} $b) + )+ + -> {$setOpSelectStatement.tree.getChild(0).getType()==this.TOK_UNIONALL + ||$setOpSelectStatement.tree.getChild(0).getType()==this.TOK_INTERSECTDISTINCT + ||$setOpSelectStatement.tree.getChild(0).getType()==this.TOK_INTERSECTALL + ||$setOpSelectStatement.tree.getChild(0).getType()==this.TOK_EXCEPTDISTINCT + ||$setOpSelectStatement.tree.getChild(0).getType()==this.TOK_EXCEPTALL}? + ^(TOK_QUERY + ^(TOK_FROM + ^(TOK_SUBQUERY + {$setOpSelectStatement.tree} + {adaptor.create(Identifier, generateUnionAlias())} + ) + ) + ^(TOK_INSERT + ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + ^(TOK_SELECT ^(TOK_SELEXPR TOK_SETCOLREF)) + ) + ) + -> {$setOpSelectStatement.tree} + ; + +selectStatementWithCTE + : + (w=withClause)? + selectStatement { + if ($w.tree != null) { + $selectStatement.tree.insertChild(0, $w.tree); + } + } + -> selectStatement + ; + +body + : + insertClause + selectClause + lateralView? + whereClause? + groupByClause? + havingClause? + window_clause? + orderByClause? + clusterByClause? + distributeByClause? + sortByClause? + limitClause? -> ^(TOK_INSERT insertClause + selectClause lateralView? whereClause? groupByClause? havingClause? orderByClause? clusterByClause? + distributeByClause? sortByClause? window_clause? limitClause?) + | + selectClause + lateralView? + whereClause? + groupByClause? + havingClause? + window_clause? + orderByClause? + clusterByClause? + distributeByClause? + sortByClause? + limitClause? -> ^(TOK_INSERT ^(TOK_DESTINATION ^(TOK_DIR TOK_TMP_FILE)) + selectClause lateralView? whereClause? groupByClause? havingClause? orderByClause? clusterByClause? + distributeByClause? sortByClause? window_clause? limitClause?) + ; + +insertClause +@init { pushMsg("insert clause", state); } +@after { popMsg(state); } + : + KW_INSERT KW_OVERWRITE destination ifNotExists? -> ^(TOK_DESTINATION destination ifNotExists?) + | KW_INSERT KW_INTO KW_TABLE? tableOrPartition (LPAREN targetCols=columnNameList RPAREN)? + -> ^(TOK_INSERT_INTO tableOrPartition $targetCols?) + ; + +destination +@init { pushMsg("destination specification", state); } +@after { popMsg(state); } + : + (local = KW_LOCAL)? KW_DIRECTORY StringLiteral tableRowFormat? tableFileFormat? + -> ^(TOK_DIR StringLiteral $local? tableRowFormat? tableFileFormat?) + | KW_TABLE tableOrPartition -> tableOrPartition + ; + +limitClause +@init { pushMsg("limit clause", state); } +@after { popMsg(state); } + : + KW_LIMIT ((offset=Number COMMA)? num=Number) -> ^(TOK_LIMIT ($offset)? $num) + | KW_LIMIT num=Number KW_OFFSET offset=Number -> ^(TOK_LIMIT ($offset)? $num) + ; + +//DELETE FROM WHERE ...; +deleteStatement +@init { pushMsg("delete statement", state); } +@after { popMsg(state); } + : + KW_DELETE KW_FROM tableName (whereClause)? -> ^(TOK_DELETE_FROM tableName whereClause?) + ; + +/*SET = (3 + col2)*/ +columnAssignmentClause + : + tableOrColumn EQUAL^ precedencePlusExpression + ; + +/*SET col1 = 5, col2 = (4 + col4), ...*/ +setColumnsClause + : + KW_SET columnAssignmentClause (COMMA columnAssignmentClause)* -> ^(TOK_SET_COLUMNS_CLAUSE columnAssignmentClause* ) + ; + +/* + UPDATE
+ SET col1 = val1, col2 = val2... WHERE ... +*/ +updateStatement +@init { pushMsg("update statement", state); } +@after { popMsg(state); } + : + KW_UPDATE tableName setColumnsClause whereClause? -> ^(TOK_UPDATE_TABLE tableName setColumnsClause whereClause?) + ; + +/* +BEGIN user defined transaction boundaries; follows SQL 2003 standard exactly except for addition of +"setAutoCommitStatement" which is not in the standard doc but is supported by most SQL engines. +*/ +sqlTransactionStatement +@init { pushMsg("transaction statement", state); } +@after { popMsg(state); } + : + startTransactionStatement + | commitStatement + | rollbackStatement + | setAutoCommitStatement + ; + +startTransactionStatement + : + KW_START KW_TRANSACTION ( transactionMode ( COMMA transactionMode )* )? -> ^(TOK_START_TRANSACTION transactionMode*) + ; + +transactionMode + : + isolationLevel + | transactionAccessMode -> ^(TOK_TXN_ACCESS_MODE transactionAccessMode) + ; + +transactionAccessMode + : + KW_READ KW_ONLY -> TOK_TXN_READ_ONLY + | KW_READ KW_WRITE -> TOK_TXN_READ_WRITE + ; + +isolationLevel + : + KW_ISOLATION KW_LEVEL levelOfIsolation -> ^(TOK_ISOLATION_LEVEL levelOfIsolation) + ; + +/*READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE may be supported later*/ +levelOfIsolation + : + KW_SNAPSHOT -> TOK_ISOLATION_SNAPSHOT + ; + +commitStatement + : + KW_COMMIT ( KW_WORK )? -> TOK_COMMIT + ; + +rollbackStatement + : + KW_ROLLBACK ( KW_WORK )? -> TOK_ROLLBACK + ; +setAutoCommitStatement + : + KW_SET KW_AUTOCOMMIT booleanValueTok -> ^(TOK_SET_AUTOCOMMIT booleanValueTok) + ; +/* +END user defined transaction boundaries +*/ + +abortTransactionStatement +@init { pushMsg("abort transactions statement", state); } +@after { popMsg(state); } + : + KW_ABORT KW_TRANSACTIONS ( Number )+ -> ^(TOK_ABORT_TRANSACTIONS ( Number )+) + ; + + +/* +BEGIN SQL Merge statement +*/ +mergeStatement +@init { pushMsg("MERGE statement", state); } +@after { popMsg(state); } + : + KW_MERGE QUERY_HINT? KW_INTO tableName (KW_AS? identifier)? KW_USING joinSourcePart KW_ON expression whenClauses + -> ^(TOK_MERGE ^(TOK_TABREF tableName identifier?) joinSourcePart expression QUERY_HINT? whenClauses) + ; +/* +Allow 0,1 or 2 WHEN MATCHED clauses and 0 or 1 WHEN NOT MATCHED +Each WHEN clause may have AND . +If 2 WHEN MATCHED clauses are present, 1 must be UPDATE the other DELETE and the 1st one +must have AND +*/ +whenClauses + : + (whenMatchedAndClause|whenMatchedThenClause)* whenNotMatchedClause? + ; +whenNotMatchedClause +@init { pushMsg("WHEN NOT MATCHED clause", state); } +@after { popMsg(state); } + : + KW_WHEN KW_NOT KW_MATCHED (KW_AND expression)? KW_THEN KW_INSERT (targetCols=columnParenthesesList)? KW_VALUES valueRowConstructor -> + ^(TOK_NOT_MATCHED ^(TOK_INSERT $targetCols? valueRowConstructor) expression?) + ; +whenMatchedAndClause +@init { pushMsg("WHEN MATCHED AND clause", state); } +@after { popMsg(state); } + : + KW_WHEN KW_MATCHED KW_AND expression KW_THEN updateOrDelete -> + ^(TOK_MATCHED updateOrDelete expression) + ; +whenMatchedThenClause +@init { pushMsg("WHEN MATCHED THEN clause", state); } +@after { popMsg(state); } + : + KW_WHEN KW_MATCHED KW_THEN updateOrDelete -> + ^(TOK_MATCHED updateOrDelete) + ; +updateOrDelete + : + KW_UPDATE setColumnsClause -> ^(TOK_UPDATE setColumnsClause) + | + KW_DELETE -> TOK_DELETE + ; +/* +END SQL Merge statement +*/ + +killQueryStatement +@init { pushMsg("kill query statement", state); } +@after { popMsg(state); } + : + KW_KILL KW_QUERY ( StringLiteral )+ -> ^(TOK_KILL_QUERY ( StringLiteral )+) + ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserStandard.g parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserStandard.g new file mode 100644 index 0000000000..49182d1a31 --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/HiveParserStandard.g @@ -0,0 +1,38 @@ +/** + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +parser grammar HiveParserStandard; + +options +{ +tokenVocab=HiveLexerStandard; +output=AST; +ASTLabelType=ASTNode; +backtrack=false; +k=3; +superClass = GenericHiveParser; +} +import HiveParserParent; + +@header { +package org.apache.hadoop.hive.ql.parse; +} + +// starting rule +statement + : explainStatement EOF + | execStatement EOF + ; diff --git parser/src/java/org/apache/hadoop/hive/ql/parse/Quotation.java parser/src/java/org/apache/hadoop/hive/ql/parse/Quotation.java new file mode 100644 index 0000000000..051f81f210 --- /dev/null +++ parser/src/java/org/apache/hadoop/hive/ql/parse/Quotation.java @@ -0,0 +1,69 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.parse; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.conf.HiveConf; + +/** + * Identifier quotation. + */ +public enum Quotation { + /** + * Quotation of identifiers and special characters in identifiers are not allowed. + */ + NONE("none"), + /** + * Use the backtick character to quote identifiers having special characters. + * Use single quotes to quote string literals. Double quotes are also accepted but not recommended. + */ + BACKTICKS("column"), + /** + * SQL standard way to quote identifiers. + * Use double quotes to quote identifiers having special characters and single quotes for string literals. + */ + STANDARD("standard"); + + Quotation(String stringValue) { + this.stringValue = stringValue; + } + + private final String stringValue; + + public String stringValue() { + return stringValue; + } + + public static Quotation from(Configuration configuration) { + String supportedQIds; + if (configuration == null) { + supportedQIds = HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT.defaultStrVal; + } else { + supportedQIds = HiveConf.getVar(configuration, HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT); + } + + for (Quotation quotation : values()) { + if (quotation.stringValue.equalsIgnoreCase(supportedQIds)) { + return quotation; + } + } + + throw new EnumConstantNotPresentException(Quotation.class, + "Option not recognized for " + HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT.varname + "value: " + supportedQIds); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/ddl/table/partition/add/AlterViewAddPartitionAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/ddl/table/partition/add/AlterViewAddPartitionAnalyzer.java index c1d2887ec8..a412fa5e45 100644 --- ql/src/java/org/apache/hadoop/hive/ql/ddl/table/partition/add/AlterViewAddPartitionAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/ddl/table/partition/add/AlterViewAddPartitionAnalyzer.java @@ -60,8 +60,8 @@ protected boolean allowLocation() { protected void postProcess(TableName tableName, Table table, AlterTableAddPartitionDesc desc, Task ddlTask) throws SemanticException { // Compile internal query to capture underlying table partition dependencies - String dbTable = HiveUtils.unparseIdentifier(tableName.getDb()) + "." + - HiveUtils.unparseIdentifier(tableName.getTable()); + String dbTable = HiveUtils.unparseIdentifier(tableName.getDb(), conf) + "." + + HiveUtils.unparseIdentifier(tableName.getTable(), conf); StringBuilder where = new StringBuilder(); boolean firstOr = true; @@ -79,7 +79,7 @@ protected void postProcess(TableName tableName, Table table, AlterTableAddPartit } else { where.append(" AND "); } - where.append(HiveUtils.unparseIdentifier(entry.getKey())); + where.append(HiveUtils.unparseIdentifier(entry.getKey(), conf)); where.append(" = '"); where.append(HiveUtils.escapeString(entry.getValue())); where.append("'"); diff --git ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java index 7820013ab0..22229ccaa4 100644 --- ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java +++ ql/src/java/org/apache/hadoop/hive/ql/lockmgr/DummyTxnManager.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hive.ql.lockmgr; +import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.common.ValidTxnWriteIdList; import org.apache.hadoop.hive.metastore.api.CommitTxnRequest; import org.apache.hadoop.hive.metastore.api.TxnToWriteId; @@ -405,7 +406,7 @@ private HiveLockMode getWriteEntityLockMode (WriteEntity we) { try { locks.add(new HiveLockObj( new HiveLockObject(new DummyPartition(p.getTable(), p.getTable().getDbName() - + "/" + org.apache.hadoop.hive.metastore.utils.MetaStoreUtils.encodeTableName(p.getTable().getTableName()) + + "/" + FileUtils.escapePathName(p.getTable().getTableName()).toLowerCase() + "/" + partialName, partialSpec), lockData), mode)); partialName += "/"; diff --git ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveLockObject.java ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveLockObject.java index 08aeeb2acd..55ecbb45b9 100644 --- ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveLockObject.java +++ ql/src/java/org/apache/hadoop/hive/ql/lockmgr/HiveLockObject.java @@ -22,6 +22,7 @@ import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.builder.HashCodeBuilder; +import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.common.StringInternUtils; import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.ql.metadata.DummyPartition; @@ -197,12 +198,12 @@ public HiveLockObject(String[] paths, HiveLockObjectData lockData) { } public HiveLockObject(Table tbl, HiveLockObjectData lockData) { - this(new String[] {tbl.getDbName(), org.apache.hadoop.hive.metastore.utils.MetaStoreUtils.encodeTableName(tbl.getTableName())}, lockData); + this(new String[] {tbl.getDbName(), FileUtils.escapePathName(tbl.getTableName()).toLowerCase()}, lockData); } public HiveLockObject(Partition par, HiveLockObjectData lockData) { this(new String[] {par.getTable().getDbName(), - org.apache.hadoop.hive.metastore.utils.MetaStoreUtils.encodeTableName(par.getTable().getTableName()), par.getName()}, lockData); + FileUtils.escapePathName(par.getTable().getTableName()).toLowerCase(), par.getName()}, lockData); } public HiveLockObject(DummyPartition par, HiveLockObjectData lockData) { diff --git ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveUtils.java ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveUtils.java index 26c7a606bf..2fe87b7aae 100644 --- ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveUtils.java +++ ql/src/java/org/apache/hadoop/hive/ql/metadata/HiveUtils.java @@ -22,6 +22,7 @@ import java.util.List; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.ql.parse.Quotation; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.conf.Configuration; @@ -274,22 +275,22 @@ public static String lightEscapeString(String str) { /** * Regenerate an identifier as part of unparsing it back to SQL text. */ - public static String unparseIdentifier(String identifier) { - return unparseIdentifier(identifier, null); - } - public static String unparseIdentifier(String identifier, Configuration conf) { // In the future, if we support arbitrary characters in // identifiers, then we'll need to escape any backticks // in identifier by doubling them up. // the time has come - String qIdSupport = conf == null ? null : - HiveConf.getVar(conf, HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT); - if ( qIdSupport != null && !"none".equals(qIdSupport) ) { - identifier = identifier.replaceAll("`", "``"); + switch (Quotation.from(conf)) + { + case STANDARD: + return "\"" + identifier.replaceAll("\"", "\"\"") + "\""; + case BACKTICKS: + default: + return "`" + identifier.replaceAll("`", "``") + "`"; + case NONE: + return "`" + identifier + "`"; } - return "`" + identifier + "`"; } public static HiveStorageHandler getStorageHandler( diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsAutoGatherContext.java ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsAutoGatherContext.java index 9bcc472a62..4cc87855de 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsAutoGatherContext.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsAutoGatherContext.java @@ -103,8 +103,21 @@ public void setAnalyzeRewrite(AnalyzeRewriteContext analyzeRewrite) { * However, we do not need to specify the partition-spec because (1) the data is going to be inserted to that specific partition * (2) we can compose the static/dynamic partition using a select operator in replaceSelectOperatorProcess. */ - public void insertAnalyzePipeline() throws SemanticException{ - String analyzeCommand = "analyze table `" + tbl.getDbName() + "`.`" + tbl.getTableName() + "`" + public void insertAnalyzePipeline() throws SemanticException { + String quote; + switch (Quotation.from(conf)) { + case NONE: + quote = ""; + break; + case BACKTICKS: + default: + quote = "`"; + break; + case STANDARD: + quote = "\""; + break; + } + String analyzeCommand = "analyze table " + quote + tbl.getDbName() + quote + "." + quote + tbl.getTableName() + quote + " compute statistics for columns "; insertAnalyzePipeline(analyzeCommand, false); } @@ -128,8 +141,9 @@ public void insertTableValuesAnalyzePipeline() throws SemanticException { partSpec.put(partKey, null); } } + String quote = ColumnStatsSemanticAnalyzer.getQuote(conf); String command = ColumnStatsSemanticAnalyzer.genRewrittenQuery( - tbl, Utilities.getColumnNamesFromFieldSchema(tbl.getCols()), conf, partSpec, isPartitionStats, true); + tbl, Utilities.getColumnNamesFromFieldSchema(tbl.getCols()), conf, partSpec, isPartitionStats, true, quote); insertAnalyzePipeline(command, true); } diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsSemanticAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsSemanticAnalyzer.java index 35f7ec674a..f4c0bd0f35 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsSemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/ColumnStatsSemanticAnalyzer.java @@ -60,6 +60,7 @@ private ASTNode originalTree; private ASTNode rewrittenTree; private String rewrittenQuery; + private String quote; private Context ctx; private boolean isRewritten; @@ -71,6 +72,18 @@ public ColumnStatsSemanticAnalyzer(QueryState queryState) throws SemanticException { super(queryState); + quote = getQuote(conf); + } + + public static String getQuote(HiveConf conf) { + String qIdSupport = conf.getVar(ConfVars.HIVE_QUOTEDID_SUPPORT); + if ("column".equals(qIdSupport)) { + return "`"; + } else if ("standard".equals(qIdSupport)) { + return "\""; + } else { + return ""; + } } private boolean shouldRewrite(ASTNode tree) { @@ -148,7 +161,7 @@ private void handlePartialPartitionSpec(Map partSpec, ColumnStat } } - private static StringBuilder genPartitionClause(Table tbl, Map partSpec) + private static StringBuilder genPartitionClause(Table tbl, Map partSpec, String quote) throws SemanticException { StringBuilder whereClause = new StringBuilder(" where "); boolean predPresent = false; @@ -163,8 +176,8 @@ private static StringBuilder genPartitionClause(Table tbl, Map p } else { whereClause.append(" and "); } - whereClause.append("`").append(partKey).append("` = ") - .append(genPartValueString(getColTypeOf(tbl, partKey), value)); + whereClause.append(quote).append(partKey).append(quote).append(" = ") + .append(genPartValueString(partKey, value)); } } @@ -174,7 +187,9 @@ private static StringBuilder genPartitionClause(Table tbl, Map p } else { groupByClause.append(','); } - groupByClause.append("`" + fs.getName() + "`"); + groupByClause.append(quote); + groupByClause.append(fs.getName()); + groupByClause.append(quote); } // attach the predicate and group by to the return clause @@ -183,7 +198,7 @@ private static StringBuilder genPartitionClause(Table tbl, Map p - private static String getColTypeOf(Table tbl, String partKey) throws SemanticException{ + private String getColTypeOf(Table tbl, String partKey) throws SemanticException{ for (FieldSchema fs : tbl.getPartitionKeys()) { if (partKey.equalsIgnoreCase(fs.getName())) { return fs.getType().toLowerCase(); @@ -215,19 +230,15 @@ private static String getColTypeOf(Table tbl, String partKey) throws SemanticExc return colTypes; } - private static String escapeBackTicks(String colName) { - return colName.replaceAll("`", "``"); - } - private String genRewrittenQuery(List colNames, HiveConf conf, Map partSpec, boolean isPartitionStats, boolean useTableValues) throws SemanticException { - String rewrittenQuery = genRewrittenQuery(tbl, colNames, conf, partSpec, isPartitionStats, useTableValues); + String rewrittenQuery = genRewrittenQuery(tbl, colNames, conf, partSpec, isPartitionStats, useTableValues, quote); isRewritten = true; return rewrittenQuery; } public static String genRewrittenQuery(Table tbl, List colNames, HiveConf conf, Map partSpec, - boolean isPartitionStats, boolean useTableValues) throws SemanticException{ + boolean isPartitionStats, boolean useTableValues, String quote) throws SemanticException{ StringBuilder rewrittenQueryBuilder = new StringBuilder("select "); StringBuilder columnNamesBuilder = new StringBuilder(); @@ -239,10 +250,12 @@ public static String genRewrittenQuery(Table tbl, List colNames, HiveCon columnDummyValuesBuilder.append(" , "); } String func = HiveConf.getVar(conf, HiveConf.ConfVars.HIVE_STATS_NDV_ALGO).toLowerCase(); - rewrittenQueryBuilder.append("compute_stats(`"); - final String columnName = escapeBackTicks(colNames.get(i)); + rewrittenQueryBuilder.append("compute_stats("); + rewrittenQueryBuilder.append(quote); + final String columnName = colNames.get(i).replaceAll(quote, quote + quote); rewrittenQueryBuilder.append(columnName); - rewrittenQueryBuilder.append("`, '" + func + "'"); + rewrittenQueryBuilder.append(quote); + rewrittenQueryBuilder.append(", '" + func + "'"); if ("fm".equals(func)) { int numBitVectors = 0; try { @@ -262,13 +275,11 @@ public static String genRewrittenQuery(Table tbl, List colNames, HiveCon if (isPartitionStats) { for (FieldSchema fs : tbl.getPartCols()) { - final String partColumnName = " , `" + fs.getName() + "`"; - rewrittenQueryBuilder.append(partColumnName); - - columnNamesBuilder.append(partColumnName); + rewrittenQueryBuilder.append(" , ").append(quote).append(fs.getName()).append(quote); + columnNamesBuilder.append(" , ").append(quote).append(fs.getName()).append(quote); - columnDummyValuesBuilder.append( - " , cast(null as " + TypeInfoUtils.getTypeInfoFromTypeString(fs.getType()).toString() + ")"); + columnDummyValuesBuilder.append(" , cast(null as ") + .append(TypeInfoUtils.getTypeInfoFromTypeString(fs.getType()).toString()).append(")"); } } @@ -279,19 +290,27 @@ public static String genRewrittenQuery(Table tbl, List colNames, HiveCon // Values rewrittenQueryBuilder.append(columnDummyValuesBuilder.toString()); rewrittenQueryBuilder.append(")) as "); - rewrittenQueryBuilder.append("`" + tbl.getTableName() + "`"); + rewrittenQueryBuilder.append(quote); + rewrittenQueryBuilder.append(tbl.getTableName()); + rewrittenQueryBuilder.append(quote); rewrittenQueryBuilder.append("("); // Columns rewrittenQueryBuilder.append(columnNamesBuilder.toString()); rewrittenQueryBuilder.append(")"); } else { - rewrittenQueryBuilder.append("`" + tbl.getDbName() + "`.`" + tbl.getTableName() + "`"); + rewrittenQueryBuilder.append(quote); + rewrittenQueryBuilder.append(tbl.getDbName()); + rewrittenQueryBuilder.append(quote); + rewrittenQueryBuilder.append("."); + rewrittenQueryBuilder.append(quote); + rewrittenQueryBuilder.append(tbl.getTableName()); + rewrittenQueryBuilder.append(quote); } // If partition level statistics is requested, add predicate and group by as needed to rewritten // query if (isPartitionStats) { - rewrittenQueryBuilder.append(genPartitionClause(tbl, partSpec)); + rewrittenQueryBuilder.append(genPartitionClause(tbl, partSpec, quote)); } String rewrittenQuery = rewrittenQueryBuilder.toString(); diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/ParseDriver.java ql/src/java/org/apache/hadoop/hive/ql/parse/ParseDriver.java index 48c0a4a8ad..b17bfa12fd 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/ParseDriver.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/ParseDriver.java @@ -19,10 +19,11 @@ package org.apache.hadoop.hive.ql.parse; import java.util.ArrayList; -import org.antlr.runtime.ANTLRStringStream; + import org.antlr.runtime.CharStream; import org.antlr.runtime.CommonToken; import org.antlr.runtime.NoViableAltException; +import org.antlr.runtime.ParserRuleReturnScope; import org.antlr.runtime.RecognitionException; import org.antlr.runtime.Token; import org.antlr.runtime.TokenRewriteStream; @@ -30,6 +31,7 @@ import org.antlr.runtime.tree.CommonTree; import org.antlr.runtime.tree.CommonTreeAdaptor; import org.antlr.runtime.tree.TreeAdaptor; +import org.apache.hadoop.conf.Configuration; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -43,91 +45,6 @@ private static final Logger LOG = LoggerFactory.getLogger(ParseDriver.class); - /** - * ANTLRNoCaseStringStream. - * - */ - //This class provides and implementation for a case insensitive token checker - //for the lexical analysis part of antlr. By converting the token stream into - //upper case at the time when lexical rules are checked, this class ensures that the - //lexical rules need to just match the token with upper case letters as opposed to - //combination of upper case and lower case characteres. This is purely used for matching lexical - //rules. The actual token text is stored in the same way as the user input without - //actually converting it into an upper case. The token values are generated by the consume() - //function of the super class ANTLRStringStream. The LA() function is the lookahead funtion - //and is purely used for matching lexical rules. This also means that the grammar will only - //accept capitalized tokens in case it is run from other tools like antlrworks which - //do not have the ANTLRNoCaseStringStream implementation. - public class ANTLRNoCaseStringStream extends ANTLRStringStream { - - public ANTLRNoCaseStringStream(String input) { - super(input); - } - - @Override - public int LA(int i) { - - int returnChar = super.LA(i); - if (returnChar == CharStream.EOF) { - return returnChar; - } else if (returnChar == 0) { - return returnChar; - } - - return Character.toUpperCase((char) returnChar); - } - } - - /** - * HiveLexerX. - * - */ - public class HiveLexerX extends HiveLexer { - - private final ArrayList errors; - - public HiveLexerX() { - super(); - errors = new ArrayList(); - } - - public HiveLexerX(CharStream input) { - super(input); - errors = new ArrayList(); - } - - @Override - public void displayRecognitionError(String[] tokenNames, - RecognitionException e) { - - errors.add(new ParseError(this, e, tokenNames)); - } - - @Override - public String getErrorMessage(RecognitionException e, String[] tokenNames) { - String msg = null; - - if (e instanceof NoViableAltException) { - @SuppressWarnings("unused") - NoViableAltException nvae = (NoViableAltException) e; - // for development, can add - // "decision=<<"+nvae.grammarDecisionDescription+">>" - // and "(decision="+nvae.decisionNumber+") and - // "state "+nvae.stateNumber - msg = "character " + getCharErrorDisplay(e.c) + " not supported here"; - } else { - msg = super.getErrorMessage(e, tokenNames); - } - - return msg; - } - - public ArrayList getErrors() { - return errors; - } - - } - /** * Tree adaptor for making antlr return ASTNodes instead of CommonTree nodes * so that the graph walking algorithms and the rules framework defined in @@ -208,7 +125,8 @@ public ASTNode parse(String command, Context ctx, String viewFullyQualifiedName) LOG.debug("Parsing command: " + command); } - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + Configuration configuration = ctx == null ? null : ctx.getConf(); + GenericHiveLexer lexer = GenericHiveLexer.of(command, configuration); TokenRewriteStream tokens = new TokenRewriteStream(lexer); if (ctx != null) { if (viewFullyQualifiedName == null) { @@ -218,14 +136,9 @@ public ASTNode parse(String command, Context ctx, String viewFullyQualifiedName) // It is a view ctx.addViewTokenRewriteStream(viewFullyQualifiedName, tokens); } - lexer.setHiveConf(ctx.getConf()); - } - HiveParser parser = new HiveParser(tokens); - if (ctx != null) { - parser.setHiveConf(ctx.getConf()); } - parser.setTreeAdaptor(adaptor); - HiveParser.statement_return r = null; + GenericHiveParser parser = GenericHiveParser.with(tokens, configuration, adaptor); + ParserRuleReturnScope r; try { r = parser.statement(); } catch (RecognitionException e) { @@ -251,7 +164,7 @@ public ASTNode parse(String command, Context ctx, String viewFullyQualifiedName) public ASTNode parseHint(String command) throws ParseException { LOG.debug("Parsing hint: {}", command); - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + GenericHiveLexer lexer = GenericHiveLexer.of(command, null); TokenRewriteStream tokens = new TokenRewriteStream(lexer); HintParser parser = new HintParser(tokens); parser.setTreeAdaptor(adaptor); @@ -286,14 +199,13 @@ public ASTNode parseHint(String command) throws ParseException { public ASTNode parseSelect(String command, Context ctx) throws ParseException { LOG.debug("Parsing command: {}", command); - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + GenericHiveLexer lexer = GenericHiveLexer.of(command, ctx.getConf()); TokenRewriteStream tokens = new TokenRewriteStream(lexer); if (ctx != null) { ctx.setTokenRewriteStream(tokens); } - HiveParser parser = new HiveParser(tokens); - parser.setTreeAdaptor(adaptor); - HiveParser_SelectClauseParser.selectClause_return r = null; + GenericHiveParser parser = GenericHiveParser.with(tokens, ctx.getConf(), adaptor); + ParserRuleReturnScope r; try { r = parser.selectClause(); } catch (RecognitionException e) { @@ -308,16 +220,15 @@ public ASTNode parseSelect(String command, Context ctx) throws ParseException { throw new ParseException(parser.errors); } - return r.getTree(); + return (ASTNode) r.getTree(); } public ASTNode parseExpression(String command) throws ParseException { LOG.debug("Parsing expression: {}", command); - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + GenericHiveLexer lexer = GenericHiveLexer.of(command, null); TokenRewriteStream tokens = new TokenRewriteStream(lexer); - HiveParser parser = new HiveParser(tokens); - parser.setTreeAdaptor(adaptor); - HiveParser_IdentifiersParser.expression_return r = null; + GenericHiveParser parser = GenericHiveParser.with(tokens, null, adaptor); + ParserRuleReturnScope r; try { r = parser.expression(); } catch (RecognitionException e) { @@ -336,13 +247,12 @@ public ASTNode parseExpression(String command) throws ParseException { } public ASTNode parseTriggerExpression(String command) throws ParseException { - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + GenericHiveLexer lexer = GenericHiveLexer.of(command, null); TokenRewriteStream tokens = new TokenRewriteStream(lexer); - HiveParser parser = new HiveParser(tokens); - parser.setTreeAdaptor(adaptor); - HiveParser_ResourcePlanParser.triggerExpressionStandalone_return r = null; + GenericHiveParser parser = GenericHiveParser.with(tokens, null, adaptor); + ParserRuleReturnScope r; try { - r = parser.gResourcePlanParser.triggerExpressionStandalone(); + r = parser.triggerExpressionStandalone(); } catch (RecognitionException e) { throw new ParseException(parser.errors); } @@ -352,17 +262,16 @@ public ASTNode parseTriggerExpression(String command) throws ParseException { throw new ParseException(parser.errors); } - return r.getTree(); + return (ASTNode) r.getTree(); } public ASTNode parseTriggerActionExpression(String command) throws ParseException { - HiveLexerX lexer = new HiveLexerX(new ANTLRNoCaseStringStream(command)); + GenericHiveLexer lexer = GenericHiveLexer.of(command, null); TokenRewriteStream tokens = new TokenRewriteStream(lexer); - HiveParser parser = new HiveParser(tokens); - parser.setTreeAdaptor(adaptor); - HiveParser_ResourcePlanParser.triggerActionExpressionStandalone_return r = null; + GenericHiveParser parser = GenericHiveParser.with(tokens, null, adaptor); + ParserRuleReturnScope r; try { - r = parser.gResourcePlanParser.triggerActionExpressionStandalone(); + r = parser.triggerActionExpressionStandalone(); } catch (RecognitionException e) { throw new ParseException(parser.errors); } @@ -372,6 +281,6 @@ public ASTNode parseTriggerActionExpression(String command) throws ParseExceptio throw new ParseException(parser.errors); } - return r.getTree(); + return (ASTNode) r.getTree(); } } diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java index 0de3730351..e56457e536 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/SemanticAnalyzer.java @@ -4402,7 +4402,7 @@ private boolean isAggregateInSelect(Node node, Collection aggregateFunc */ boolean isRegex(String pattern, HiveConf conf) { String qIdSupport = HiveConf.getVar(conf, HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT); - if ( "column".equals(qIdSupport)) { + if ( !"none".equals(qIdSupport)) { return false; } for (int i = 0; i < pattern.length(); i++) { @@ -11679,8 +11679,8 @@ private void setupStats(TableScanDesc tsDesc, QBParseInfo qbp, Table tab, String // db_name.table_name + partitionSec // as the prefix for easy of read during explain and debugging. // Currently, partition spec can only be static partition. - String k = org.apache.hadoop.hive.metastore.utils.MetaStoreUtils.encodeTableName(tblName) + Path.SEPARATOR; - tsDesc.setStatsAggPrefix(tab.getDbName()+"."+k); + String k = FileUtils.escapePathName(tblName).toLowerCase() + Path.SEPARATOR; + tsDesc.setStatsAggPrefix(FileUtils.escapePathName(tab.getDbName()).toLowerCase() + "." + k); // set up WriteEntity for replication and txn stats WriteEntity we = new WriteEntity(tab, WriteEntity.WriteType.DDL_SHARED); @@ -15125,7 +15125,8 @@ private String getQueryStringFromAst(ASTNode ast) { int endIdx = ast.getTokenStopIndex(); boolean queryNeedsQuotes = true; - if (conf.getVar(ConfVars.HIVE_QUOTEDID_SUPPORT).equals("none")) { + Quotation quotation = Quotation.from(conf); + if (quotation == Quotation.NONE) { queryNeedsQuotes = false; } @@ -15136,10 +15137,16 @@ private String getQueryStringFromAst(ASTNode ast) { } else if (queryNeedsQuotes && curTok.getType() == HiveLexer.Identifier) { // The Tokens have no distinction between Identifiers and QuotedIdentifiers. // Ugly solution is just to surround all identifiers with quotes. - sb.append('`'); - // Re-escape any backtick (`) characters in the identifier. - sb.append(curTok.getText().replaceAll("`", "``")); - sb.append('`'); + if (quotation == Quotation.BACKTICKS) { + sb.append('`'); + // Re-escape any backtick (`) characters in the identifier. + sb.append(curTok.getText().replaceAll("`", "``")); + sb.append('`'); + } else if (quotation == Quotation.STANDARD) { + sb.append('\"'); + sb.append(curTok.getText()); + sb.append('\"'); + } } else { sb.append(curTok.getText()); } diff --git ql/src/java/org/apache/hadoop/hive/ql/stats/BasicStatsTask.java ql/src/java/org/apache/hadoop/hive/ql/stats/BasicStatsTask.java index 6eb1ca2645..016d611cb1 100644 --- ql/src/java/org/apache/hadoop/hive/ql/stats/BasicStatsTask.java +++ ql/src/java/org/apache/hadoop/hive/ql/stats/BasicStatsTask.java @@ -32,6 +32,7 @@ import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.common.StatsSetupConst; import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.conf.HiveConf.ConfVars; @@ -193,10 +194,10 @@ private String getAggregationPrefix(Table table, Partition partition) throws Met private String getAggregationPrefix0(Table table, Partition partition) throws MetaException { // prefix is of the form dbName.tblName - String prefix = table.getDbName() + "." + MetaStoreUtils.encodeTableName(table.getTableName()); + String prefix = FileUtils.escapePathName(table.getDbName()).toLowerCase() + "." + + FileUtils.escapePathName(table.getTableName()).toLowerCase(); // FIXME: this is a secret contract; reusein getAggrKey() creates a more closer relation to the StatsGatherer // prefix = work.getAggKey(); - prefix = prefix.toLowerCase(); if (partition != null) { return Utilities.join(prefix, Warehouse.makePartPath(partition.getSpec())); } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFCastFormat.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFCastFormat.java index 81540ba8c1..6e24f9cf0a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFCastFormat.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDFCastFormat.java @@ -28,7 +28,7 @@ import org.apache.hadoop.hive.ql.exec.Description; import org.apache.hadoop.hive.ql.exec.UDFArgumentException; import org.apache.hadoop.hive.ql.metadata.HiveException; -import org.apache.hadoop.hive.ql.parse.HiveParser_IdentifiersParser; +import org.apache.hadoop.hive.ql.parse.HiveParser; import org.apache.hadoop.hive.serde.serdeConstants; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; @@ -75,11 +75,11 @@ @VisibleForTesting static final Map OUTPUT_TYPES = ImmutableMap.builder() - .put(HiveParser_IdentifiersParser.TOK_STRING, serdeConstants.STRING_TYPE_NAME) - .put(HiveParser_IdentifiersParser.TOK_VARCHAR, serdeConstants.VARCHAR_TYPE_NAME) - .put(HiveParser_IdentifiersParser.TOK_CHAR, serdeConstants.CHAR_TYPE_NAME) - .put(HiveParser_IdentifiersParser.TOK_TIMESTAMP, serdeConstants.TIMESTAMP_TYPE_NAME) - .put(HiveParser_IdentifiersParser.TOK_DATE, serdeConstants.DATE_TYPE_NAME).build(); + .put(HiveParser.TOK_STRING, serdeConstants.STRING_TYPE_NAME) + .put(HiveParser.TOK_VARCHAR, serdeConstants.VARCHAR_TYPE_NAME) + .put(HiveParser.TOK_CHAR, serdeConstants.CHAR_TYPE_NAME) + .put(HiveParser.TOK_TIMESTAMP, serdeConstants.TIMESTAMP_TYPE_NAME) + .put(HiveParser.TOK_DATE, serdeConstants.DATE_TYPE_NAME).build(); private transient HiveSqlDateTimeFormatter formatter; private transient PrimitiveObjectInspector outputOI; diff --git ql/src/test/org/apache/hadoop/hive/ql/metadata/TestHiveUtils.java ql/src/test/org/apache/hadoop/hive/ql/metadata/TestHiveUtils.java new file mode 100644 index 0000000000..5ab26a5dc4 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/metadata/TestHiveUtils.java @@ -0,0 +1,97 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hive.ql.metadata; + +import static org.apache.hadoop.hive.ql.metadata.HiveUtils.unparseIdentifier; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.*; + +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.parse.Quotation; +import org.junit.Test; + +/** + * Test class for testing methods in {@link HiveUtils}. + */ +public class TestHiveUtils { + @Test + public void testUnparseIdentifierWithBackTicksWhenQuotationIsNone() { + HiveConf conf = createConf(Quotation.NONE); + String id = "any``id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("`any``id`")); + } + + @Test + public void testUnparseIdentifierWithBackTicksWhenQuotationIsBackTicks() { + HiveConf conf = createConf(Quotation.BACKTICKS); + String id = "any``id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("`any````id`")); + } + + @Test + public void testUnparseIdentifierWithBackTicksWhenQuotationIsStandard() { + HiveConf conf = createConf(Quotation.STANDARD); + String id = "any``id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("\"any``id\"")); + } + + @Test + public void testUnparseIdentifierWithDoubleQuotesWhenQuotationIsNone() { + HiveConf conf = createConf(Quotation.NONE); + String id = "any\"\"id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("`any\"\"id`")); + } + + @Test + public void testUnparseIdentifierWithDoubleQuotesWhenQuotationIsBackTicks() { + HiveConf conf = createConf(Quotation.BACKTICKS); + String id = "any\"\"id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("`any\"\"id`")); + } + + @Test + public void testUnparseIdentifierWithDoubleQuotesWhenQuotationIsStandard() { + HiveConf conf = createConf(Quotation.STANDARD); + String id = "any\"\"id"; + + String unparsed = unparseIdentifier(id, conf); + + assertThat(unparsed, is("\"any\"\"\"\"id\"")); + } + + private HiveConf createConf(Quotation quotation) { + HiveConf conf = new HiveConf(); + conf.setVar(HiveConf.ConfVars.HIVE_QUOTEDID_SUPPORT, quotation.stringValue()); + return conf; + } +} \ No newline at end of file diff --git ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFCastFormat.java ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFCastFormat.java index 9afd5af2be..2233b41827 100644 --- ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFCastFormat.java +++ ql/src/test/org/apache/hadoop/hive/ql/udf/generic/TestGenericUDFCastFormat.java @@ -22,7 +22,7 @@ import org.apache.hadoop.hive.common.type.HiveVarchar; import org.apache.hadoop.hive.common.type.Timestamp; import org.apache.hadoop.hive.ql.metadata.HiveException; -import org.apache.hadoop.hive.ql.parse.HiveParser_IdentifiersParser; +import org.apache.hadoop.hive.ql.parse.HiveParser; import org.apache.hadoop.hive.serde2.io.DateWritableV2; import org.apache.hadoop.hive.serde2.io.TimestampWritableV2; import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector; @@ -44,11 +44,11 @@ public class TestGenericUDFCastFormat { //type codes - public static final int CHAR = HiveParser_IdentifiersParser.TOK_CHAR; - public static final int VARCHAR = HiveParser_IdentifiersParser.TOK_VARCHAR; - public static final int STRING = HiveParser_IdentifiersParser.TOK_STRING; - public static final int DATE = HiveParser_IdentifiersParser.TOK_DATE; - public static final int TIMESTAMP = HiveParser_IdentifiersParser.TOK_TIMESTAMP; + public static final int CHAR = HiveParser.TOK_CHAR; + public static final int VARCHAR = HiveParser.TOK_VARCHAR; + public static final int STRING = HiveParser.TOK_STRING; + public static final int DATE = HiveParser.TOK_DATE; + public static final int TIMESTAMP = HiveParser.TOK_TIMESTAMP; @Test public void testDateToStringWithFormat() throws HiveException { diff --git ql/src/test/queries/clientnegative/database_create_invalid_name.q ql/src/test/queries/clientnegative/database_create_invalid_name.q index 5d6749542b..1fd14c1aa1 100644 --- ql/src/test/queries/clientnegative/database_create_invalid_name.q +++ ql/src/test/queries/clientnegative/database_create_invalid_name.q @@ -1,4 +1,4 @@ SHOW DATABASES; -- Try to create a database with an invalid name -CREATE DATABASE `test.db`; +CREATE DATABASE `test§db`; diff --git ql/src/test/queries/clientpositive/quotedid_basic_standard.q ql/src/test/queries/clientpositive/quotedid_basic_standard.q new file mode 100644 index 0000000000..1112057512 --- /dev/null +++ ql/src/test/queries/clientpositive/quotedid_basic_standard.q @@ -0,0 +1,45 @@ +--! qt:dataset:src + +set hive.mapred.mode=nonstrict; + +set hive.support.quoted.identifiers=standard; + +select 3 as "a", 10 as "~!@#$%^&*()_q<>"; + +-- basic +create table t1("x+1" string, "y&y" string, "~!@#$%^&*()_q<>" string); +describe t1; +select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1; +explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1; +explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1'; +explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1'; +explain select "x+1", "y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1'; + +-- case insensitive +explain select "X+1", "Y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&Y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1'; + + +-- escaped back ticks +create table t4("x+1""" string, "y&y" string); +describe t4; +insert into table t4 select * from src; +select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from t4 where "x+1""" = '10' group by "x+1""", "y&y" having "x+1""" = '10'; + +-- view +create view v1 as +select "x+1""", "y&y" +from t4 where "x+1""" < '200'; + +select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from v1 +group by "x+1""", "y&y" +; + +create table lv_table(c1 string) partitioned by(c2 string); +create view "lv~!@#$%^&*()_q<>" partitioned on (c2) as select c1, c2 from lv_table; +alter view "lv~!@#$%^&*()_q<>" add partition (c2='a'); + +set hive.support.quoted.identifiers=column; diff --git ql/src/test/queries/clientpositive/special_character_in_tabnames_1.q ql/src/test/queries/clientpositive/special_character_in_tabnames_1.q index 08df0d803c..215905280e 100644 --- ql/src/test/queries/clientpositive/special_character_in_tabnames_1.q +++ ql/src/test/queries/clientpositive/special_character_in_tabnames_1.q @@ -12,6 +12,9 @@ set hive.strict.checks.cartesian.product=false; -- SORT_QUERY_RESULTS +create database `db~!@#$%^&*(),<>`; +use `db~!@#$%^&*(),<>`; + create table `c/b/o_t1`(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE; create table `//cbo_t2`(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE; create table `cbo_/t3////`(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; @@ -55,7 +58,7 @@ FIELDS TERMINATED BY '|'; LOAD DATA LOCAL INPATH '../../data/files/lineitem.txt' OVERWRITE INTO TABLE `line/item`; -create table `src/_/cbo` as select * from src; +create table `src/_/cbo` as select * from default.src; analyze table `c/b/o_t1` partition (dt) compute statistics; @@ -115,11 +118,11 @@ set hive.auto.convert.join=false; -- 21. Test groupby is empty and there is no other cols in aggr -select unionsrc.key FROM (select 'tst1' as key, count(1) as value from src) unionsrc; +select unionsrc.key FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc; -select unionsrc.key, unionsrc.value FROM (select 'tst1' as key, count(1) as value from src) unionsrc; +select unionsrc.key, unionsrc.value FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc; @@ -1067,15 +1070,15 @@ select * from (select max(c_int) over (partition by key order by value Rows UNBO select i, a, h, b, c, d, e, f, g, a as x, a +1 as y from (select max(c_int) over (partition by key order by value range UNBOUNDED PRECEDING) a, min(c_int) over (partition by key order by value range current row) b, count(c_int) over(partition by key order by value range 1 PRECEDING) c, avg(value) over (partition by key order by value range between unbounded preceding and unbounded following) d, sum(value) over (partition by key order by value range between unbounded preceding and current row) e, avg(c_float) over (partition by key order by value range between 1 preceding and unbounded following) f, sum(c_float) over (partition by key order by value range between 1 preceding and current row) g, max(c_float) over (partition by key order by value range between 1 preceding and unbounded following) h, min(c_float) over (partition by key order by value range between 1 preceding and 1 following) i from `c/b/o_t1`) `c/b/o_t1`; -select *, rank() over(partition by key order by value) as rr from src1; +select *, rank() over(partition by key order by value) as rr from default.src1; -select *, rank() over(partition by key order by value) from src1; +select *, rank() over(partition by key order by value) from default.src1; -insert into table `src/_/cbo` select * from src; +insert into table `src/_/cbo` select * from default.src; select * from `src/_/cbo` limit 1; -insert overwrite table `src/_/cbo` select * from src; +insert overwrite table `src/_/cbo` select * from default.src; select * from `src/_/cbo` limit 1; @@ -1085,3 +1088,5 @@ insert into `t//` values(1); insert into `t//` values(null); analyze table `t//` compute statistics; explain select * from `t//`; + +drop database `db~!@#$%^&*(),<>` cascade; diff --git ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_1.q ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_1.q new file mode 100644 index 0000000000..0ee599f861 --- /dev/null +++ ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_1.q @@ -0,0 +1,1091 @@ +--! qt:dataset:src1 +--! qt:dataset:src +set hive.cbo.enable=true; +set hive.exec.check.crossproducts=false; +set hive.stats.fetch.column.stats=true; +set hive.auto.convert.join=false; +set hive.strict.checks.cartesian.product=false; +set hive.support.quoted.identifiers=standard; + +-- SORT_QUERY_RESULTS + +create database "db~!@#$%^&*(),<>"; +use "db~!@#$%^&*(),<>"; + +create table "c/b/o_t1"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE; +create table "//cbo_t2"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE; +create table "cbo_/t3////"(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE; + +load data local inpath '../../data/files/cbo_t1.txt' into table "c/b/o_t1" partition (dt='2014'); +load data local inpath '../../data/files/cbo_t2.txt' into table "//cbo_t2" partition (dt='2014'); +load data local inpath '../../data/files/cbo_t3.txt' into table "cbo_/t3////"; + +CREATE TABLE "p/a/r/t"( + p_partkey INT, + p_name STRING, + p_mfgr STRING, + p_brand STRING, + p_type STRING, + p_size INT, + p_container STRING, + p_retailprice DOUBLE, + p_comment STRING +); + +LOAD DATA LOCAL INPATH '../../data/files/part_tiny.txt' overwrite into table "p/a/r/t"; + +CREATE TABLE "line/item" (L_ORDERKEY INT, + L_PARTKEY INT, + L_SUPPKEY INT, + L_LINENUMBER INT, + L_QUANTITY DOUBLE, + L_EXTENDEDPRICE DOUBLE, + L_DISCOUNT DOUBLE, + L_TAX DOUBLE, + L_RETURNFLAG STRING, + L_LINESTATUS STRING, + l_shipdate STRING, + L_COMMITDATE STRING, + L_RECEIPTDATE STRING, + L_SHIPINSTRUCT STRING, + L_SHIPMODE STRING, + L_COMMENT STRING) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY '|'; + +LOAD DATA LOCAL INPATH '../../data/files/lineitem.txt' OVERWRITE INTO TABLE "line/item"; + +create table "src/_/cbo" as select * from default.src; + +analyze table "c/b/o_t1" partition (dt) compute statistics; + +analyze table "c/b/o_t1" compute statistics for columns key, value, c_int, c_float, c_boolean; + +analyze table "//cbo_t2" partition (dt) compute statistics; + +analyze table "//cbo_t2" compute statistics for columns key, value, c_int, c_float, c_boolean; + +analyze table "cbo_/t3////" compute statistics; + +analyze table "cbo_/t3////" compute statistics for columns key, value, c_int, c_float, c_boolean; + +analyze table "src/_/cbo" compute statistics; + +analyze table "src/_/cbo" compute statistics for columns; + +analyze table "p/a/r/t" compute statistics; + +analyze table "p/a/r/t" compute statistics for columns; + +analyze table "line/item" compute statistics; + +analyze table "line/item" compute statistics for columns; + +select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key; + +select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x; + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c; + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int desc; + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) "c/b/o_t1" right outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 2) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c; + + + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) "c/b/o_t1" full outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int; + + + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 21. Test groupby is empty and there is no other cols in aggr + +select unionsrc.key FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc; + + + +select unionsrc.key, unionsrc.value FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc; + + + +select unionsrc.key FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key; + + + +select unionsrc.key, unionsrc.value FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key; + + + +select unionsrc.key, count(1) FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + + UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc group by unionsrc.key order by unionsrc.key; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- SORT_QUERY_RESULTS + +-- 4. Test Select + Join + TS + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key; + +select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////"; + +select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////" where "c/b/o_t1".key="cbo_/t3////".key and "c/b/o_t1".key >= 1; + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key; + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key; + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key; + + + +select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key; + +select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a; + +select a, "c/b/o_t1".b, key, "//cbo_t2".c_int, "cbo_/t3////".p from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a=key join (select key as p, c_int as q, "cbo_/t3////".c_float as r from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".p; + +select b, "c/b/o_t1".c, "//cbo_t2".c_int, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key; + +select "cbo_/t3////".c_int, b, "//cbo_t2".c_int, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key; + + + +select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key; + +select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p left outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a; + + + +select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key; + +select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p right outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a; + + + +select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key; + +select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p full outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a; + + + +-- 5. Test Select + Join + FIL + TS + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0); + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0); + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0); + +select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0); + + + +select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or "//cbo_t2".q >= 0); + + + +select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0); + + + +select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0); + + + +select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0); + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 7. Test Select + TS + Join + Fil + GB + GB Having + Limit + +select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key order by x limit 1; + +select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x order by x,y limit 1; + +select key from(select key from (select key from "c/b/o_t1" order by key limit 5)"//cbo_t2" order by key limit 5)"cbo_/t3////" order by key limit 5; + +select key, c_int from(select key, c_int from (select key, c_int from "c/b/o_t1" order by c_int limit 5)"c/b/o_t1" order by c_int limit 5)"//cbo_t2" order by c_int limit 5; + + + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a limit 5) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc limit 5) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c limit 5; + + + +select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int, c desc limit 5; + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 12. SemiJoin + +select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key; + +select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0); + +select * from (select c, b, a from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0); + +select * from (select "cbo_/t3////".c_int, "c/b/o_t1".c, b from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 = 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "cbo_/t3////".c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0); + +select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0); + +select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a; + +select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 1. Test Select + TS + +select * from "c/b/o_t1"; + +select * from "c/b/o_t1" as "c/b/o_t1"; + +select * from "c/b/o_t1" as "//cbo_t2"; + + + +select "c/b/o_t1".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1"; + +select * from "c/b/o_t1" where (((key=1) and (c_float=10)) and (c_int=20)); + + + +-- 2. Test Select + TS + FIL + +select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0; + +select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + + + +select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + + + +-- 3 Test Select + Select + TS + FIL + +select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1"; + +select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1"; + +select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1"; + +select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1"; + + + +select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0; + +select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100; + + + +select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0; + +select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0; + + + + + + + +select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0; + +select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100; + +select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100; + + + +select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0; + +select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0; + + + + + + + +-- 13. null expr in select list + +select null from "cbo_/t3////"; + + + +-- 14. unary operator + +select key from "c/b/o_t1" where c_int = -6 or c_int = +6; + + + +-- 15. query referencing only partition columns + +select count("c/b/o_t1".dt) from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".dt = "//cbo_t2".dt where "c/b/o_t1".dt = '2014' ; + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 20. Test get stats with empty partition list + +select "c/b/o_t1".value from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key = "//cbo_t2".key where "c/b/o_t1".dt = '10' and "c/b/o_t1".c_boolean = true; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 18. SubQueries Not Exists + +-- distinct, corr + +select * + +from "src/_/cbo" b + +where not exists + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.value > 'val_2' + + ) + +; + + + +-- no agg, corr, having + +select * + +from "src/_/cbo" b + +group by key, value + +having not exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_12' + + ) + +; + + + +-- 19. SubQueries Exists + +-- view test + +create view cv1 as + +select * + +from "src/_/cbo" b + +where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') + +; + + + +select * from cv1 + +; + + + +-- sq in from + +select * + +from (select * + + from "src/_/cbo" b + + where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') + + ) a + +; + + + +-- sq in from, having + +select * + +from (select b.key, count(*) + + from "src/_/cbo" b + + group by b.key + + having exists + + (select a.key + + from "src/_/cbo" a + + where a.key = b.key and a.value > 'val_9' + + ) + +) a + +; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 17. SubQueries In + +-- non agg, non corr + +select * + +from "src/_/cbo" + +where "src/_/cbo".key in (select key from "src/_/cbo" s1 where s1.key > '9') order by key + +; + + + +-- agg, corr + +-- add back once rank issue fixed for cbo + + + +-- distinct, corr + +select * + +from "src/_/cbo" b + +where b.key in + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key > '9' + + ) order by b.key + +; + + + +-- non agg, corr, with join in Parent Query + +select p.p_partkey, li.l_suppkey + +from (select distinct l_partkey as p_partkey from "line/item") p join "line/item" li on p.p_partkey = li.l_partkey + +where li.l_linenumber = 1 and + + li.l_orderkey in (select l_orderkey from "line/item" where l_shipmode = 'AIR' and l_linenumber = li.l_linenumber) + + order by p.p_partkey + +; + + + +-- where and having + +-- Plan is: + +-- Stage 1: b semijoin sq1:"src/_/cbo" (subquery in where) + +-- Stage 2: group by Stage 1 o/p + +-- Stage 5: group by on sq2:"src/_/cbo" (subquery in having) + +-- Stage 6: Stage 2 o/p semijoin Stage 5 + +select key, value, count(*) + +from "src/_/cbo" b + +where b.key in (select key from "src/_/cbo" where "src/_/cbo".key > '8') + +group by key, value + +having count(*) in (select count(*) from "src/_/cbo" s1 where s1.key > '9' group by s1.key ) order by key + +; + + + +-- non agg, non corr, windowing + +select p_mfgr, p_name, avg(p_size) + +from "p/a/r/t" + +group by p_mfgr, p_name + +having p_name in + + (select first_value(p_name) over(partition by p_mfgr order by p_size) from "p/a/r/t") order by p_mfgr + +; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 16. SubQueries Not In + +-- non agg, non corr + +select * + +from "src/_/cbo" + +where "src/_/cbo".key not in + + ( select key from "src/_/cbo" s1 + + where s1.key > '2' + + ) order by key + +; + + + +-- non agg, corr + +select p_mfgr, b.p_name, p_size + +from "p/a/r/t" b + +where b.p_name not in + + (select p_name + + from (select p_mfgr, p_name, p_size as r from "p/a/r/t") a + + where r < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_mfgr,p_size + +; + + + +-- agg, non corr + +select p_name, p_size + +from + +"p/a/r/t" where "p/a/r/t".p_size not in + + (select avg(p_size) + + from (select p_size from "p/a/r/t") a + + where p_size < 10 + + ) order by p_name + +; + + + +-- agg, corr + +select p_mfgr, p_name, p_size + +from "p/a/r/t" b where b.p_size not in + + (select min(p_size) + + from (select p_mfgr, p_size from "p/a/r/t") a + + where p_size < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_name + +; + + + +-- non agg, non corr, Group By in Parent Query + +select li.l_partkey, count(*) + +from "line/item" li + +where li.l_linenumber = 1 and + + li.l_orderkey not in (select l_orderkey from "line/item" where l_shipmode = 'AIR') + +group by li.l_partkey order by li.l_partkey + +; + + + +-- add null check test from sq_notin.q once HIVE-7721 resolved. + + + +-- non agg, corr, having + +select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from (select p_mfgr, min(p_retailprice) l, max(p_retailprice) r, avg(p_retailprice) a from "p/a/r/t" group by p_mfgr) a + + where min(p_retailprice) = l and r - l > 600 + + ) + + order by b.p_mfgr + +; + + + +-- agg, non corr, having + +select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from "p/a/r/t" a + + group by p_mfgr + + having max(p_retailprice) - min(p_retailprice) > 600 + + ) + + order by b.p_mfgr + +; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- SORT_QUERY_RESULTS + + + +-- 8. Test UDF/UDAF + +select count(*), count(c_int), sum(c_int), avg(c_int), max(c_int), min(c_int) from "c/b/o_t1"; + +select count(*), count(c_int) as a, sum(c_int), avg(c_int), max(c_int), min(c_int), case c_int when 0 then 1 when 1 then 2 else 3 end, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) from "c/b/o_t1" group by c_int order by a; + +select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1"; + +select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f, case c_int when 0 then 1 when 1 then 2 else 3 end as g, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) as h from "c/b/o_t1" group by c_int) "c/b/o_t1" order by a; + +select f,a,e,b from (select count(*) as a, count(c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1"; + +select f,a,e,b from (select count(*) as a, count(distinct c_int) as b, sum(distinct c_int) as c, avg(distinct c_int) as d, max(distinct c_int) as e, min(distinct c_int) as f from "c/b/o_t1") "c/b/o_t1"; + +select key,count(c_int) as a, avg(c_float) from "c/b/o_t1" group by key order by a; + +select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float order by a; + +select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_int order by a; + +select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float, c_int order by a; + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- SORT_QUERY_RESULTS + + + +-- 11. Union All + +select * from (select * from "c/b/o_t1" order by key, c_boolean, value, dt)a union all select * from (select * from "//cbo_t2" order by key, c_boolean, value, dt)b; + +select key from (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r2 where key >=0 order by key; + +select r2.key from (select key, c_int from (select key, c_int from "c/b/o_t1" union all select key, c_int from "cbo_/t3////" )r1 union all select key, c_int from "cbo_/t3////")r2 join (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r3 on r2.key=r3.key where r3.key >=0 order by r2.key; + + + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 10. Test views + +create view v1 as select c_int, value, c_boolean, dt from "c/b/o_t1"; + +create view v2 as select c_int, value from "//cbo_t2"; + + + +select value from v1 where c_boolean=false; + +select max(c_int) from v1 group by (c_boolean); + + + +select count(v1.c_int) from v1 join "//cbo_t2" on v1.c_int = "//cbo_t2".c_int; + +select count(v1.c_int) from v1 join v2 on v1.c_int = v2.c_int; + + + +select count(*) from v1 a join v1 b on a.value = b.value; + + + +create view v3 as select v1.value val from v1 join "c/b/o_t1" on v1.c_boolean = "c/b/o_t1".c_boolean; + + + +select count(val) from v3 where val != '1'; + +with q1 as ( select key from "c/b/o_t1" where key = '1') + +select count(*) from q1; + + + +with q1 as ( select value from v1 where c_boolean = false) + +select count(value) from q1 ; + + + +create view v4 as + +with q1 as ( select key,c_int from "c/b/o_t1" where key = '1') + +select * from q1 + +; + + + +with q1 as ( select c_int from q2 where c_boolean = false), + +q2 as ( select c_int,c_boolean from v1 where value = '1') + +select sum(c_int) from (select c_int from q1) a; + + + +with q1 as ( select "c/b/o_t1".c_int c_int from q2 join "c/b/o_t1" where q2.c_int = "c/b/o_t1".c_int and "c/b/o_t1".dt='2014'), + +q2 as ( select c_int,c_boolean from v1 where value = '1' or dt = '14') + +select count(*) from q1 join q2 join v4 on q1.c_int = q2.c_int and v4.c_int = q2.c_int; + + + + + +drop view v1; + +drop view v2; + +drop view v3; + +drop view v4; + +set hive.cbo.enable=false; + +set hive.exec.check.crossproducts=false; + + + +set hive.stats.fetch.column.stats=true; + +set hive.auto.convert.join=false; + + + +-- 9. Test Windowing Functions + +-- SORT_QUERY_RESULTS + + + +select count(c_int) over() from "c/b/o_t1"; + +select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key), 2), lead(c_int, 2, c_int) over(partition by c_float order by key), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn; + +select * from (select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key),2), lead(c_int, 2, c_int) over(partition by c_float order by key ), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn) "c/b/o_t1"; + +select x from (select count(c_int) over() as x, sum(c_float) over() from "c/b/o_t1") "c/b/o_t1"; + +select 1+sum(c_int) over() from "c/b/o_t1"; + +select sum(c_int)+sum(sum(c_int)) over() from "c/b/o_t1"; + +select * from (select max(c_int) over (partition by key order by value Rows UNBOUNDED PRECEDING), min(c_int) over (partition by key order by value rows current row), count(c_int) over(partition by key order by value ROWS 1 PRECEDING), avg(value) over (partition by key order by value Rows between unbounded preceding and unbounded following), sum(value) over (partition by key order by value rows between unbounded preceding and current row), avg(c_float) over (partition by key order by value Rows between 1 preceding and unbounded following), sum(c_float) over (partition by key order by value rows between 1 preceding and current row), max(c_float) over (partition by key order by value rows between 1 preceding and unbounded following), min(c_float) over (partition by key order by value rows between 1 preceding and 1 following) from "c/b/o_t1") "c/b/o_t1"; + +select i, a, h, b, c, d, e, f, g, a as x, a +1 as y from (select max(c_int) over (partition by key order by value range UNBOUNDED PRECEDING) a, min(c_int) over (partition by key order by value range current row) b, count(c_int) over(partition by key order by value range 1 PRECEDING) c, avg(value) over (partition by key order by value range between unbounded preceding and unbounded following) d, sum(value) over (partition by key order by value range between unbounded preceding and current row) e, avg(c_float) over (partition by key order by value range between 1 preceding and unbounded following) f, sum(c_float) over (partition by key order by value range between 1 preceding and current row) g, max(c_float) over (partition by key order by value range between 1 preceding and unbounded following) h, min(c_float) over (partition by key order by value range between 1 preceding and 1 following) i from "c/b/o_t1") "c/b/o_t1"; + +select *, rank() over(partition by key order by value) as rr from default.src1; + +select *, rank() over(partition by key order by value) from default.src1; + +insert into table "src/_/cbo" select * from default.src; + +select * from "src/_/cbo" order by key limit 1; + +insert overwrite table "src/_/cbo" select * from default.src; + +select * from "src/_/cbo" order by key limit 1; + +drop table "t//"; +create table "t//" (col string); +insert into "t//" values(1); +insert into "t//" values(null); +analyze table "t//" compute statistics; +explain select * from "t//"; + +drop database "db~!@#$%^&*(),<>" cascade; + +set hive.support.quoted.identifiers=column; diff --git ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_2.q ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_2.q new file mode 100644 index 0000000000..3aec3169f5 --- /dev/null +++ ql/src/test/queries/clientpositive/special_character_in_tabnames_quotes_2.q @@ -0,0 +1,24 @@ +set hive.cbo.enable=true; +set hive.support.quoted.identifiers=standard; + +-- try the query without indexing, with manual indexing, and with automatic indexing +-- SORT_QUERY_RESULTS + +DROP TABLE IF EXISTS "s/c"; + +CREATE TABLE "s/c" (key STRING COMMENT 'default', value STRING COMMENT 'default') STORED AS TEXTFILE; + +LOAD DATA LOCAL INPATH '../../data/files/kv1.txt' INTO TABLE "s/c"; + +ANALYZE TABLE "s/c" COMPUTE STATISTICS; + +ANALYZE TABLE "s/c" COMPUTE STATISTICS FOR COLUMNS key,value; + +describe formatted "s/c"; + +SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100; + +EXPLAIN SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100; +SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100; + +set hive.support.quoted.identifiers=column; diff --git ql/src/test/results/clientnegative/database_create_invalid_name.q.out ql/src/test/results/clientnegative/database_create_invalid_name.q.out index 4b2cd1e41b..9dba025d9c 100644 --- ql/src/test/results/clientnegative/database_create_invalid_name.q.out +++ ql/src/test/results/clientnegative/database_create_invalid_name.q.out @@ -3,7 +3,7 @@ PREHOOK: type: SHOWDATABASES POSTHOOK: query: SHOW DATABASES POSTHOOK: type: SHOWDATABASES default -PREHOOK: query: CREATE DATABASE `test.db` +PREHOOK: query: CREATE DATABASE `test§db` PREHOOK: type: CREATEDATABASE -PREHOOK: Output: database:test.db -FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.ddl.DDLTask. InvalidObjectException(message:test.db is not a valid database name) +PREHOOK: Output: database:test§db +FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.ddl.DDLTask. InvalidObjectException(message:test§db is not a valid database name) diff --git ql/src/test/results/clientpositive/special_character_in_tabnames_2.q.out ql/src/test/results/clientpositive/llap/special_character_in_tabnames_2.q.out similarity index 69% rename from ql/src/test/results/clientpositive/special_character_in_tabnames_2.q.out rename to ql/src/test/results/clientpositive/llap/special_character_in_tabnames_2.q.out index b1a808a805..f1fa1886bd 100644 --- ql/src/test/results/clientpositive/special_character_in_tabnames_2.q.out +++ ql/src/test/results/clientpositive/llap/special_character_in_tabnames_2.q.out @@ -72,38 +72,22 @@ POSTHOOK: type: QUERY POSTHOOK: Input: default@s/c #### A masked pattern was here #### STAGE DEPENDENCIES: - Stage-1 is a root stage - Stage-0 depends on stages: Stage-1 + Stage-0 is a root stage STAGE PLANS: - Stage: Stage-1 - Map Reduce - Map Operator Tree: - TableScan - alias: s/c - filterExpr: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator - predicate: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) - Statistics: Num rows: 55 Data size: 9790 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 55 Data size: 9790 Basic stats: COMPLETE Column stats: COMPLETE - File Output Operator - compressed: false - Statistics: Num rows: 55 Data size: 9790 Basic stats: COMPLETE Column stats: COMPLETE - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - Execution mode: vectorized - Stage: Stage-0 Fetch Operator limit: -1 Processor Tree: - ListSink + TableScan + alias: s/c + filterExpr: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) + Filter Operator + predicate: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + ListSink PREHOOK: query: SELECT key, value FROM `s/c` WHERE key > 80 AND key < 100 PREHOOK: type: QUERY diff --git ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_1.q.out ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_1.q.out new file mode 100644 index 0000000000..08dcea6851 --- /dev/null +++ ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_1.q.out @@ -0,0 +1,19456 @@ +PREHOOK: query: create database "db~!@#$%^&*(),<>" +PREHOOK: type: CREATEDATABASE +PREHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: query: create database "db~!@#$%^&*(),<>" +POSTHOOK: type: CREATEDATABASE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: query: use "db~!@#$%^&*(),<>" +PREHOOK: type: SWITCHDATABASE +PREHOOK: Input: database:db~!@#$%^&*(),<> +POSTHOOK: query: use "db~!@#$%^&*(),<>" +POSTHOOK: type: SWITCHDATABASE +POSTHOOK: Input: database:db~!@#$%^&*(),<> +PREHOOK: query: create table "c/b/o_t1"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: query: create table "c/b/o_t1"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: query: create table "//cbo_t2"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: query: create table "//cbo_t2"(key string, value string, c_int int, c_float float, c_boolean boolean) partitioned by (dt string) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: query: create table "cbo_/t3////"(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: query: create table "cbo_/t3////"(key string, value string, c_int int, c_float float, c_boolean boolean) row format delimited fields terminated by ',' STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: query: load data local inpath '../../data/files/cbo_t1.txt' into table "c/b/o_t1" partition (dt='2014') +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t1.txt' into table "c/b/o_t1" partition (dt='2014') +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: query: load data local inpath '../../data/files/cbo_t2.txt' into table "//cbo_t2" partition (dt='2014') +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: query: load data local inpath '../../data/files/cbo_t2.txt' into table "//cbo_t2" partition (dt='2014') +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: query: load data local inpath '../../data/files/cbo_t3.txt' into table "cbo_/t3////" +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: query: load data local inpath '../../data/files/cbo_t3.txt' into table "cbo_/t3////" +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: query: CREATE TABLE "p/a/r/t"( + p_partkey INT, + p_name STRING, + p_mfgr STRING, + p_brand STRING, + p_type STRING, + p_size INT, + p_container STRING, + p_retailprice DOUBLE, + p_comment STRING +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: query: CREATE TABLE "p/a/r/t"( + p_partkey INT, + p_name STRING, + p_mfgr STRING, + p_brand STRING, + p_type STRING, + p_size INT, + p_container STRING, + p_retailprice DOUBLE, + p_comment STRING +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/part_tiny.txt' overwrite into table "p/a/r/t" +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/part_tiny.txt' overwrite into table "p/a/r/t" +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: query: CREATE TABLE "line/item" (L_ORDERKEY INT, + L_PARTKEY INT, + L_SUPPKEY INT, + L_LINENUMBER INT, + L_QUANTITY DOUBLE, + L_EXTENDEDPRICE DOUBLE, + L_DISCOUNT DOUBLE, + L_TAX DOUBLE, + L_RETURNFLAG STRING, + L_LINESTATUS STRING, + l_shipdate STRING, + L_COMMITDATE STRING, + L_RECEIPTDATE STRING, + L_SHIPINSTRUCT STRING, + L_SHIPMODE STRING, + L_COMMENT STRING) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY '|' +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@line/item +POSTHOOK: query: CREATE TABLE "line/item" (L_ORDERKEY INT, + L_PARTKEY INT, + L_SUPPKEY INT, + L_LINENUMBER INT, + L_QUANTITY DOUBLE, + L_EXTENDEDPRICE DOUBLE, + L_DISCOUNT DOUBLE, + L_TAX DOUBLE, + L_RETURNFLAG STRING, + L_LINESTATUS STRING, + l_shipdate STRING, + L_COMMITDATE STRING, + L_RECEIPTDATE STRING, + L_SHIPINSTRUCT STRING, + L_SHIPMODE STRING, + L_COMMENT STRING) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY '|' +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@line/item +PREHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/lineitem.txt' OVERWRITE INTO TABLE "line/item" +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: db~!@#$%^&*(),<>@line/item +POSTHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/lineitem.txt' OVERWRITE INTO TABLE "line/item" +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: db~!@#$%^&*(),<>@line/item +PREHOOK: query: create table "src/_/cbo" as select * from default.src +PREHOOK: type: CREATETABLE_AS_SELECT +PREHOOK: Input: default@src +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: query: create table "src/_/cbo" as select * from default.src +POSTHOOK: type: CREATETABLE_AS_SELECT +POSTHOOK: Input: default@src +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Lineage: src/_/cbo.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: src/_/cbo.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +PREHOOK: query: analyze table "c/b/o_t1" partition (dt) compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: query: analyze table "c/b/o_t1" partition (dt) compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: query: analyze table "c/b/o_t1" compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: analyze table "c/b/o_t1" compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +PREHOOK: query: analyze table "//cbo_t2" partition (dt) compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: query: analyze table "//cbo_t2" partition (dt) compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: query: analyze table "//cbo_t2" compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: analyze table "//cbo_t2" compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +#### A masked pattern was here #### +PREHOOK: query: analyze table "cbo_/t3////" compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: query: analyze table "cbo_/t3////" compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: query: analyze table "cbo_/t3////" compute statistics for columns key, value, c_int, c_float, c_boolean +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: analyze table "cbo_/t3////" compute statistics for columns key, value, c_int, c_float, c_boolean +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +PREHOOK: query: analyze table "src/_/cbo" compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: query: analyze table "src/_/cbo" compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +PREHOOK: query: analyze table "src/_/cbo" compute statistics for columns +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: analyze table "src/_/cbo" compute statistics for columns +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +PREHOOK: query: analyze table "p/a/r/t" compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: query: analyze table "p/a/r/t" compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: query: analyze table "p/a/r/t" compute statistics for columns +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: analyze table "p/a/r/t" compute statistics for columns +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +PREHOOK: query: analyze table "line/item" compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@line/item +PREHOOK: Output: db~!@#$%^&*(),<>@line/item +POSTHOOK: query: analyze table "line/item" compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@line/item +POSTHOOK: Output: db~!@#$%^&*(),<>@line/item +PREHOOK: query: analyze table "line/item" compute statistics for columns +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: db~!@#$%^&*(),<>@line/item +PREHOOK: Output: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +POSTHOOK: query: analyze table "line/item" compute statistics for columns +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: db~!@#$%^&*(),<>@line/item +POSTHOOK: Output: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +PREHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 4 2 + 1 4 2 +1 4 12 +1 4 2 +NULL NULL NULL +PREHOOK: query: select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +5.0 12 1 +5.0 2 3 +NULL NULL 1 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int desc +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int desc +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) "c/b/o_t1" right outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 2) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b+c, a desc) "c/b/o_t1" right outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 2) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) "c/b/o_t1" full outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by c+a desc) "c/b/o_t1" full outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by p+q desc, r asc) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select unionsrc.key FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select unionsrc.key FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +tst1 +PREHOOK: query: select unionsrc.key, unionsrc.value FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select unionsrc.key, unionsrc.value FROM (select 'tst1' as key, count(1) as value from default.src) unionsrc +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +tst1 500 +PREHOOK: query: select unionsrc.key FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select unionsrc.key FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +avg +max +min +PREHOOK: query: select unionsrc.key, unionsrc.value FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select unionsrc.key, unionsrc.value FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + +UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc order by unionsrc.key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +avg 1.5 +max 3.0 +min 1.0 +PREHOOK: query: select unionsrc.key, count(1) FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + + UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc group by unionsrc.key order by unionsrc.key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select unionsrc.key, count(1) FROM (select 'max' as key, max(c_int) as value from "cbo_/t3////" s1 + + UNION ALL + + select 'min' as key, min(c_int) as value from "cbo_/t3////" s2 + + UNION ALL + + select 'avg' as key, avg(c_int) as value from "cbo_/t3////" s3) unionsrc group by unionsrc.key order by unionsrc.key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +avg 1 +max 1 +min 1 +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +PREHOOK: query: select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////" where "c/b/o_t1".key="cbo_/t3////".key and "c/b/o_t1".key >= 1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".key from "c/b/o_t1" join "cbo_/t3////" where "c/b/o_t1".key="cbo_/t3////".key and "c/b/o_t1".key >= 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL NULL +NULL NULL +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL NULL +NULL NULL +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL 2 +NULL NULL +NULL NULL +NULL NULL +NULL NULL +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +PREHOOK: query: select a, "c/b/o_t1".b, key, "//cbo_t2".c_int, "cbo_/t3////".p from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a=key join (select key as p, c_int as q, "cbo_/t3////".c_float as r from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".p +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select a, "c/b/o_t1".b, key, "//cbo_t2".c_int, "cbo_/t3////".p from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a=key join (select key as p, c_int as q, "cbo_/t3////".c_float as r from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".p +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 + 1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +1 1 1 1 1 +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".c_int, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".c_int, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +1 1.0 1 1 +PREHOOK: query: select "cbo_/t3////".c_int, b, "//cbo_t2".c_int, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, b, "//cbo_t2".c_int, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".a="//cbo_t2".key join "cbo_/t3////" on "c/b/o_t1".a="cbo_/t3////".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +1 1 1 1.0 +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p left outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p left outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p right outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p right outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1") "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p full outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select key, "c/b/o_t1".c_int, "//cbo_t2".p, q from "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2") "//cbo_t2" on "c/b/o_t1".key=p full outer join (select key as a, c_int as b, "cbo_/t3////".c_float as c from "cbo_/t3////")"cbo_/t3////" on "c/b/o_t1".key=a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 + 1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +1 1 1 1 +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +NULL NULL NULL NULL +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" left outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" right outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int, "//cbo_t2".c_int from "c/b/o_t1" full outer join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + "//cbo_t2".c_int == 2) and ("c/b/o_t1".c_int > 0 or "//cbo_t2".c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or "//cbo_t2".q >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select b, "c/b/o_t1".c, "//cbo_t2".p, q, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or "//cbo_t2".q >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +1 1.0 1 1 1 +PREHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" right outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select q, b, "//cbo_t2".p, "c/b/o_t1".c, "cbo_/t3////".c_int from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" full outer join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q == 2) and (b > 0 or c_int >= 0)) R where (q + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +1 1 1 1.0 1 +PREHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key order by x limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key, (c_int+1)+2 as x, sum(c_int) from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key order by x limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 4 2 +PREHOOK: query: select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x order by x,y limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from "c/b/o_t1" group by c_float, "c/b/o_t1".c_int, key) R group by y, x order by x,y limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +5.0 2 3 +PREHOOK: query: select key from(select key from (select key from "c/b/o_t1" order by key limit 5)"//cbo_t2" order by key limit 5)"cbo_/t3////" order by key limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key from(select key from (select key from "c/b/o_t1" order by key limit 5)"//cbo_t2" order by key limit 5)"cbo_/t3////" order by key limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 + 1 + 1 + 1 +1 +PREHOOK: query: select key, c_int from(select key, c_int from (select key, c_int from "c/b/o_t1" order by c_int limit 5)"c/b/o_t1" order by c_int limit 5)"//cbo_t2" order by c_int limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key, c_int from(select key, c_int from (select key, c_int from "c/b/o_t1" order by c_int limit 5)"c/b/o_t1" order by c_int limit 5)"//cbo_t2" order by c_int limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 +1 1 +1 1 +1 1 +1 1 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a limit 5) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc limit 5) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key order by a limit 5) "c/b/o_t1" join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key order by q/10 desc, r asc limit 5) "//cbo_t2" on "c/b/o_t1".a=p join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c order by "cbo_/t3////".c_int+c desc, c limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int, c desc limit 5 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select "cbo_/t3////".c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by b % c asc, b desc limit 5) "c/b/o_t1" left outer join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 limit 5) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "//cbo_t2".q >= 0) and (b > 0 or c_int >= 0) group by "cbo_/t3////".c_int, c having "cbo_/t3////".c_int > 0 and (c_int >=1 or c >= 1) and (c_int + c) >= 0 order by "cbo_/t3////".c_int % c asc, "cbo_/t3////".c_int, c desc limit 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 12 6 +1 2 6 +PREHOOK: query: select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +PREHOOK: query: select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int from "c/b/o_t1" left semi join "//cbo_t2" on "c/b/o_t1".key="//cbo_t2".key where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +PREHOOK: query: select * from (select c, b, a from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c, b, a from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c >= 0)) R where (b + 1 = 2) and (R.b > 0 or c >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +1.0 1 1 +PREHOOK: query: select * from (select "cbo_/t3////".c_int, "c/b/o_t1".c, b from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 = 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "cbo_/t3////".c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select "cbo_/t3////".c_int, "c/b/o_t1".c, b from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 = 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p left outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + "cbo_/t3////".c_int == 2) and (b > 0 or c_int >= 0)) R where (R.c_int + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +1 1.0 1 +PREHOOK: query: select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p right outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +PREHOOK: query: select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select * from (select c_int, b, "c/b/o_t1".c from (select key as a, c_int as b, "c/b/o_t1".c_float as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 == 2) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0)) "c/b/o_t1" left semi join (select "//cbo_t2".key as p, "//cbo_t2".c_int as q, c_float as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 == 2) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0)) "//cbo_t2" on "c/b/o_t1".a=p full outer join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 == 2) and (b > 0 or c_int >= 0)) R where (c + 1 = 2) and (R.b > 0 or c_int >= 0) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +1 1 1.0 +PREHOOK: query: select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 2 1 + 1 2 1 +1 12 1 +1 2 1 +PREHOOK: query: select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select a, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from "c/b/o_t1" where ("c/b/o_t1".c_int + 1 >= 0) and ("c/b/o_t1".c_int > 0 or "c/b/o_t1".c_float >= 0) group by c_float, "c/b/o_t1".c_int, key having "c/b/o_t1".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by a+b desc, c asc limit 5) "c/b/o_t1" left semi join (select key as p, c_int+1 as q, sum(c_int) as r from "//cbo_t2" where ("//cbo_t2".c_int + 1 >= 0) and ("//cbo_t2".c_int > 0 or "//cbo_t2".c_float >= 0) group by c_float, "//cbo_t2".c_int, key having "//cbo_t2".c_float > 0 and (c_int >=1 or c_float >= 1) and (c_int + c_float) >= 0 order by q+r/10 desc, p limit 5) "//cbo_t2" on "c/b/o_t1".a=p left semi join "cbo_/t3////" on "c/b/o_t1".a=key where (b + 1 >= 0) and (b > 0 or a >= 0) group by a, c having a > 0 and (a >=1 or c >= 1) and (a + c) >= 0 order by c, a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 2 1 + 1 2 1 +1 12 1 +1 2 1 +PREHOOK: query: select * from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +PREHOOK: query: select * from "c/b/o_t1" as "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" as "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +PREHOOK: query: select * from "c/b/o_t1" as "//cbo_t2" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" as "//cbo_t2" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +PREHOOK: query: select "c/b/o_t1".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +NULL NULL NULL +NULL NULL NULL +PREHOOK: query: select * from "c/b/o_t1" where (((key=1) and (c_float=10)) and (c_int=20)) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" where (((key=1) and (c_float=10)) and (c_int=20)) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +PREHOOK: query: select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +PREHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select "//cbo_t2".key as x, c_int as c_int, (((c_int+c_float)*10)+5) as y from "c/b/o_t1" as "//cbo_t2" where "//cbo_t2".c_int >= 0 and c_float+c_int >= 0 or c_float <= 100) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 and y+c_int >= 0 or x <= 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 + 1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +1 1 25.0 +PREHOOK: query: select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "c/b/o_t1" where "c/b/o_t1".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select "//cbo_t2".c_int+c_float as x , c_int as c_int, (((c_int+c_float)*10)+5) as y from (select * from "c/b/o_t1" where "c/b/o_t1".c_int >= 0) as "//cbo_t2" where "//cbo_t2".c_int >= 0 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +2.0 1 25.0 +PREHOOK: query: select null from "cbo_/t3////" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select null from "cbo_/t3////" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +NULL +PREHOOK: query: select key from "c/b/o_t1" where c_int = -6 or c_int = +6 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key from "c/b/o_t1" where c_int = -6 or c_int = +6 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +PREHOOK: query: select count("c/b/o_t1".dt) from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".dt = "//cbo_t2".dt where "c/b/o_t1".dt = '2014' +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count("c/b/o_t1".dt) from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".dt = "//cbo_t2".dt where "c/b/o_t1".dt = '2014' +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +400 +PREHOOK: query: select "c/b/o_t1".value from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key = "//cbo_t2".key where "c/b/o_t1".dt = '10' and "c/b/o_t1".c_boolean = true +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +#### A masked pattern was here #### +POSTHOOK: query: select "c/b/o_t1".value from "c/b/o_t1" join "//cbo_t2" on "c/b/o_t1".key = "//cbo_t2".key where "c/b/o_t1".dt = '10' and "c/b/o_t1".c_boolean = true +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +#### A masked pattern was here #### +PREHOOK: query: select * + +from "src/_/cbo" b + +where not exists + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.value > 'val_2' + + ) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from "src/_/cbo" b + +where not exists + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.value > 'val_2' + + ) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +0 val_0 +0 val_0 +0 val_0 +10 val_10 +100 val_100 +100 val_100 +103 val_103 +103 val_103 +104 val_104 +104 val_104 +105 val_105 +11 val_11 +111 val_111 +113 val_113 +113 val_113 +114 val_114 +116 val_116 +118 val_118 +118 val_118 +119 val_119 +119 val_119 +119 val_119 +12 val_12 +12 val_12 +120 val_120 +120 val_120 +125 val_125 +125 val_125 +126 val_126 +128 val_128 +128 val_128 +128 val_128 +129 val_129 +129 val_129 +131 val_131 +133 val_133 +134 val_134 +134 val_134 +136 val_136 +137 val_137 +137 val_137 +138 val_138 +138 val_138 +138 val_138 +138 val_138 +143 val_143 +145 val_145 +146 val_146 +146 val_146 +149 val_149 +149 val_149 +15 val_15 +15 val_15 +150 val_150 +152 val_152 +152 val_152 +153 val_153 +155 val_155 +156 val_156 +157 val_157 +158 val_158 +160 val_160 +162 val_162 +163 val_163 +164 val_164 +164 val_164 +165 val_165 +165 val_165 +166 val_166 +167 val_167 +167 val_167 +167 val_167 +168 val_168 +169 val_169 +169 val_169 +169 val_169 +169 val_169 +17 val_17 +170 val_170 +172 val_172 +172 val_172 +174 val_174 +174 val_174 +175 val_175 +175 val_175 +176 val_176 +176 val_176 +177 val_177 +178 val_178 +179 val_179 +179 val_179 +18 val_18 +18 val_18 +180 val_180 +181 val_181 +183 val_183 +186 val_186 +187 val_187 +187 val_187 +187 val_187 +189 val_189 +19 val_19 +190 val_190 +191 val_191 +191 val_191 +192 val_192 +193 val_193 +193 val_193 +193 val_193 +194 val_194 +195 val_195 +195 val_195 +196 val_196 +197 val_197 +197 val_197 +199 val_199 +199 val_199 +199 val_199 +2 val_2 +PREHOOK: query: select * + +from "src/_/cbo" b + +group by key, value + +having not exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_12' + + ) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from "src/_/cbo" b + +group by key, value + +having not exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_12' + + ) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +105 val_105 +11 val_11 +111 val_111 +113 val_113 +114 val_114 +116 val_116 +118 val_118 +119 val_119 +12 val_12 +PREHOOK: query: create view cv1 as + +select * + +from "src/_/cbo" b + +where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') +PREHOOK: type: CREATEVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@cv1 +POSTHOOK: query: create view cv1 as + +select * + +from "src/_/cbo" b + +where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@cv1 +POSTHOOK: Lineage: cv1.key SIMPLE [(src/_/cbo)b.FieldSchema(name:key, type:string, comment:null), ] +POSTHOOK: Lineage: cv1.value SIMPLE [(src/_/cbo)b.FieldSchema(name:value, type:string, comment:null), ] +PREHOOK: query: select * from cv1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@cv1 +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * from cv1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@cv1 +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 +PREHOOK: query: select * + +from (select * + + from "src/_/cbo" b + + where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') + + ) a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from (select * + + from "src/_/cbo" b + + where exists + + (select a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key = b.key and a.value > 'val_9') + + ) a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 +PREHOOK: query: select * + +from (select b.key, count(*) + + from "src/_/cbo" b + + group by b.key + + having exists + + (select a.key + + from "src/_/cbo" a + + where a.key = b.key and a.value > 'val_9' + + ) + +) a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from (select b.key, count(*) + + from "src/_/cbo" b + + group by b.key + + having exists + + (select a.key + + from "src/_/cbo" a + + where a.key = b.key and a.value > 'val_9' + + ) + +) a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +90 3 +92 1 +95 2 +96 1 +97 2 +98 2 +PREHOOK: query: select * + +from "src/_/cbo" + +where "src/_/cbo".key in (select key from "src/_/cbo" s1 where s1.key > '9') order by key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from "src/_/cbo" + +where "src/_/cbo".key in (select key from "src/_/cbo" s1 where s1.key > '9') order by key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 +PREHOOK: query: select * + +from "src/_/cbo" b + +where b.key in + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key > '9' + + ) order by b.key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from "src/_/cbo" b + +where b.key in + + (select distinct a.key + + from "src/_/cbo" a + + where b.value = a.value and a.key > '9' + + ) order by b.key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 +PREHOOK: query: select p.p_partkey, li.l_suppkey + +from (select distinct l_partkey as p_partkey from "line/item") p join "line/item" li on p.p_partkey = li.l_partkey + +where li.l_linenumber = 1 and + + li.l_orderkey in (select l_orderkey from "line/item" where l_shipmode = 'AIR' and l_linenumber = li.l_linenumber) + + order by p.p_partkey +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +POSTHOOK: query: select p.p_partkey, li.l_suppkey + +from (select distinct l_partkey as p_partkey from "line/item") p join "line/item" li on p.p_partkey = li.l_partkey + +where li.l_linenumber = 1 and + + li.l_orderkey in (select l_orderkey from "line/item" where l_shipmode = 'AIR' and l_linenumber = li.l_linenumber) + + order by p.p_partkey +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +108570 8571 +4297 1798 +PREHOOK: query: select key, value, count(*) + +from "src/_/cbo" b + +where b.key in (select key from "src/_/cbo" where "src/_/cbo".key > '8') + +group by key, value + +having count(*) in (select count(*) from "src/_/cbo" s1 where s1.key > '9' group by s1.key ) order by key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select key, value, count(*) + +from "src/_/cbo" b + +where b.key in (select key from "src/_/cbo" where "src/_/cbo".key > '8') + +group by key, value + +having count(*) in (select count(*) from "src/_/cbo" s1 where s1.key > '9' group by s1.key ) order by key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +80 val_80 1 +82 val_82 1 +83 val_83 2 +84 val_84 2 +85 val_85 1 +86 val_86 1 +87 val_87 1 +9 val_9 1 +90 val_90 3 +92 val_92 1 +95 val_95 2 +96 val_96 1 +97 val_97 2 +98 val_98 2 +PREHOOK: query: select p_mfgr, p_name, avg(p_size) + +from "p/a/r/t" + +group by p_mfgr, p_name + +having p_name in + + (select first_value(p_name) over(partition by p_mfgr order by p_size) from "p/a/r/t") order by p_mfgr +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select p_mfgr, p_name, avg(p_size) + +from "p/a/r/t" + +group by p_mfgr, p_name + +having p_name in + + (select first_value(p_name) over(partition by p_mfgr order by p_size) from "p/a/r/t") order by p_mfgr +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +Manufacturer#1 almond antique burnished rose metallic 2.0 +Manufacturer#2 almond aquamarine midnight light salmon 2.0 +Manufacturer#3 almond antique misty red olive 1.0 +Manufacturer#4 almond aquamarine yellow dodger mint 7.0 +Manufacturer#5 almond antique sky peru orange 2.0 +PREHOOK: query: select * + +from "src/_/cbo" + +where "src/_/cbo".key not in + + ( select key from "src/_/cbo" s1 + + where s1.key > '2' + + ) order by key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * + +from "src/_/cbo" + +where "src/_/cbo".key not in + + ( select key from "src/_/cbo" s1 + + where s1.key > '2' + + ) order by key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +0 val_0 +0 val_0 +0 val_0 +10 val_10 +100 val_100 +100 val_100 +103 val_103 +103 val_103 +104 val_104 +104 val_104 +105 val_105 +11 val_11 +111 val_111 +113 val_113 +113 val_113 +114 val_114 +116 val_116 +118 val_118 +118 val_118 +119 val_119 +119 val_119 +119 val_119 +12 val_12 +12 val_12 +120 val_120 +120 val_120 +125 val_125 +125 val_125 +126 val_126 +128 val_128 +128 val_128 +128 val_128 +129 val_129 +129 val_129 +131 val_131 +133 val_133 +134 val_134 +134 val_134 +136 val_136 +137 val_137 +137 val_137 +138 val_138 +138 val_138 +138 val_138 +138 val_138 +143 val_143 +145 val_145 +146 val_146 +146 val_146 +149 val_149 +149 val_149 +15 val_15 +15 val_15 +150 val_150 +152 val_152 +152 val_152 +153 val_153 +155 val_155 +156 val_156 +157 val_157 +158 val_158 +160 val_160 +162 val_162 +163 val_163 +164 val_164 +164 val_164 +165 val_165 +165 val_165 +166 val_166 +167 val_167 +167 val_167 +167 val_167 +168 val_168 +169 val_169 +169 val_169 +169 val_169 +169 val_169 +17 val_17 +170 val_170 +172 val_172 +172 val_172 +174 val_174 +174 val_174 +175 val_175 +175 val_175 +176 val_176 +176 val_176 +177 val_177 +178 val_178 +179 val_179 +179 val_179 +18 val_18 +18 val_18 +180 val_180 +181 val_181 +183 val_183 +186 val_186 +187 val_187 +187 val_187 +187 val_187 +189 val_189 +19 val_19 +190 val_190 +191 val_191 +191 val_191 +192 val_192 +193 val_193 +193 val_193 +193 val_193 +194 val_194 +195 val_195 +195 val_195 +196 val_196 +197 val_197 +197 val_197 +199 val_199 +199 val_199 +199 val_199 +2 val_2 +PREHOOK: query: select p_mfgr, b.p_name, p_size + +from "p/a/r/t" b + +where b.p_name not in + + (select p_name + + from (select p_mfgr, p_name, p_size as r from "p/a/r/t") a + + where r < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_mfgr,p_size +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select p_mfgr, b.p_name, p_size + +from "p/a/r/t" b + +where b.p_name not in + + (select p_name + + from (select p_mfgr, p_name, p_size as r from "p/a/r/t") a + + where r < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_mfgr,p_size +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +Manufacturer#1 almond antique chartreuse lavender yellow 34 +Manufacturer#1 almond aquamarine burnished black steel 28 +Manufacturer#1 almond aquamarine pink moccasin thistle 42 +Manufacturer#2 almond antique violet chocolate turquoise 14 +Manufacturer#2 almond antique violet turquoise frosted 40 +Manufacturer#2 almond aquamarine rose maroon antique 25 +Manufacturer#2 almond aquamarine sandy cyan gainsboro 18 +Manufacturer#3 almond antique chartreuse khaki white 17 +Manufacturer#3 almond antique forest lavender goldenrod 14 +Manufacturer#3 almond antique metallic orange dim 19 +Manufacturer#3 almond antique olive coral navajo 45 +Manufacturer#4 almond antique gainsboro frosted violet 10 +Manufacturer#4 almond antique violet mint lemon 39 +Manufacturer#4 almond aquamarine floral ivory bisque 27 +Manufacturer#4 almond azure aquamarine papaya violet 12 +Manufacturer#5 almond antique blue firebrick mint 31 +Manufacturer#5 almond aquamarine dodger light gainsboro 46 +Manufacturer#5 almond azure blanched chiffon midnight 23 +PREHOOK: query: select p_name, p_size + +from + +"p/a/r/t" where "p/a/r/t".p_size not in + + (select avg(p_size) + + from (select p_size from "p/a/r/t") a + + where p_size < 10 + + ) order by p_name +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select p_name, p_size + +from + +"p/a/r/t" where "p/a/r/t".p_size not in + + (select avg(p_size) + + from (select p_size from "p/a/r/t") a + + where p_size < 10 + + ) order by p_name +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +almond antique blue firebrick mint 31 +almond antique burnished rose metallic 2 +almond antique burnished rose metallic 2 +almond antique chartreuse khaki white 17 +almond antique chartreuse lavender yellow 34 +almond antique forest lavender goldenrod 14 +almond antique gainsboro frosted violet 10 +almond antique medium spring khaki 6 +almond antique metallic orange dim 19 +almond antique misty red olive 1 +almond antique olive coral navajo 45 +almond antique salmon chartreuse burlywood 6 +almond antique sky peru orange 2 +almond antique violet chocolate turquoise 14 +almond antique violet mint lemon 39 +almond antique violet turquoise frosted 40 +almond aquamarine burnished black steel 28 +almond aquamarine dodger light gainsboro 46 +almond aquamarine floral ivory bisque 27 +almond aquamarine midnight light salmon 2 +almond aquamarine pink moccasin thistle 42 +almond aquamarine rose maroon antique 25 +almond aquamarine sandy cyan gainsboro 18 +almond aquamarine yellow dodger mint 7 +almond azure aquamarine papaya violet 12 +almond azure blanched chiffon midnight 23 +PREHOOK: query: select p_mfgr, p_name, p_size + +from "p/a/r/t" b where b.p_size not in + + (select min(p_size) + + from (select p_mfgr, p_size from "p/a/r/t") a + + where p_size < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_name +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select p_mfgr, p_name, p_size + +from "p/a/r/t" b where b.p_size not in + + (select min(p_size) + + from (select p_mfgr, p_size from "p/a/r/t") a + + where p_size < 10 and b.p_mfgr = a.p_mfgr + + ) order by p_name +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +Manufacturer#1 almond antique chartreuse lavender yellow 34 +Manufacturer#1 almond antique salmon chartreuse burlywood 6 +Manufacturer#1 almond aquamarine burnished black steel 28 +Manufacturer#1 almond aquamarine pink moccasin thistle 42 +Manufacturer#2 almond antique violet chocolate turquoise 14 +Manufacturer#2 almond antique violet turquoise frosted 40 +Manufacturer#2 almond aquamarine rose maroon antique 25 +Manufacturer#2 almond aquamarine sandy cyan gainsboro 18 +Manufacturer#3 almond antique chartreuse khaki white 17 +Manufacturer#3 almond antique forest lavender goldenrod 14 +Manufacturer#3 almond antique metallic orange dim 19 +Manufacturer#3 almond antique olive coral navajo 45 +Manufacturer#4 almond antique gainsboro frosted violet 10 +Manufacturer#4 almond antique violet mint lemon 39 +Manufacturer#4 almond aquamarine floral ivory bisque 27 +Manufacturer#4 almond azure aquamarine papaya violet 12 +Manufacturer#5 almond antique blue firebrick mint 31 +Manufacturer#5 almond antique medium spring khaki 6 +Manufacturer#5 almond aquamarine dodger light gainsboro 46 +Manufacturer#5 almond azure blanched chiffon midnight 23 +PREHOOK: query: select li.l_partkey, count(*) + +from "line/item" li + +where li.l_linenumber = 1 and + + li.l_orderkey not in (select l_orderkey from "line/item" where l_shipmode = 'AIR') + +group by li.l_partkey order by li.l_partkey +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +POSTHOOK: query: select li.l_partkey, count(*) + +from "line/item" li + +where li.l_linenumber = 1 and + + li.l_orderkey not in (select l_orderkey from "line/item" where l_shipmode = 'AIR') + +group by li.l_partkey order by li.l_partkey +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@line/item +#### A masked pattern was here #### +106170 1 +119477 1 +119767 1 +123076 1 +139636 1 +175839 1 +182052 1 +21636 1 +22630 1 +450 1 +59694 1 +61931 1 +7068 1 +85951 1 +88035 1 +88362 1 +PREHOOK: query: select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from (select p_mfgr, min(p_retailprice) l, max(p_retailprice) r, avg(p_retailprice) a from "p/a/r/t" group by p_mfgr) a + + where min(p_retailprice) = l and r - l > 600 + + ) + + order by b.p_mfgr +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from (select p_mfgr, min(p_retailprice) l, max(p_retailprice) r, avg(p_retailprice) a from "p/a/r/t" group by p_mfgr) a + + where min(p_retailprice) = l and r - l > 600 + + ) + + order by b.p_mfgr +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +Manufacturer#1 1173.15 +Manufacturer#2 1690.68 +PREHOOK: query: select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from "p/a/r/t" a + + group by p_mfgr + + having max(p_retailprice) - min(p_retailprice) > 600 + + ) + + order by b.p_mfgr +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +POSTHOOK: query: select b.p_mfgr, min(p_retailprice) + +from "p/a/r/t" b + +group by b.p_mfgr + +having b.p_mfgr not in + + (select p_mfgr + + from "p/a/r/t" a + + group by p_mfgr + + having max(p_retailprice) - min(p_retailprice) > 600 + + ) + + order by b.p_mfgr +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@p/a/r/t +#### A masked pattern was here #### +Manufacturer#1 1173.15 +Manufacturer#2 1690.68 +PREHOOK: query: select count(*), count(c_int), sum(c_int), avg(c_int), max(c_int), min(c_int) from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(*), count(c_int), sum(c_int), avg(c_int), max(c_int), min(c_int) from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +20 18 18 1.0 1 1 +PREHOOK: query: select count(*), count(c_int) as a, sum(c_int), avg(c_int), max(c_int), min(c_int), case c_int when 0 then 1 when 1 then 2 else 3 end, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) from "c/b/o_t1" group by c_int order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(*), count(c_int) as a, sum(c_int), avg(c_int), max(c_int), min(c_int), case c_int when 0 then 1 when 1 then 2 else 3 end, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) from "c/b/o_t1" group by c_int order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +18 18 18 1.0 1 1 2 36 +2 0 NULL NULL NULL NULL 3 6 +PREHOOK: query: select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +20 1 18 1.0 1 1 +PREHOOK: query: select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f, case c_int when 0 then 1 when 1 then 2 else 3 end as g, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) as h from "c/b/o_t1" group by c_int) "c/b/o_t1" order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select count(*) as a, count(distinct c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f, case c_int when 0 then 1 when 1 then 2 else 3 end as g, sum(case c_int when 0 then 1 when 1 then 2 else 3 end) as h from "c/b/o_t1" group by c_int) "c/b/o_t1" order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +18 1 18 1.0 1 1 2 36 +2 0 NULL NULL NULL NULL 3 6 +PREHOOK: query: select f,a,e,b from (select count(*) as a, count(c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select f,a,e,b from (select count(*) as a, count(c_int) as b, sum(c_int) as c, avg(c_int) as d, max(c_int) as e, min(c_int) as f from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 20 1 18 +PREHOOK: query: select f,a,e,b from (select count(*) as a, count(distinct c_int) as b, sum(distinct c_int) as c, avg(distinct c_int) as d, max(distinct c_int) as e, min(distinct c_int) as f from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select f,a,e,b from (select count(*) as a, count(distinct c_int) as b, sum(distinct c_int) as c, avg(distinct c_int) as d, max(distinct c_int) as e, min(distinct c_int) as f from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 20 1 1 +PREHOOK: query: select key,count(c_int) as a, avg(c_float) from "c/b/o_t1" group by key order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select key,count(c_int) as a, avg(c_float) from "c/b/o_t1" group by key order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 2 1.0 + 1 2 1.0 +1 12 1.0 +1 2 1.0 +NULL 0 NULL +PREHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +0 NULL +1 1.0 +PREHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_int order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_int order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +0 NULL +1 1.0 +PREHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float, c_int order by a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(distinct c_int) as a, avg(c_float) from "c/b/o_t1" group by c_float, c_int order by a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +0 NULL +1 1.0 +PREHOOK: query: select * from (select * from "c/b/o_t1" order by key, c_boolean, value, dt)a union all select * from (select * from "//cbo_t2" order by key, c_boolean, value, dt)b +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select * from "c/b/o_t1" order by key, c_boolean, value, dt)a union all select * from (select * from "//cbo_t2" order by key, c_boolean, value, dt)b +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 + 1 1 1 1.0 true 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 false 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +1 1 1 1.0 true 2014 +2 2 2 2.0 true 2014 +2 2 2 2.0 true 2014 +2 2 2 2.0 true 2014 +2 2 2 2.0 true 2014 +2 2 2 2.0 true 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +NULL NULL NULL NULL NULL 2014 +PREHOOK: query: select key from (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r2 where key >=0 order by key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select key from (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r2 where key >=0 order by key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +2 +2 +2 +2 +2 +2 +3 +3 +3 +PREHOOK: query: select r2.key from (select key, c_int from (select key, c_int from "c/b/o_t1" union all select key, c_int from "cbo_/t3////" )r1 union all select key, c_int from "cbo_/t3////")r2 join (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r3 on r2.key=r3.key where r3.key >=0 order by r2.key +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### +POSTHOOK: query: select r2.key from (select key, c_int from (select key, c_int from "c/b/o_t1" union all select key, c_int from "cbo_/t3////" )r1 union all select key, c_int from "cbo_/t3////")r2 join (select key, c_int from (select * from "c/b/o_t1" union all select * from "//cbo_t2" where "//cbo_t2".key >=0)r1 union all select key, c_int from "cbo_/t3////")r3 on r2.key=r3.key where r3.key >=0 order by r2.key +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@cbo_/t3//// +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +3 +PREHOOK: query: create view v1 as select c_int, value, c_boolean, dt from "c/b/o_t1" +PREHOOK: type: CREATEVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@v1 +POSTHOOK: query: create view v1 as select c_int, value, c_boolean, dt from "c/b/o_t1" +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@v1 +POSTHOOK: Lineage: v1.c_boolean SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:c_boolean, type:boolean, comment:null), ] +POSTHOOK: Lineage: v1.c_int SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:c_int, type:int, comment:null), ] +POSTHOOK: Lineage: v1.dt SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:dt, type:string, comment:null), ] +POSTHOOK: Lineage: v1.value SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:value, type:string, comment:null), ] +PREHOOK: query: create view v2 as select c_int, value from "//cbo_t2" +PREHOOK: type: CREATEVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@v2 +POSTHOOK: query: create view v2 as select c_int, value from "//cbo_t2" +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@v2 +POSTHOOK: Lineage: v2.c_int SIMPLE [(//cbo_t2)//cbo_t2.FieldSchema(name:c_int, type:int, comment:null), ] +POSTHOOK: Lineage: v2.value SIMPLE [(//cbo_t2)//cbo_t2.FieldSchema(name:value, type:string, comment:null), ] +PREHOOK: query: select value from v1 where c_boolean=false +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: select value from v1 where c_boolean=false +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +1 +1 +PREHOOK: query: select max(c_int) from v1 group by (c_boolean) +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: select max(c_int) from v1 group by (c_boolean) +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +1 +1 +NULL +PREHOOK: query: select count(v1.c_int) from v1 join "//cbo_t2" on v1.c_int = "//cbo_t2".c_int +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: select count(v1.c_int) from v1 join "//cbo_t2" on v1.c_int = "//cbo_t2".c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +234 +PREHOOK: query: select count(v1.c_int) from v1 join v2 on v1.c_int = v2.c_int +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +PREHOOK: Input: db~!@#$%^&*(),<>@v2 +#### A masked pattern was here #### +POSTHOOK: query: select count(v1.c_int) from v1 join v2 on v1.c_int = v2.c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Input: db~!@#$%^&*(),<>@//cbo_t2@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +POSTHOOK: Input: db~!@#$%^&*(),<>@v2 +#### A masked pattern was here #### +234 +PREHOOK: query: select count(*) from v1 a join v1 b on a.value = b.value +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: select count(*) from v1 a join v1 b on a.value = b.value +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +156 +PREHOOK: query: create view v3 as select v1.value val from v1 join "c/b/o_t1" on v1.c_boolean = "c/b/o_t1".c_boolean +PREHOOK: type: CREATEVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@v3 +POSTHOOK: query: create view v3 as select v1.value val from v1 join "c/b/o_t1" on v1.c_boolean = "c/b/o_t1".c_boolean +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@v3 +POSTHOOK: Lineage: v3.val SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:value, type:string, comment:null), ] +PREHOOK: query: select count(val) from v3 where val != '1' +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +PREHOOK: Input: db~!@#$%^&*(),<>@v3 +#### A masked pattern was here #### +POSTHOOK: query: select count(val) from v3 where val != '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +POSTHOOK: Input: db~!@#$%^&*(),<>@v3 +#### A masked pattern was here #### +96 +PREHOOK: query: with q1 as ( select key from "c/b/o_t1" where key = '1') + +select count(*) from q1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: with q1 as ( select key from "c/b/o_t1" where key = '1') + +select count(*) from q1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +12 +PREHOOK: query: with q1 as ( select value from v1 where c_boolean = false) + +select count(value) from q1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: with q1 as ( select value from v1 where c_boolean = false) + +select count(value) from q1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +2 +PREHOOK: query: create view v4 as + +with q1 as ( select key,c_int from "c/b/o_t1" where key = '1') + +select * from q1 +PREHOOK: type: CREATEVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@v4 +POSTHOOK: query: create view v4 as + +with q1 as ( select key,c_int from "c/b/o_t1" where key = '1') + +select * from q1 +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@v4 +POSTHOOK: Lineage: v4.c_int SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:c_int, type:int, comment:null), ] +POSTHOOK: Lineage: v4.key SIMPLE [(c/b/o_t1)c/b/o_t1.FieldSchema(name:key, type:string, comment:null), ] +PREHOOK: query: with q1 as ( select c_int from q2 where c_boolean = false), + +q2 as ( select c_int,c_boolean from v1 where value = '1') + +select sum(c_int) from (select c_int from q1) a +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +POSTHOOK: query: with q1 as ( select c_int from q2 where c_boolean = false), + +q2 as ( select c_int,c_boolean from v1 where value = '1') + +select sum(c_int) from (select c_int from q1) a +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +#### A masked pattern was here #### +2 +PREHOOK: query: with q1 as ( select "c/b/o_t1".c_int c_int from q2 join "c/b/o_t1" where q2.c_int = "c/b/o_t1".c_int and "c/b/o_t1".dt='2014'), + +q2 as ( select c_int,c_boolean from v1 where value = '1' or dt = '14') + +select count(*) from q1 join q2 join v4 on q1.c_int = q2.c_int and v4.c_int = q2.c_int +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +PREHOOK: Input: db~!@#$%^&*(),<>@v4 +#### A masked pattern was here #### +POSTHOOK: query: with q1 as ( select "c/b/o_t1".c_int c_int from q2 join "c/b/o_t1" where q2.c_int = "c/b/o_t1".c_int and "c/b/o_t1".dt='2014'), + +q2 as ( select c_int,c_boolean from v1 where value = '1' or dt = '14') + +select count(*) from q1 join q2 join v4 on q1.c_int = q2.c_int and v4.c_int = q2.c_int +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +POSTHOOK: Input: db~!@#$%^&*(),<>@v4 +#### A masked pattern was here #### +31104 +PREHOOK: query: drop view v1 +PREHOOK: type: DROPVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@v1 +PREHOOK: Output: db~!@#$%^&*(),<>@v1 +POSTHOOK: query: drop view v1 +POSTHOOK: type: DROPVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@v1 +POSTHOOK: Output: db~!@#$%^&*(),<>@v1 +PREHOOK: query: drop view v2 +PREHOOK: type: DROPVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@v2 +PREHOOK: Output: db~!@#$%^&*(),<>@v2 +POSTHOOK: query: drop view v2 +POSTHOOK: type: DROPVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@v2 +POSTHOOK: Output: db~!@#$%^&*(),<>@v2 +PREHOOK: query: drop view v3 +PREHOOK: type: DROPVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@v3 +PREHOOK: Output: db~!@#$%^&*(),<>@v3 +POSTHOOK: query: drop view v3 +POSTHOOK: type: DROPVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@v3 +POSTHOOK: Output: db~!@#$%^&*(),<>@v3 +PREHOOK: query: drop view v4 +PREHOOK: type: DROPVIEW +PREHOOK: Input: db~!@#$%^&*(),<>@v4 +PREHOOK: Output: db~!@#$%^&*(),<>@v4 +POSTHOOK: query: drop view v4 +POSTHOOK: type: DROPVIEW +POSTHOOK: Input: db~!@#$%^&*(),<>@v4 +POSTHOOK: Output: db~!@#$%^&*(),<>@v4 +PREHOOK: query: select count(c_int) over() from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(c_int) over() from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +PREHOOK: query: select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key), 2), lead(c_int, 2, c_int) over(partition by c_float order by key), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key), 2), lead(c_int, 2, c_int) over(partition by c_float order by key), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +0 NULL NULL NULL 1 1 1 0.0 NULL NULL +0 NULL NULL NULL 2 1 1 0.0 NULL NULL +16 16.0 1 1 10 5 3 0.24 1 1.0 +16 16.0 1 1 11 5 3 0.24 1 1.0 +16 16.0 1 1 12 5 3 0.24 1 1.0 +16 16.0 1 1 13 5 3 0.24 1 1.0 +16 16.0 1 1 14 5 3 0.24 1 1.0 +16 16.0 1 1 15 5 3 0.24 1 1.0 +16 16.0 1 1 16 5 3 0.24 1 1.0 +16 16.0 1 1 5 5 3 0.24 1 1.0 +16 16.0 1 1 6 5 3 0.24 1 1.0 +16 16.0 1 1 7 5 3 0.24 1 1.0 +16 16.0 1 1 8 5 3 0.24 1 1.0 +16 16.0 1 1 9 5 3 0.24 1 1.0 +18 18.0 1 1 17 17 4 0.94 1 1.0 +18 18.0 1 1 18 17 4 0.94 1 1.0 +2 2.0 1 1 1 1 1 0.0 1 1.0 +2 2.0 1 1 2 1 1 0.0 1 1.0 +4 4.0 1 1 3 3 2 0.12 1 1.0 +4 4.0 1 1 4 3 2 0.12 1 1.0 +PREHOOK: query: select * from (select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key),2), lead(c_int, 2, c_int) over(partition by c_float order by key ), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn) "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select count(c_int) over(partition by c_float order by key), sum(c_float) over(partition by c_float order by key), max(c_int) over(partition by c_float order by key), min(c_int) over(partition by c_float order by key), row_number() over(partition by c_float order by key) as rn, rank() over(partition by c_float order by key), dense_rank() over(partition by c_float order by key), round(percent_rank() over(partition by c_float order by key),2), lead(c_int, 2, c_int) over(partition by c_float order by key ), lag(c_float, 2, c_float) over(partition by c_float order by key) from "c/b/o_t1" order by rn) "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +0 NULL NULL NULL 1 1 1 0.0 NULL NULL +0 NULL NULL NULL 2 1 1 0.0 NULL NULL +16 16.0 1 1 10 5 3 0.24 1 1.0 +16 16.0 1 1 11 5 3 0.24 1 1.0 +16 16.0 1 1 12 5 3 0.24 1 1.0 +16 16.0 1 1 13 5 3 0.24 1 1.0 +16 16.0 1 1 14 5 3 0.24 1 1.0 +16 16.0 1 1 15 5 3 0.24 1 1.0 +16 16.0 1 1 16 5 3 0.24 1 1.0 +16 16.0 1 1 5 5 3 0.24 1 1.0 +16 16.0 1 1 6 5 3 0.24 1 1.0 +16 16.0 1 1 7 5 3 0.24 1 1.0 +16 16.0 1 1 8 5 3 0.24 1 1.0 +16 16.0 1 1 9 5 3 0.24 1 1.0 +18 18.0 1 1 17 17 4 0.94 1 1.0 +18 18.0 1 1 18 17 4 0.94 1 1.0 +2 2.0 1 1 1 1 1 0.0 1 1.0 +2 2.0 1 1 2 1 1 0.0 1 1.0 +4 4.0 1 1 3 3 2 0.12 1 1.0 +4 4.0 1 1 4 3 2 0.12 1 1.0 +PREHOOK: query: select x from (select count(c_int) over() as x, sum(c_float) over() from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select x from (select count(c_int) over() as x, sum(c_float) over() from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +18 +PREHOOK: query: select 1+sum(c_int) over() from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select 1+sum(c_int) over() from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +19 +PREHOOK: query: select sum(c_int)+sum(sum(c_int)) over() from "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select sum(c_int)+sum(sum(c_int)) over() from "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +36 +PREHOOK: query: select * from (select max(c_int) over (partition by key order by value Rows UNBOUNDED PRECEDING), min(c_int) over (partition by key order by value rows current row), count(c_int) over(partition by key order by value ROWS 1 PRECEDING), avg(value) over (partition by key order by value Rows between unbounded preceding and unbounded following), sum(value) over (partition by key order by value rows between unbounded preceding and current row), avg(c_float) over (partition by key order by value Rows between 1 preceding and unbounded following), sum(c_float) over (partition by key order by value rows between 1 preceding and current row), max(c_float) over (partition by key order by value rows between 1 preceding and unbounded following), min(c_float) over (partition by key order by value rows between 1 preceding and 1 following) from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select * from (select max(c_int) over (partition by key order by value Rows UNBOUNDED PRECEDING), min(c_int) over (partition by key order by value rows current row), count(c_int) over(partition by key order by value ROWS 1 PRECEDING), avg(value) over (partition by key order by value Rows between unbounded preceding and unbounded following), sum(value) over (partition by key order by value rows between unbounded preceding and current row), avg(c_float) over (partition by key order by value Rows between 1 preceding and unbounded following), sum(c_float) over (partition by key order by value rows between 1 preceding and current row), max(c_float) over (partition by key order by value rows between 1 preceding and unbounded following), min(c_float) over (partition by key order by value rows between 1 preceding and 1 following) from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1 1 1 1.0 1.0 1.0 1.0 1.0 1.0 +1 1 1 1.0 1.0 1.0 1.0 1.0 1.0 +1 1 1 1.0 1.0 1.0 1.0 1.0 1.0 +1 1 1 1.0 1.0 1.0 1.0 1.0 1.0 +1 1 2 1.0 10.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 11.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 12.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 2.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 2.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 2.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 2.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 3.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 4.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 5.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 6.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 7.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 8.0 1.0 2.0 1.0 1.0 +1 1 2 1.0 9.0 1.0 2.0 1.0 1.0 +NULL NULL 0 NULL NULL NULL NULL NULL NULL +NULL NULL 0 NULL NULL NULL NULL NULL NULL +PREHOOK: query: select i, a, h, b, c, d, e, f, g, a as x, a +1 as y from (select max(c_int) over (partition by key order by value range UNBOUNDED PRECEDING) a, min(c_int) over (partition by key order by value range current row) b, count(c_int) over(partition by key order by value range 1 PRECEDING) c, avg(value) over (partition by key order by value range between unbounded preceding and unbounded following) d, sum(value) over (partition by key order by value range between unbounded preceding and current row) e, avg(c_float) over (partition by key order by value range between 1 preceding and unbounded following) f, sum(c_float) over (partition by key order by value range between 1 preceding and current row) g, max(c_float) over (partition by key order by value range between 1 preceding and unbounded following) h, min(c_float) over (partition by key order by value range between 1 preceding and 1 following) i from "c/b/o_t1") "c/b/o_t1" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +POSTHOOK: query: select i, a, h, b, c, d, e, f, g, a as x, a +1 as y from (select max(c_int) over (partition by key order by value range UNBOUNDED PRECEDING) a, min(c_int) over (partition by key order by value range current row) b, count(c_int) over(partition by key order by value range 1 PRECEDING) c, avg(value) over (partition by key order by value range between unbounded preceding and unbounded following) d, sum(value) over (partition by key order by value range between unbounded preceding and current row) e, avg(c_float) over (partition by key order by value range between 1 preceding and unbounded following) f, sum(c_float) over (partition by key order by value range between 1 preceding and current row) g, max(c_float) over (partition by key order by value range between 1 preceding and unbounded following) h, min(c_float) over (partition by key order by value range between 1 preceding and 1 following) i from "c/b/o_t1") "c/b/o_t1" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Input: db~!@#$%^&*(),<>@c/b/o_t1@dt=2014 +#### A masked pattern was here #### +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 12 1.0 12.0 1.0 12.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +1.0 1 1.0 1 2 1.0 2.0 1.0 2.0 1 2 +NULL NULL NULL NULL 0 NULL NULL NULL NULL NULL NULL +NULL NULL NULL NULL 0 NULL NULL NULL NULL NULL NULL +PREHOOK: query: select *, rank() over(partition by key order by value) as rr from default.src1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src1 +#### A masked pattern was here #### +POSTHOOK: query: select *, rank() over(partition by key order by value) as rr from default.src1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src1 +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + val_165 5 + val_193 6 + val_265 7 + val_27 8 + val_409 9 + val_484 10 +128 1 +146 val_146 1 +150 val_150 1 +213 val_213 1 +224 1 +238 val_238 1 +255 val_255 1 +273 val_273 1 +278 val_278 1 +311 val_311 1 +369 1 +401 val_401 1 +406 val_406 1 +66 val_66 1 +98 val_98 1 +PREHOOK: query: select *, rank() over(partition by key order by value) from default.src1 +PREHOOK: type: QUERY +PREHOOK: Input: default@src1 +#### A masked pattern was here #### +POSTHOOK: query: select *, rank() over(partition by key order by value) from default.src1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src1 +#### A masked pattern was here #### + 1 + 1 + 1 + 1 + val_165 5 + val_193 6 + val_265 7 + val_27 8 + val_409 9 + val_484 10 +128 1 +146 val_146 1 +150 val_150 1 +213 val_213 1 +224 1 +238 val_238 1 +255 val_255 1 +273 val_273 1 +278 val_278 1 +311 val_311 1 +369 1 +401 val_401 1 +406 val_406 1 +66 val_66 1 +98 val_98 1 +PREHOOK: query: insert into table "src/_/cbo" select * from default.src +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: query: insert into table "src/_/cbo" select * from default.src +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Lineage: src/_/cbo.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: src/_/cbo.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +PREHOOK: query: select * from "src/_/cbo" order by key limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * from "src/_/cbo" order by key limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +0 val_0 +PREHOOK: query: insert overwrite table "src/_/cbo" select * from default.src +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: query: insert overwrite table "src/_/cbo" select * from default.src +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Lineage: src/_/cbo.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: src/_/cbo.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +PREHOOK: query: select * from "src/_/cbo" order by key limit 1 +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +POSTHOOK: query: select * from "src/_/cbo" order by key limit 1 +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@src/_/cbo +#### A masked pattern was here #### +0 val_0 +PREHOOK: query: drop table "t//" +PREHOOK: type: DROPTABLE +POSTHOOK: query: drop table "t//" +POSTHOOK: type: DROPTABLE +PREHOOK: query: create table "t//" (col string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: query: create table "t//" (col string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@t// +PREHOOK: query: insert into "t//" values(1) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: query: insert into "t//" values(1) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: Lineage: t//.col SCRIPT [] +PREHOOK: query: insert into "t//" values(null) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: query: insert into "t//" values(null) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: Lineage: t//.col SCRIPT [] +PREHOOK: query: analyze table "t//" compute statistics +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@t// +PREHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: query: analyze table "t//" compute statistics +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@t// +POSTHOOK: Output: db~!@#$%^&*(),<>@t// +PREHOOK: query: explain select * from "t//" +PREHOOK: type: QUERY +PREHOOK: Input: db~!@#$%^&*(),<>@t// +#### A masked pattern was here #### +POSTHOOK: query: explain select * from "t//" +POSTHOOK: type: QUERY +POSTHOOK: Input: db~!@#$%^&*(),<>@t// +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: t// + Select Operator + expressions: col (type: string) + outputColumnNames: _col0 + ListSink + +PREHOOK: query: drop database "db~!@#$%^&*(),<>" cascade +PREHOOK: type: DROPDATABASE +PREHOOK: Input: database:db~!@#$%^&*(),<> +PREHOOK: Output: database:db~!@#$%^&*(),<> +PREHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +PREHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +PREHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +PREHOOK: Output: db~!@#$%^&*(),<>@cv1 +PREHOOK: Output: db~!@#$%^&*(),<>@line/item +PREHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +PREHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +PREHOOK: Output: db~!@#$%^&*(),<>@t// +POSTHOOK: query: drop database "db~!@#$%^&*(),<>" cascade +POSTHOOK: type: DROPDATABASE +POSTHOOK: Input: database:db~!@#$%^&*(),<> +POSTHOOK: Output: database:db~!@#$%^&*(),<> +POSTHOOK: Output: db~!@#$%^&*(),<>@//cbo_t2 +POSTHOOK: Output: db~!@#$%^&*(),<>@c/b/o_t1 +POSTHOOK: Output: db~!@#$%^&*(),<>@cbo_/t3//// +POSTHOOK: Output: db~!@#$%^&*(),<>@cv1 +POSTHOOK: Output: db~!@#$%^&*(),<>@line/item +POSTHOOK: Output: db~!@#$%^&*(),<>@p/a/r/t +POSTHOOK: Output: db~!@#$%^&*(),<>@src/_/cbo +POSTHOOK: Output: db~!@#$%^&*(),<>@t// diff --git ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_2.q.out ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_2.q.out new file mode 100644 index 0000000000..e1cd96f1e6 --- /dev/null +++ ql/src/test/results/clientpositive/llap/special_character_in_tabnames_quotes_2.q.out @@ -0,0 +1,153 @@ +PREHOOK: query: DROP TABLE IF EXISTS "s/c" +PREHOOK: type: DROPTABLE +POSTHOOK: query: DROP TABLE IF EXISTS "s/c" +POSTHOOK: type: DROPTABLE +PREHOOK: query: CREATE TABLE "s/c" (key STRING COMMENT 'default', value STRING COMMENT 'default') STORED AS TEXTFILE +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@s/c +POSTHOOK: query: CREATE TABLE "s/c" (key STRING COMMENT 'default', value STRING COMMENT 'default') STORED AS TEXTFILE +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@s/c +PREHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/kv1.txt' INTO TABLE "s/c" +PREHOOK: type: LOAD +#### A masked pattern was here #### +PREHOOK: Output: default@s/c +POSTHOOK: query: LOAD DATA LOCAL INPATH '../../data/files/kv1.txt' INTO TABLE "s/c" +POSTHOOK: type: LOAD +#### A masked pattern was here #### +POSTHOOK: Output: default@s/c +PREHOOK: query: ANALYZE TABLE "s/c" COMPUTE STATISTICS +PREHOOK: type: QUERY +PREHOOK: Input: default@s/c +PREHOOK: Output: default@s/c +POSTHOOK: query: ANALYZE TABLE "s/c" COMPUTE STATISTICS +POSTHOOK: type: QUERY +POSTHOOK: Input: default@s/c +POSTHOOK: Output: default@s/c +PREHOOK: query: ANALYZE TABLE "s/c" COMPUTE STATISTICS FOR COLUMNS key,value +PREHOOK: type: ANALYZE_TABLE +PREHOOK: Input: default@s/c +PREHOOK: Output: default@s/c +#### A masked pattern was here #### +POSTHOOK: query: ANALYZE TABLE "s/c" COMPUTE STATISTICS FOR COLUMNS key,value +POSTHOOK: type: ANALYZE_TABLE +POSTHOOK: Input: default@s/c +POSTHOOK: Output: default@s/c +#### A masked pattern was here #### +PREHOOK: query: describe formatted "s/c" +PREHOOK: type: DESCTABLE +PREHOOK: Input: default@s/c +POSTHOOK: query: describe formatted "s/c" +POSTHOOK: type: DESCTABLE +POSTHOOK: Input: default@s/c +# col_name data_type comment +key string default +value string default + +# Detailed Table Information +Database: default +#### A masked pattern was here #### +Retention: 0 +#### A masked pattern was here #### +Table Type: MANAGED_TABLE +Table Parameters: + COLUMN_STATS_ACCURATE {\"BASIC_STATS\":\"true\",\"COLUMN_STATS\":{\"key\":\"true\",\"value\":\"true\"}} + bucketing_version 2 + numFiles 1 + numRows 500 + rawDataSize 5312 + totalSize 5812 +#### A masked pattern was here #### + +# Storage Information +SerDe Library: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe +InputFormat: org.apache.hadoop.mapred.TextInputFormat +OutputFormat: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat +Compressed: No +Num Buckets: -1 +Bucket Columns: [] +Sort Columns: [] +Storage Desc Params: + serialization.format 1 +PREHOOK: query: SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@s/c +#### A masked pattern was here #### +POSTHOOK: query: SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@s/c +#### A masked pattern was here #### +82 val_82 +83 val_83 +83 val_83 +84 val_84 +84 val_84 +85 val_85 +86 val_86 +87 val_87 +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 +PREHOOK: query: EXPLAIN SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@s/c +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@s/c +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: s/c + filterExpr: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) + Filter Operator + predicate: ((UDFToDouble(key) > 80.0D) and (UDFToDouble(key) < 100.0D)) (type: boolean) + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + ListSink + +PREHOOK: query: SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +PREHOOK: type: QUERY +PREHOOK: Input: default@s/c +#### A masked pattern was here #### +POSTHOOK: query: SELECT key, value FROM "s/c" WHERE key > 80 AND key < 100 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@s/c +#### A masked pattern was here #### +82 val_82 +83 val_83 +83 val_83 +84 val_84 +84 val_84 +85 val_85 +86 val_86 +87 val_87 +90 val_90 +90 val_90 +90 val_90 +92 val_92 +95 val_95 +95 val_95 +96 val_96 +97 val_97 +97 val_97 +98 val_98 +98 val_98 diff --git ql/src/test/results/clientpositive/quotedid_basic_standard.q.out ql/src/test/results/clientpositive/quotedid_basic_standard.q.out new file mode 100644 index 0000000000..9f4fcdcc50 --- /dev/null +++ ql/src/test/results/clientpositive/quotedid_basic_standard.q.out @@ -0,0 +1,560 @@ +PREHOOK: query: select 3 as "a", 10 as "~!@#$%^&*()_q<>" +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +POSTHOOK: query: select 3 as "a", 10 as "~!@#$%^&*()_q<>" +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +#### A masked pattern was here #### +3 10 +PREHOOK: query: create table t1("x+1" string, "y&y" string, "~!@#$%^&*()_q<>" string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t1 +POSTHOOK: query: create table t1("x+1" string, "y&y" string, "~!@#$%^&*()_q<>" string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t1 +PREHOOK: query: describe t1 +PREHOOK: type: DESCTABLE +PREHOOK: Input: default@t1 +POSTHOOK: query: describe t1 +POSTHOOK: type: DESCTABLE +POSTHOOK: Input: default@t1 +x+1 string +y&y string +~!@#$%^&*()_q<> string +PREHOOK: query: select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +PREHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + TableScan + alias: t1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: x+1 (type: string), y&y (type: string), ~!@#$%^&*()_q<> (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + ListSink + +PREHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1' +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t1 + filterExpr: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: x+1 (type: string), y&y (type: string), '1' (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + Execution mode: vectorized + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>" from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t1 + filterExpr: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: x+1, y&y + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: x+1 (type: string), y&y (type: string) + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Execution mode: vectorized + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: explain select "x+1", "y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t1 + filterExpr: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: x+1, y&y + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: x+1 (type: string), y&y (type: string) + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Execution mode: vectorized + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: '1' (type: string), _col1 (type: string) + null sort order: az + sort order: ++ + Map-reduce partition columns: '1' (type: string) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + value expressions: _col0 (type: string) + Execution mode: vectorized + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 ASC NULLS LAST + partition by: '1' + raw input shape: + window functions: + window function definition + alias: rank_window_0 + arguments: _col1 + name: rank + window function: GenericUDAFRankEvaluator + window frame: ROWS PRECEDING(MAX)~FOLLOWING(MAX) + isPivotResult: true + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string), rank_window_0 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: explain select "X+1", "Y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&Y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +PREHOOK: type: QUERY +PREHOOK: Input: default@t1 +#### A masked pattern was here #### +POSTHOOK: query: explain select "X+1", "Y&y", "~!@#$%^&*()_q<>", rank() over(partition by "~!@#$%^&*()_q<>" order by "y&y") +from t1 where "~!@#$%^&*()_q<>" = '1' group by "x+1", "y&Y", "~!@#$%^&*()_q<>" having "~!@#$%^&*()_q<>" = '1' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t1 +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t1 + filterExpr: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (~!@#$%^&*()_q<> = '1') (type: boolean) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: x+1 (type: string), y&y (type: string) + outputColumnNames: x+1, y&y + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Group By Operator + keys: x+1 (type: string), y&y (type: string) + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Execution mode: vectorized + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: '1' (type: string), _col1 (type: string) + null sort order: az + sort order: ++ + Map-reduce partition columns: '1' (type: string) + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + value expressions: _col0 (type: string) + Execution mode: vectorized + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 ASC NULLS LAST + partition by: '1' + raw input shape: + window functions: + window function definition + alias: rank_window_0 + arguments: _col1 + name: rank + window function: GenericUDAFRankEvaluator + window frame: ROWS PRECEDING(MAX)~FOLLOWING(MAX) + isPivotResult: true + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), '1' (type: string), rank_window_0 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 1 Data size: 552 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: create table t4("x+1""" string, "y&y" string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t4 +POSTHOOK: query: create table t4("x+1""" string, "y&y" string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t4 +PREHOOK: query: describe t4 +PREHOOK: type: DESCTABLE +PREHOOK: Input: default@t4 +POSTHOOK: query: describe t4 +POSTHOOK: type: DESCTABLE +POSTHOOK: Input: default@t4 +x+1" string +y&y string +PREHOOK: query: insert into table t4 select * from src +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@t4 +POSTHOOK: query: insert into table t4 select * from src +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@t4 +POSTHOOK: Lineage: t4.x+1" SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: t4.y&y SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +PREHOOK: query: select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from t4 where "x+1""" = '10' group by "x+1""", "y&y" having "x+1""" = '10' +PREHOOK: type: QUERY +PREHOOK: Input: default@t4 +#### A masked pattern was here #### +POSTHOOK: query: select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from t4 where "x+1""" = '10' group by "x+1""", "y&y" having "x+1""" = '10' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t4 +#### A masked pattern was here #### +10 val_10 1 +PREHOOK: query: create view v1 as +select "x+1""", "y&y" +from t4 where "x+1""" < '200' +PREHOOK: type: CREATEVIEW +PREHOOK: Input: default@t4 +PREHOOK: Output: database:default +PREHOOK: Output: default@v1 +POSTHOOK: query: create view v1 as +select "x+1""", "y&y" +from t4 where "x+1""" < '200' +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: default@t4 +POSTHOOK: Output: database:default +POSTHOOK: Output: default@v1 +POSTHOOK: Lineage: v1.x+1" SIMPLE [(t4)t4.FieldSchema(name:x+1", type:string, comment:null), ] +POSTHOOK: Lineage: v1.y&y SIMPLE [(t4)t4.FieldSchema(name:y&y, type:string, comment:null), ] +PREHOOK: query: select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from v1 +group by "x+1""", "y&y" +PREHOOK: type: QUERY +PREHOOK: Input: default@t4 +PREHOOK: Input: default@v1 +#### A masked pattern was here #### +POSTHOOK: query: select "x+1""", "y&y", rank() over(partition by "x+1""" order by "y&y") +from v1 +group by "x+1""", "y&y" +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t4 +POSTHOOK: Input: default@v1 +#### A masked pattern was here #### +0 val_0 1 +10 val_10 1 +100 val_100 1 +103 val_103 1 +104 val_104 1 +105 val_105 1 +11 val_11 1 +111 val_111 1 +113 val_113 1 +114 val_114 1 +116 val_116 1 +118 val_118 1 +119 val_119 1 +12 val_12 1 +120 val_120 1 +125 val_125 1 +126 val_126 1 +128 val_128 1 +129 val_129 1 +131 val_131 1 +133 val_133 1 +134 val_134 1 +136 val_136 1 +137 val_137 1 +138 val_138 1 +143 val_143 1 +145 val_145 1 +146 val_146 1 +149 val_149 1 +15 val_15 1 +150 val_150 1 +152 val_152 1 +153 val_153 1 +155 val_155 1 +156 val_156 1 +157 val_157 1 +158 val_158 1 +160 val_160 1 +162 val_162 1 +163 val_163 1 +164 val_164 1 +165 val_165 1 +166 val_166 1 +167 val_167 1 +168 val_168 1 +169 val_169 1 +17 val_17 1 +170 val_170 1 +172 val_172 1 +174 val_174 1 +175 val_175 1 +176 val_176 1 +177 val_177 1 +178 val_178 1 +179 val_179 1 +18 val_18 1 +180 val_180 1 +181 val_181 1 +183 val_183 1 +186 val_186 1 +187 val_187 1 +189 val_189 1 +19 val_19 1 +190 val_190 1 +191 val_191 1 +192 val_192 1 +193 val_193 1 +194 val_194 1 +195 val_195 1 +196 val_196 1 +197 val_197 1 +199 val_199 1 +2 val_2 1 +20 val_20 1 +PREHOOK: query: create table lv_table(c1 string) partitioned by(c2 string) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@lv_table +POSTHOOK: query: create table lv_table(c1 string) partitioned by(c2 string) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@lv_table +PREHOOK: query: create view "lv~!@#$%^&*()_q<>" partitioned on (c2) as select c1, c2 from lv_table +PREHOOK: type: CREATEVIEW +PREHOOK: Input: default@lv_table +PREHOOK: Output: database:default +PREHOOK: Output: default@lv~!@#$%^&*()_q<> +POSTHOOK: query: create view "lv~!@#$%^&*()_q<>" partitioned on (c2) as select c1, c2 from lv_table +POSTHOOK: type: CREATEVIEW +POSTHOOK: Input: default@lv_table +POSTHOOK: Output: database:default +POSTHOOK: Output: default@lv~!@#$%^&*()_q<> +POSTHOOK: Lineage: lv~!@#$%^&*()_q<>.c1 SIMPLE [(lv_table)lv_table.FieldSchema(name:c1, type:string, comment:null), ] +PREHOOK: query: alter view "lv~!@#$%^&*()_q<>" add partition (c2='a') +PREHOOK: type: ALTERTABLE_ADDPARTS +PREHOOK: Input: default@lv_table +PREHOOK: Input: default@lv~!@#$%^&*()_q<> +PREHOOK: Output: default@lv~!@#$%^&*()_q<> +POSTHOOK: query: alter view "lv~!@#$%^&*()_q<>" add partition (c2='a') +POSTHOOK: type: ALTERTABLE_ADDPARTS +POSTHOOK: Input: default@lv_table +POSTHOOK: Input: default@lv~!@#$%^&*()_q<> +POSTHOOK: Output: default@lv~!@#$%^&*()_q<> +POSTHOOK: Output: default@lv~!@#$%^&*()_q<>@c2=a diff --git standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/conf/MetastoreConf.java standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/conf/MetastoreConf.java index a874121e12..5cb1b80216 100644 --- standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/conf/MetastoreConf.java +++ standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/conf/MetastoreConf.java @@ -1046,8 +1046,8 @@ public static ConfVars getMetaConf(String name) { "hive.support.special.characters.tablename", true, "This flag should be set to true to enable support for special characters in table names.\n" + "When it is set to false, only [a-zA-Z_0-9]+ are supported.\n" - + "The only supported special character right now is '/'. This flag applies only to quoted table names.\n" - + "The default value is true."), + + "The supported special characters are %&'()*+,-./:;<=>?[]_|{}$^!~#@ and space. This flag applies only to" + + " quoted table names.\nThe default value is true."), TASK_THREADS_ALWAYS("metastore.task.threads.always", "metastore.task.threads.always", EVENT_CLEANER_TASK_CLASS + "," + RUNTIME_STATS_CLEANER_TASK_CLASS + "," + "org.apache.hadoop.hive.metastore.repl.DumpDirCleanerTask" + "," + diff --git standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/MetaStoreUtils.java standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/MetaStoreUtils.java index 62f5773f9b..aa6d7d6d83 100644 --- standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/MetaStoreUtils.java +++ standalone-metastore/metastore-common/src/main/java/org/apache/hadoop/hive/metastore/utils/MetaStoreUtils.java @@ -107,8 +107,14 @@ protected DateFormat initialValue() { // NOTE: // If the following array is updated, please also be sure to update the // configuration parameter documentation - // HIVE_SUPPORT_SPECICAL_CHARACTERS_IN_TABLE_NAMES in HiveConf as well. - private static final char[] specialCharactersInTableNames = new char[] { '/' }; + // HIVE_SUPPORT_SPECICAL_CHARACTERS_IN_TABLE_NAMES in MetastoreConf as well. + private static final char[] specialCharactersInTableNames = new char[] { + // standard + ' ', '"', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', + '_', '|', '{', '}', '$', '^', + // non-standard + '!', '~', '#', '@' + }; /** * Catches exceptions that can't be handled and bundles them to MetaException @@ -188,15 +194,15 @@ public static MetaException newMetaException(String errorMessage, Exception e) { */ public static boolean validateName(String name, Configuration conf) { Pattern tpat; - String allowedCharacters = "\\w_"; + String allowedSpecialCharacters = ""; if (conf != null && MetastoreConf.getBoolVar(conf, MetastoreConf.ConfVars.SUPPORT_SPECICAL_CHARACTERS_IN_TABLE_NAMES)) { for (Character c : specialCharactersInTableNames) { - allowedCharacters += c; + allowedSpecialCharacters += c; } } - tpat = Pattern.compile("[" + allowedCharacters + "]+"); + tpat = Pattern.compile("[\\w" + Pattern.quote(allowedSpecialCharacters) + "]+"); Matcher m = tpat.matcher(name); return m.matches(); } diff --git standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index 77d34047a4..6142d9fad4 100644 --- standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -1397,7 +1397,7 @@ static boolean isDbReplicationTarget(Database db) { // Assumes that the catalog has already been set. private void create_database_core(RawStore ms, final Database db) throws AlreadyExistsException, InvalidObjectException, MetaException { - if (!MetaStoreUtils.validateName(db.getName(), null)) { + if (!MetaStoreUtils.validateName(db.getName(), conf)) { throw new InvalidObjectException(db.getName() + " is not a valid database name"); } diff --git standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java index 3f04abe47a..dc91b71db9 100644 --- standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java +++ standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java @@ -1856,7 +1856,7 @@ public void testCreateTableSettingId() throws Exception { @Test public void testAlterTable() throws Exception { String dbName = "alterdb"; - String invTblName = "alter-tbl"; + String invTblName = "alter§tbl"; String tblName = "altertbl"; try { diff --git standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestDatabases.java standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestDatabases.java index 9d7cfd2a32..45f754e64a 100644 --- standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestDatabases.java +++ standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestDatabases.java @@ -187,7 +187,7 @@ public void testCreateDatabaseInvalidName() throws Exception { Database database = testDatabases[0]; // Invalid character in new database name - database.setName("test_database_1;"); + database.setName("test_database§1;"); client.createDatabase(database); } diff --git standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestTablesCreateDropAlterTruncate.java standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestTablesCreateDropAlterTruncate.java index 6d82d794ca..79fd105333 100644 --- standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestTablesCreateDropAlterTruncate.java +++ standalone-metastore/metastore-server/src/test/java/org/apache/hadoop/hive/metastore/client/TestTablesCreateDropAlterTruncate.java @@ -394,7 +394,7 @@ public void testCreateTableNullTableName() throws Exception { @Test(expected = InvalidObjectException.class) public void testCreateTableInvalidTableName() throws Exception { Table table = testTables[0]; - table.setTableName("test_table;"); + table.setTableName("test§table;"); client.createTable(table); }