diff --git ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java new file mode 100644 index 0000000..15c01f7 --- /dev/null +++ ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java @@ -0,0 +1,797 @@ +/** + * 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.ant; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; + +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Task; + +/** + * This class generates java classes from the templates. + */ +public class GenVectorCode extends Task { + + private static String [][] templateExpansions = + { + {"ColumnArithmeticScalar", "Add", "long", "long", "+"}, + {"ColumnArithmeticScalar", "Subtract", "long", "long", "-"}, + {"ColumnArithmeticScalar", "Multiply", "long", "long", "*"}, + {"ColumnArithmeticScalar", "Modulo", "long", "long", "%"}, + + {"ColumnArithmeticScalar", "Add", "long", "double", "+"}, + {"ColumnArithmeticScalar", "Subtract", "long", "double", "-"}, + {"ColumnArithmeticScalar", "Multiply", "long", "double", "*"}, + {"ColumnArithmeticScalar", "Divide", "long", "double", "/"}, + {"ColumnArithmeticScalar", "Modulo", "long", "double", "%"}, + + {"ColumnArithmeticScalar", "Add", "double", "long", "+"}, + {"ColumnArithmeticScalar", "Subtract", "double", "long", "-"}, + {"ColumnArithmeticScalar", "Multiply", "double", "long", "*"}, + {"ColumnArithmeticScalar", "Divide", "double", "long", "/"}, + {"ColumnArithmeticScalar", "Modulo", "double", "long", "%"}, + + {"ColumnArithmeticScalar", "Add", "double", "double", "+"}, + {"ColumnArithmeticScalar", "Subtract", "double", "double", "-"}, + {"ColumnArithmeticScalar", "Multiply", "double", "double", "*"}, + {"ColumnArithmeticScalar", "Divide", "double", "double", "/"}, + {"ColumnArithmeticScalar", "Modulo", "double", "double", "%"}, + + {"ScalarArithmeticColumn", "Add", "long", "long", "+"}, + {"ScalarArithmeticColumn", "Subtract", "long", "long", "-"}, + {"ScalarArithmeticColumn", "Multiply", "long", "long", "*"}, + {"ScalarArithmeticColumn", "Modulo", "long", "long", "%"}, + + {"ScalarArithmeticColumn", "Add", "long", "double", "+"}, + {"ScalarArithmeticColumn", "Subtract", "long", "double", "-"}, + {"ScalarArithmeticColumn", "Multiply", "long", "double", "*"}, + {"ScalarArithmeticColumn", "Divide", "long", "double", "/"}, + {"ScalarArithmeticColumn", "Modulo", "long", "double", "%"}, + + {"ScalarArithmeticColumn", "Add", "double", "long", "+"}, + {"ScalarArithmeticColumn", "Subtract", "double", "long", "-"}, + {"ScalarArithmeticColumn", "Multiply", "double", "long", "*"}, + {"ScalarArithmeticColumn", "Divide", "double", "long", "/"}, + {"ScalarArithmeticColumn", "Modulo", "double", "long", "%"}, + + {"ScalarArithmeticColumn", "Add", "double", "double", "+"}, + {"ScalarArithmeticColumn", "Subtract", "double", "double", "-"}, + {"ScalarArithmeticColumn", "Multiply", "double", "double", "*"}, + {"ScalarArithmeticColumn", "Divide", "double", "double", "/"}, + {"ScalarArithmeticColumn", "Modulo", "double", "double", "%"}, + + {"ColumnArithmeticColumn", "Add", "long", "long", "+"}, + {"ColumnArithmeticColumn", "Subtract", "long", "long", "-"}, + {"ColumnArithmeticColumn", "Multiply", "long", "long", "*"}, + {"ColumnArithmeticColumn", "Modulo", "long", "long", "%"}, + + {"ColumnArithmeticColumn", "Add", "long", "double", "+"}, + {"ColumnArithmeticColumn", "Subtract", "long", "double", "-"}, + {"ColumnArithmeticColumn", "Multiply", "long", "double", "*"}, + {"ColumnArithmeticColumn", "Divide", "long", "double", "/"}, + {"ColumnArithmeticColumn", "Modulo", "long", "double", "%"}, + + {"ColumnArithmeticColumn", "Add", "double", "long", "+"}, + {"ColumnArithmeticColumn", "Subtract", "double", "long", "-"}, + {"ColumnArithmeticColumn", "Multiply", "double", "long", "*"}, + {"ColumnArithmeticColumn", "Divide", "double", "long", "/"}, + {"ColumnArithmeticColumn", "Modulo", "double", "long", "%"}, + + {"ColumnArithmeticColumn", "Add", "double", "double", "+"}, + {"ColumnArithmeticColumn", "Subtract", "double", "double", "-"}, + {"ColumnArithmeticColumn", "Multiply", "double", "double", "*"}, + {"ColumnArithmeticColumn", "Divide", "double", "double", "/"}, + {"ColumnArithmeticColumn", "Modulo", "double", "double", "%"}, + + {"ColumnCompareScalar", "Equal", "long", "double", "=="}, + {"ColumnCompareScalar", "Equal", "double", "double", "=="}, + {"ColumnCompareScalar", "NotEqual", "long", "double", "!="}, + {"ColumnCompareScalar", "NotEqual", "double", "double", "!="}, + {"ColumnCompareScalar", "Less", "long", "double", "<"}, + {"ColumnCompareScalar", "Less", "double", "double", "<"}, + {"ColumnCompareScalar", "LessEqual", "long", "double", "<="}, + {"ColumnCompareScalar", "LessEqual", "double", "double", "<="}, + {"ColumnCompareScalar", "Greater", "long", "double", ">"}, + {"ColumnCompareScalar", "Greater", "double", "double", ">"}, + {"ColumnCompareScalar", "GreaterEqual", "long", "double", ">="}, + {"ColumnCompareScalar", "GreaterEqual", "double", "double", ">="}, + + {"FilterColumnCompareScalar", "Equal", "long", "double", "=="}, + {"FilterColumnCompareScalar", "Equal", "double", "double", "=="}, + {"FilterColumnCompareScalar", "NotEqual", "long", "double", "!="}, + {"FilterColumnCompareScalar", "NotEqual", "double", "double", "!="}, + {"FilterColumnCompareScalar", "Less", "long", "double", "<"}, + {"FilterColumnCompareScalar", "Less", "double", "double", "<"}, + {"FilterColumnCompareScalar", "LessEqual", "long", "double", "<="}, + {"FilterColumnCompareScalar", "LessEqual", "double", "double", "<="}, + {"FilterColumnCompareScalar", "Greater", "long", "double", ">"}, + {"FilterColumnCompareScalar", "Greater", "double", "double", ">"}, + {"FilterColumnCompareScalar", "GreaterEqual", "long", "double", ">="}, + {"FilterColumnCompareScalar", "GreaterEqual", "double", "double", ">="}, + + {"FilterColumnCompareScalar", "Equal", "long", "long", "=="}, + {"FilterColumnCompareScalar", "Equal", "double", "long", "=="}, + {"FilterColumnCompareScalar", "NotEqual", "long", "long", "!="}, + {"FilterColumnCompareScalar", "NotEqual", "double", "long", "!="}, + {"FilterColumnCompareScalar", "Less", "long", "long", "<"}, + {"FilterColumnCompareScalar", "Less", "double", "long", "<"}, + {"FilterColumnCompareScalar", "LessEqual", "long", "long", "<="}, + {"FilterColumnCompareScalar", "LessEqual", "double", "long", "<="}, + {"FilterColumnCompareScalar", "Greater", "long", "long", ">"}, + {"FilterColumnCompareScalar", "Greater", "double", "long", ">"}, + {"FilterColumnCompareScalar", "GreaterEqual", "long", "long", ">="}, + {"FilterColumnCompareScalar", "GreaterEqual", "double", "long", ">="}, + + {"FilterScalarCompareColumn", "Equal", "long", "double", "=="}, + {"FilterScalarCompareColumn", "Equal", "double", "double", "=="}, + {"FilterScalarCompareColumn", "NotEqual", "long", "double", "!="}, + {"FilterScalarCompareColumn", "NotEqual", "double", "double", "!="}, + {"FilterScalarCompareColumn", "Less", "long", "double", "<"}, + {"FilterScalarCompareColumn", "Less", "double", "double", "<"}, + {"FilterScalarCompareColumn", "LessEqual", "long", "double", "<="}, + {"FilterScalarCompareColumn", "LessEqual", "double", "double", "<="}, + {"FilterScalarCompareColumn", "Greater", "long", "double", ">"}, + {"FilterScalarCompareColumn", "Greater", "double", "double", ">"}, + {"FilterScalarCompareColumn", "GreaterEqual", "long", "double", ">="}, + {"FilterScalarCompareColumn", "GreaterEqual", "double", "double", ">="}, + + {"FilterScalarCompareColumn", "Equal", "long", "long", "=="}, + {"FilterScalarCompareColumn", "Equal", "double", "long", "=="}, + {"FilterScalarCompareColumn", "NotEqual", "long", "long", "!="}, + {"FilterScalarCompareColumn", "NotEqual", "double", "long", "!="}, + {"FilterScalarCompareColumn", "Less", "long", "long", "<"}, + {"FilterScalarCompareColumn", "Less", "double", "long", "<"}, + {"FilterScalarCompareColumn", "LessEqual", "long", "long", "<="}, + {"FilterScalarCompareColumn", "LessEqual", "double", "long", "<="}, + {"FilterScalarCompareColumn", "Greater", "long", "long", ">"}, + {"FilterScalarCompareColumn", "Greater", "double", "long", ">"}, + {"FilterScalarCompareColumn", "GreaterEqual", "long", "long", ">="}, + {"FilterScalarCompareColumn", "GreaterEqual", "double", "long", ">="}, + + {"FilterStringColumnCompareScalar", "Equal", "=="}, + {"FilterStringColumnCompareScalar", "NotEqual", "!="}, + {"FilterStringColumnCompareScalar", "Less", "<"}, + {"FilterStringColumnCompareScalar", "LessEqual", "<="}, + {"FilterStringColumnCompareScalar", "Greater", ">"}, + {"FilterStringColumnCompareScalar", "GreaterEqual", ">="}, + + {"FilterStringScalarCompareColumn", "Equal", "=="}, + {"FilterStringScalarCompareColumn", "NotEqual", "!="}, + {"FilterStringScalarCompareColumn", "Less", "<"}, + {"FilterStringScalarCompareColumn", "LessEqual", "<="}, + {"FilterStringScalarCompareColumn", "Greater", ">"}, + {"FilterStringScalarCompareColumn", "GreaterEqual", ">="}, + + {"FilterStringColumnCompareColumn", "Equal", "=="}, + {"FilterStringColumnCompareColumn", "NotEqual", "!="}, + {"FilterStringColumnCompareColumn", "Less", "<"}, + {"FilterStringColumnCompareColumn", "LessEqual", "<="}, + {"FilterStringColumnCompareColumn", "Greater", ">"}, + {"FilterStringColumnCompareColumn", "GreaterEqual", ">="}, + + {"FilterColumnCompareColumn", "Equal", "long", "double", "=="}, + {"FilterColumnCompareColumn", "Equal", "double", "double", "=="}, + {"FilterColumnCompareColumn", "NotEqual", "long", "double", "!="}, + {"FilterColumnCompareColumn", "NotEqual", "double", "double", "!="}, + {"FilterColumnCompareColumn", "Less", "long", "double", "<"}, + {"FilterColumnCompareColumn", "Less", "double", "double", "<"}, + {"FilterColumnCompareColumn", "LessEqual", "long", "double", "<="}, + {"FilterColumnCompareColumn", "LessEqual", "double", "double", "<="}, + {"FilterColumnCompareColumn", "Greater", "long", "double", ">"}, + {"FilterColumnCompareColumn", "Greater", "double", "double", ">"}, + {"FilterColumnCompareColumn", "GreaterEqual", "long", "double", ">="}, + {"FilterColumnCompareColumn", "GreaterEqual", "double", "double", ">="}, + + {"FilterColumnCompareColumn", "Equal", "long", "long", "=="}, + {"FilterColumnCompareColumn", "Equal", "double", "long", "=="}, + {"FilterColumnCompareColumn", "NotEqual", "long", "long", "!="}, + {"FilterColumnCompareColumn", "NotEqual", "double", "long", "!="}, + {"FilterColumnCompareColumn", "Less", "long", "long", "<"}, + {"FilterColumnCompareColumn", "Less", "double", "long", "<"}, + {"FilterColumnCompareColumn", "LessEqual", "long", "long", "<="}, + {"FilterColumnCompareColumn", "LessEqual", "double", "long", "<="}, + {"FilterColumnCompareColumn", "Greater", "long", "long", ">"}, + {"FilterColumnCompareColumn", "Greater", "double", "long", ">"}, + {"FilterColumnCompareColumn", "GreaterEqual", "long", "long", ">="}, + {"FilterColumnCompareColumn", "GreaterEqual", "double", "long", ">="}, + + {"ColumnUnaryMinus", "long"}, + {"ColumnUnaryMinus", "double"}, + + // template, , , , , + {"VectorUDAFMinMax", "VectorUDAFMinLong", "long", "<", "min", + "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: long)"}, + {"VectorUDAFMinMax", "VectorUDAFMinDouble", "double", "<", "min", + "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: double)"}, + {"VectorUDAFMinMax", "VectorUDAFMaxLong", "long", ">", "max", + "_FUNC_(expr) - Returns the maximum value of expr (vectorized, type: long)"}, + {"VectorUDAFMinMax", "VectorUDAFMaxDouble", "double", ">", "max", + "_FUNC_(expr) - Returns the maximum value of expr (vectorized, type: double)"}, + + {"VectorUDAFMinMaxString", "VectorUDAFMinString", "<", "min", + "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: string)"}, + {"VectorUDAFMinMaxString", "VectorUDAFMaxString", ">", "max", + "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: string)"}, + + //template, , + {"VectorUDAFSum", "VectorUDAFSumLong", "long"}, + {"VectorUDAFSum", "VectorUDAFSumDouble", "double"}, + {"VectorUDAFAvg", "VectorUDAFAvgLong", "long"}, + {"VectorUDAFAvg", "VectorUDAFAvgDouble", "double"}, + + // template, , , , , + // + {"VectorUDAFVar", "VectorUDAFVarPopLong", "long", "myagg.variance / myagg.count", + "variance, var_pop", + "_FUNC_(x) - Returns the variance of a set of numbers (vectorized, long)"}, + {"VectorUDAFVar", "VectorUDAFVarPopDouble", "double", "myagg.variance / myagg.count", + "variance, var_pop", + "_FUNC_(x) - Returns the variance of a set of numbers (vectorized, double)"}, + {"VectorUDAFVar", "VectorUDAFVarSampLong", "long", "myagg.variance / (myagg.count-1.0)", + "var_samp", + "_FUNC_(x) - Returns the sample variance of a set of numbers (vectorized, long)"}, + {"VectorUDAFVar", "VectorUDAFVarSampDouble", "double", "myagg.variance / (myagg.count-1.0)", + "var_samp", + "_FUNC_(x) - Returns the sample variance of a set of numbers (vectorized, double)"}, + {"VectorUDAFVar", "VectorUDAFStdPopLong", "long", + "Math.sqrt(myagg.variance / (myagg.count))", "std,stddev,stddev_pop", + "_FUNC_(x) - Returns the standard deviation of a set of numbers (vectorized, long)"}, + {"VectorUDAFVar", "VectorUDAFStdPopDouble", "double", + "Math.sqrt(myagg.variance / (myagg.count))", "std,stddev,stddev_pop", + "_FUNC_(x) - Returns the standard deviation of a set of numbers (vectorized, double)"}, + {"VectorUDAFVar", "VectorUDAFStdSampLong", "long", + "Math.sqrt(myagg.variance / (myagg.count-1.0))", "stddev_samp", + "_FUNC_(x) - Returns the sample standard deviation of a set of numbers (vectorized, long)"}, + {"VectorUDAFVar", "VectorUDAFStdSampDouble", "double", + "Math.sqrt(myagg.variance / (myagg.count-1.0))", "stddev_samp", + "_FUNC_(x) - Returns the sample standard deviation of a set of numbers (vectorized, double)"}, + + }; + + + private String templateBaseDir; + private String buildDir; + + private String expressionOutputDirectory; + private String expressionTemplateDirectory; + private String udafOutputDirectory; + private String udafTemplateDirectory; + private GenVectorTestCode testCodeGen; + + static String joinPath(String...parts) { + String path = parts[0]; + for (int i=1; i < parts.length; ++i) { + path += File.separatorChar + parts[i]; + } + return path; + } + + public void init(String templateBaseDir, String buildDir) { + File generationDirectory = new File(templateBaseDir); + + String buildPath = joinPath(buildDir, "ql", "gen", "vector"); + + File exprOutput = new File(joinPath(buildPath, "org", "apache", "hadoop", + "hive", "ql", "exec", "vector", "expressions", "gen")); + expressionOutputDirectory = exprOutput.getAbsolutePath(); + + expressionTemplateDirectory = + joinPath(generationDirectory.getAbsolutePath(), "ExpressionTemplates"); + + File udafOutput = new File(joinPath(buildPath, "org", "apache", "hadoop", + "hive", "ql", "exec", "vector", "expressions", "aggregates", "gen")); + udafOutputDirectory = udafOutput.getAbsolutePath(); + + udafTemplateDirectory = + joinPath(generationDirectory.getAbsolutePath(), "UDAFTemplates"); + + File testCodeOutput = + new File( + joinPath(buildDir, "ql", "test", "src", "org", + "apache", "hadoop", "hive", "ql", "exec", "vector", + "expressions", "gen")); + testCodeGen = new GenVectorTestCode(testCodeOutput.getAbsolutePath(), + joinPath(generationDirectory.getAbsolutePath(), "TestTemplates")); + } + + /** + * @param args + * @throws Exception + */ + public static void main(String[] args) throws Exception { + GenVectorCode gen = new GenVectorCode(); + gen.init(System.getProperty("user.dir"), + joinPath(System.getProperty("user.dir"), "..", "..", "..", "..", "build")); + gen.generate(); + } + + @Override + public void execute() throws BuildException { + init(templateBaseDir, buildDir); + try { + this.generate(); + } catch (Exception e) { + new BuildException(e); + } + } + + private void generate() throws Exception { + System.out.println("Generating vector expression code"); + for (String [] tdesc : templateExpansions) { + if (tdesc[0].equals("ColumnArithmeticScalar")) { + generateColumnArithmeticScalar(tdesc); + } else if (tdesc[0].equals("ColumnCompareScalar")) { + generateColumnCompareScalar(tdesc); + } else if (tdesc[0].equals("FilterColumnCompareScalar")) { + generateFilterColumnCompareScalar(tdesc); + } else if (tdesc[0].equals("FilterScalarCompareColumn")) { + generateFilterScalarCompareColumn(tdesc); + } else if (tdesc[0].equals("ScalarArithmeticColumn")) { + generateScalarArithmeticColumn(tdesc); + } else if (tdesc[0].equals("FilterColumnCompareColumn")) { + generateFilterColumnCompareColumn(tdesc); + } else if (tdesc[0].equals("ColumnArithmeticColumn")) { + generateColumnArithmeticColumn(tdesc); + } else if (tdesc[0].equals("ColumnUnaryMinus")) { + generateColumnUnaryMinus(tdesc); + } else if (tdesc[0].equals("VectorUDAFMinMax")) { + generateVectorUDAFMinMax(tdesc); + } else if (tdesc[0].equals("VectorUDAFMinMaxString")) { + generateVectorUDAFMinMaxString(tdesc); + } else if (tdesc[0].equals("VectorUDAFSum")) { + generateVectorUDAFSum(tdesc); + } else if (tdesc[0].equals("VectorUDAFAvg")) { + generateVectorUDAFAvg(tdesc); + } else if (tdesc[0].equals("VectorUDAFVar")) { + generateVectorUDAFVar(tdesc); + } else if (tdesc[0].equals("FilterStringColumnCompareScalar")) { + generateFilterStringColumnCompareScalar(tdesc); + } else if (tdesc[0].equals("FilterStringScalarCompareColumn")) { + generateFilterStringScalarCompareColumn(tdesc); + } else if (tdesc[0].equals("FilterStringColumnCompareColumn")) { + generateFilterStringColumnCompareColumn(tdesc); + } else { + continue; + } + } + System.out.println("Generating vector expression test code"); + testCodeGen.generateTestSuites(); + } + + private void generateVectorUDAFMinMax(String[] tdesc) throws Exception { + String className = tdesc[1]; + String valueType = tdesc[2]; + String operatorSymbol = tdesc[3]; + String descName = tdesc[4]; + String descValue = tdesc[5]; + String columnType = getColumnVectorType(valueType); + String writableType = getOutputWritableType(valueType); + String inspectorType = getOutputObjectInspector(valueType); + + String outputFile = joinPath(this.udafOutputDirectory, className + ".java"); + String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt"); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", valueType); + templateString = templateString.replaceAll("", operatorSymbol); + templateString = templateString.replaceAll("", columnType); + templateString = templateString.replaceAll("", descName); + templateString = templateString.replaceAll("", descValue); + templateString = templateString.replaceAll("", writableType); + templateString = templateString.replaceAll("", inspectorType); + writeFile(outputFile, templateString); + + } + + private void generateVectorUDAFMinMaxString(String[] tdesc) throws Exception { + String className = tdesc[1]; + String operatorSymbol = tdesc[2]; + String descName = tdesc[3]; + String descValue = tdesc[4]; + + String outputFile = joinPath(this.udafOutputDirectory, className + ".java"); + String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt"); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", operatorSymbol); + templateString = templateString.replaceAll("", descName); + templateString = templateString.replaceAll("", descValue); + writeFile(outputFile, templateString); + + } + + private void generateVectorUDAFSum(String[] tdesc) throws Exception { + //template, , , , + String className = tdesc[1]; + String valueType = tdesc[2]; + String columnType = getColumnVectorType(valueType); + String writableType = getOutputWritableType(valueType); + String inspectorType = getOutputObjectInspector(valueType); + + String outputFile = joinPath(this.udafOutputDirectory, className + ".java"); + String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt"); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", valueType); + templateString = templateString.replaceAll("", columnType); + templateString = templateString.replaceAll("", writableType); + templateString = templateString.replaceAll("", inspectorType); + writeFile(outputFile, templateString); + } + + private void generateVectorUDAFAvg(String[] tdesc) throws IOException { + String className = tdesc[1]; + String valueType = tdesc[2]; + String columnType = getColumnVectorType(valueType); + + String outputFile = joinPath(this.udafOutputDirectory, className + ".java"); + String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt"); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", valueType); + templateString = templateString.replaceAll("", columnType); + writeFile(outputFile, templateString); + } + + private void generateVectorUDAFVar(String[] tdesc) throws IOException { + String className = tdesc[1]; + String valueType = tdesc[2]; + String varianceFormula = tdesc[3]; + String descriptionName = tdesc[4]; + String descriptionValue = tdesc[5]; + String columnType = getColumnVectorType(valueType); + + String outputFile = joinPath(this.udafOutputDirectory, className + ".java"); + String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt"); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", valueType); + templateString = templateString.replaceAll("", columnType); + templateString = templateString.replaceAll("", varianceFormula); + templateString = templateString.replaceAll("", descriptionName); + templateString = templateString.replaceAll("", descriptionValue); + writeFile(outputFile, templateString); + } + + private void generateFilterStringScalarCompareColumn(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String className = "FilterStringScalar" + operatorName + "StringColumn"; + + // Template expansion logic is the same for both column-scalar and scalar-column cases. + generateFilterStringColumnCompareScalar(tdesc, className); + } + + private void generateFilterStringColumnCompareScalar(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String className = "FilterStringCol" + operatorName + "StringScalar"; + generateFilterStringColumnCompareScalar(tdesc, className); + } + + private void generateFilterStringColumnCompareColumn(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String className = "FilterStringCol" + operatorName + "StringColumn"; + generateFilterStringColumnCompareScalar(tdesc, className); + } + + private void generateFilterStringColumnCompareScalar(String[] tdesc, String className) + throws IOException { + String operatorSymbol = tdesc[2]; + String outputFile = joinPath(this.expressionOutputDirectory, className + ".java"); + // Read the template into a string; + String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"); + String templateString = readFile(templateFile); + // Expand, and write result + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", operatorSymbol); + writeFile(outputFile, templateString); + } + + private void generateFilterColumnCompareColumn(String[] tdesc) throws IOException { + //The variables are all same as ColumnCompareScalar except that + //this template doesn't need a return type. Pass anything as return type. + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = "Filter" + getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Column"; + generateColumnBinaryOperatorColumn(tdesc, null, className); + } + + private void generateColumnUnaryMinus(String[] tdesc) throws IOException { + String operandType = tdesc[1]; + String inputColumnVectorType = this.getColumnVectorType(operandType); + String outputColumnVectorType = inputColumnVectorType; + String returnType = operandType; + String className = getCamelCaseType(operandType) + "ColUnaryMinus"; + String outputFile = joinPath(this.expressionOutputDirectory, className + ".java"); + String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"); + String templateString = readFile(templateFile); + // Expand, and write result + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", inputColumnVectorType); + templateString = templateString.replaceAll("", outputColumnVectorType); + templateString = templateString.replaceAll("", operandType); + templateString = templateString.replaceAll("", returnType); + writeFile(outputFile, templateString); + } + + private void generateColumnArithmeticColumn(String [] tdesc) throws IOException { + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Column"; + String returnType = getArithmeticReturnType(operandType1, operandType2); + generateColumnBinaryOperatorColumn(tdesc, returnType, className); + } + + private void generateFilterColumnCompareScalar(String[] tdesc) throws IOException { + //The variables are all same as ColumnCompareScalar except that + //this template doesn't need a return type. Pass anything as return type. + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = "Filter" + getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; + generateColumnBinaryOperatorScalar(tdesc, null, className); + } + + private void generateFilterScalarCompareColumn(String[] tdesc) throws IOException { + //this template doesn't need a return type. Pass anything as return type. + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = "Filter" + getCamelCaseType(operandType1) + + "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column"; + generateScalarBinaryOperatorColumn(tdesc, null, className); + } + + private void generateColumnCompareScalar(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String returnType = "long"; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; + generateColumnBinaryOperatorScalar(tdesc, returnType, className); + } + + private void generateColumnBinaryOperatorColumn(String[] tdesc, String returnType, + String className) throws IOException { + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String outputColumnVectorType = this.getColumnVectorType(returnType); + String inputColumnVectorType1 = this.getColumnVectorType(operandType1); + String inputColumnVectorType2 = this.getColumnVectorType(operandType2); + String operatorSymbol = tdesc[4]; + String outputFile = joinPath(this.expressionOutputDirectory, className + ".java"); + + //Read the template into a string; + String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"); + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", inputColumnVectorType1); + templateString = templateString.replaceAll("", inputColumnVectorType2); + templateString = templateString.replaceAll("", outputColumnVectorType); + templateString = templateString.replaceAll("", operatorSymbol); + templateString = templateString.replaceAll("", operandType1); + templateString = templateString.replaceAll("", operandType2); + templateString = templateString.replaceAll("", returnType); + templateString = templateString.replaceAll("", getCamelCaseType(returnType)); + writeFile(outputFile, templateString); + + if(returnType==null){ + testCodeGen.addColumnColumnFilterTestCases( + className, + inputColumnVectorType1, + inputColumnVectorType2, + operatorSymbol); + }else{ + testCodeGen.addColumnColumnOperationTestCases( + className, + inputColumnVectorType1, + inputColumnVectorType2, + outputColumnVectorType); + } + } + + private void generateColumnBinaryOperatorScalar(String[] tdesc, String returnType, + String className) throws IOException { + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String outputColumnVectorType = this.getColumnVectorType(returnType); + String inputColumnVectorType = this.getColumnVectorType(operandType1); + String operatorSymbol = tdesc[4]; + String outputFile = joinPath(this.expressionOutputDirectory, className + ".java"); + + //Read the template into a string; + String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"); + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", inputColumnVectorType); + templateString = templateString.replaceAll("", outputColumnVectorType); + templateString = templateString.replaceAll("", operatorSymbol); + templateString = templateString.replaceAll("", operandType1); + templateString = templateString.replaceAll("", operandType2); + templateString = templateString.replaceAll("", returnType); + writeFile(outputFile, templateString); + + if(returnType==null) { + testCodeGen.addColumnScalarFilterTestCases( + true, + className, + inputColumnVectorType, + operandType2, + operatorSymbol); + } else { + testCodeGen.addColumnScalarOperationTestCases( + true, + className, + inputColumnVectorType, + outputColumnVectorType, + operandType2); + } + } + + private void generateScalarBinaryOperatorColumn(String[] tdesc, String returnType, + String className) throws IOException { + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String outputColumnVectorType = this.getColumnVectorType(returnType); + String inputColumnVectorType = this.getColumnVectorType(operandType2); + String operatorSymbol = tdesc[4]; + String outputFile = joinPath(this.expressionOutputDirectory, className + ".java"); + + //Read the template into a string; + String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"); + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + templateString = templateString.replaceAll("", inputColumnVectorType); + templateString = templateString.replaceAll("", outputColumnVectorType); + templateString = templateString.replaceAll("", operatorSymbol); + templateString = templateString.replaceAll("", operandType1); + templateString = templateString.replaceAll("", operandType2); + templateString = templateString.replaceAll("", returnType); + writeFile(outputFile, templateString); + + if(returnType==null) { + testCodeGen.addColumnScalarFilterTestCases( + false, + className, + inputColumnVectorType, + operandType1, + operatorSymbol); + } else { + testCodeGen.addColumnScalarOperationTestCases( + false, + className, + inputColumnVectorType, + outputColumnVectorType, + operandType1); + } + } + + //Binary arithmetic operator + private void generateColumnArithmeticScalar(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; + String returnType = getArithmeticReturnType(operandType1, operandType2); + generateColumnBinaryOperatorScalar(tdesc, returnType, className); + } + + private void generateScalarArithmeticColumn(String[] tdesc) throws IOException { + String operatorName = tdesc[1]; + String operandType1 = tdesc[2]; + String operandType2 = tdesc[3]; + String className = getCamelCaseType(operandType1) + + "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column"; + String returnType = getArithmeticReturnType(operandType1, operandType2); + generateScalarBinaryOperatorColumn(tdesc, returnType, className); + } + + + static void writeFile(String outputFile, String str) throws IOException { + BufferedWriter w = new BufferedWriter(new FileWriter(outputFile)); + w.write(str); + w.close(); + } + + static String readFile(String templateFile) throws IOException { + BufferedReader r = new BufferedReader(new FileReader(templateFile)); + String line = r.readLine(); + StringBuilder b = new StringBuilder(); + while (line != null) { + b.append(line); + b.append("\n"); + line = r.readLine(); + } + r.close(); + return b.toString(); + } + + static String getCamelCaseType(String type) { + if (type == null) { + return null; + } + if (type.equals("long")) { + return "Long"; + } else if (type.equals("double")) { + return "Double"; + } else { + return type; + } + } + + private String getArithmeticReturnType(String operandType1, + String operandType2) { + if (operandType1.equals("double") || + operandType2.equals("double")) { + return "double"; + } else { + return "long"; + } + } + + private String getColumnVectorType(String primitiveType) { + if(primitiveType!=null && primitiveType.equals("double")) { + return "DoubleColumnVector"; + } + return "LongColumnVector"; + } + + private String getOutputWritableType(String primitiveType) throws Exception { + if (primitiveType.equals("long")) { + return "LongWritable"; + } else if (primitiveType.equals("double")) { + return "DoubleWritable"; + } + throw new Exception("Unimplemented primitive output writable: " + primitiveType); + } + + private String getOutputObjectInspector(String primitiveType) throws Exception { + if (primitiveType.equals("long")) { + return "PrimitiveObjectInspectorFactory.writableLongObjectInspector"; + } else if (primitiveType.equals("double")) { + return "PrimitiveObjectInspectorFactory.writableDoubleObjectInspector"; + } + throw new Exception("Unimplemented primitive output inspector: " + primitiveType); + } + + public void setTemplateBaseDir(String templateBaseDir) { + this.templateBaseDir = templateBaseDir; + } + + public void setBuildDir(String buildDir) { + this.buildDir = buildDir; + } +} + diff --git ant/src/org/apache/hadoop/hive/ant/GenVectorTestCode.java ant/src/org/apache/hadoop/hive/ant/GenVectorTestCode.java new file mode 100644 index 0000000..4065067 --- /dev/null +++ ant/src/org/apache/hadoop/hive/ant/GenVectorTestCode.java @@ -0,0 +1,258 @@ +/** + * 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.ant; + +import java.io.IOException; +import java.util.HashMap; + +/** + * + * GenVectorTestCode. + * This class is mutable and maintains a hashmap of TestSuiteClassName to test cases. + * The tests cases are added over the course of vectorized expressions class generation, + * with test classes being outputted at the end. For each column vector (inputs and/or outputs) + * a matrix of pairwise covering Booleans is used to generate test cases across nulls and + * repeating dimensions. Based on the input column vector(s) nulls and repeating states + * the states of the output column vector (if there is one) is validated, along with the null + * vector. For filter operations the selection vector is validated against the generated + * data. Each template corresponds to a class representing a test suite. + */ +public class GenVectorTestCode { + + public enum TestSuiteClassName{ + TestColumnScalarOperationVectorExpressionEvaluation, + TestColumnScalarFilterVectorExpressionEvaluation, + TestColumnColumnOperationVectorExpressionEvaluation, + TestColumnColumnFilterVectorExpressionEvaluation, + } + + private final String testOutputDir; + private final String testTemplateDirectory; + private final HashMap testsuites; + + public GenVectorTestCode(String testOutputDir, String testTemplateDirectory) { + this.testOutputDir = testOutputDir; + this.testTemplateDirectory = testTemplateDirectory; + testsuites = new HashMap(); + + for(TestSuiteClassName className : TestSuiteClassName.values()) { + testsuites.put(className,new StringBuilder()); + } + + } + + public void addColumnScalarOperationTestCases(boolean op1IsCol, String vectorExpClassName, + String inputColumnVectorType, String outputColumnVectorType, String scalarType) + throws IOException { + + TestSuiteClassName template = + TestSuiteClassName.TestColumnScalarOperationVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = GenVectorCode.joinPath(this.testTemplateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(GenVectorCode.readFile(templateFile)); + + for(Boolean[] testMatrix :new Boolean[][]{ + // Pairwise: InitOuputColHasNulls, InitOuputColIsRepeating, ColumnHasNulls, ColumnIsRepeating + {false, true, true, true}, + {false, false, false, false}, + {true, false, true, false}, + {true, true, false, false}, + {true, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Out", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("Col", testMatrix[2], testMatrix[3])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType); + testCase = testCase.replaceAll("", outputColumnVectorType); + testCase = testCase.replaceAll("", scalarType); + testCase = testCase.replaceAll("", GenVectorCode.getCamelCaseType(scalarType)); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + + if(op1IsCol){ + testCase = testCase.replaceAll("","0, scalarValue"); + }else{ + testCase = testCase.replaceAll("","scalarValue, 0"); + } + + testsuites.get(template).append(testCase); + } + } + + public void addColumnScalarFilterTestCases(boolean op1IsCol, String vectorExpClassName, + String inputColumnVectorType, String scalarType, String operatorSymbol) + throws IOException { + + TestSuiteClassName template = + TestSuiteClassName.TestColumnScalarFilterVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = GenVectorCode.joinPath(this.testTemplateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(GenVectorCode.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: ColumnHasNulls, ColumnIsRepeating + {true, true}, + {true, false}, + {false, false}, + {false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Col", testMatrix[0], testMatrix[1])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType); + testCase = testCase.replaceAll("", scalarType); + testCase = testCase.replaceAll("", GenVectorCode.getCamelCaseType(scalarType)); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", operatorSymbol); + + if(op1IsCol){ + testCase = testCase.replaceAll("","inputColumnVector.vector[i]"); + testCase = testCase.replaceAll("","scalarValue"); + }else{ + testCase = testCase.replaceAll("","scalarValue"); + testCase = testCase.replaceAll("","inputColumnVector.vector[i]"); + } + + testsuites.get(template).append(testCase); + } + } + + public void addColumnColumnOperationTestCases(String vectorExpClassName, + String inputColumnVectorType1, String inputColumnVectorType2, String outputColumnVectorType) + throws IOException { + + TestSuiteClassName template= + TestSuiteClassName.TestColumnColumnOperationVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = GenVectorCode.joinPath(this.testTemplateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(GenVectorCode.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: InitOuputColHasNulls, InitOuputColIsRepeating, Column1HasNulls, + // Column1IsRepeating, Column2HasNulls, Column2IsRepeating + {true, true, false, true, true, true}, + {false, false, true, false, false, false}, + {true, false, true, false, true, true}, + {true, true, true, true, false, false}, + {false, false, false, true, true, false}, + {false, true, false, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Out", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("C1", testMatrix[2], testMatrix[3]) + + createNullRepeatingNameFragment("C2", testMatrix[4], testMatrix[5])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType1); + testCase = testCase.replaceAll("", inputColumnVectorType2); + testCase = testCase.replaceAll("", outputColumnVectorType); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + testCase = testCase.replaceAll("", testMatrix[4].toString()); + testCase = testCase.replaceAll("", testMatrix[5].toString()); + + testsuites.get(template).append(testCase); + } + } + + public void addColumnColumnFilterTestCases(String vectorExpClassName, + String inputColumnVectorType1, String inputColumnVectorType2, String operatorSymbol) + throws IOException { + + TestSuiteClassName template= + TestSuiteClassName.TestColumnColumnFilterVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = GenVectorCode.joinPath(this.testTemplateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(GenVectorCode.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: Column1HasNulls, Column1IsRepeating, Column2HasNulls, Column2IsRepeating + {false, true, true, true}, + {false, false, false, false}, + {true, false, true, false}, + {true, true, false, false}, + {true, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("C1", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("C2", testMatrix[2], testMatrix[3])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType1); + testCase = testCase.replaceAll("", inputColumnVectorType2); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + testCase = testCase.replaceAll("", operatorSymbol); + + testsuites.get(template).append(testCase); + } + } + + public void generateTestSuites() throws IOException { + + String templateFile = GenVectorCode.joinPath(this.testTemplateDirectory, "TestClass.txt"); + for(TestSuiteClassName testClass : testsuites.keySet()) { + + String templateString = GenVectorCode.readFile(templateFile); + templateString = templateString.replaceAll("", testClass.toString()); + templateString = templateString.replaceAll("", testsuites.get(testClass).toString()); + + String outputFile = GenVectorCode.joinPath(this.testOutputDir, testClass + ".java"); + + GenVectorCode.writeFile(outputFile, templateString); + } + } + + private static String createNullRepeatingNameFragment(String idenitfier, boolean nulls, boolean repeating) + { + if(nulls || repeating){ + if(nulls){ + idenitfier+="Nulls"; + } + if(repeating){ + idenitfier+="Repeats"; + } + return idenitfier; + } + + return ""; + } + + private static String removeTemplateComments(String templateString){ + return templateString.replaceAll("(?s)", ""); + } +} diff --git build-common.xml build-common.xml index 5a16bff..988df26 100644 --- build-common.xml +++ build-common.xml @@ -481,7 +481,7 @@ + excludes="**/ql/exec/vector/util/*.class,**/ql/exec/vector/udf/legacy/*.class,**/ql/exec/vector/udf/generic/*.class,**/TestSerDe.class,**/TestHiveMetaStore.class,**/TestBeeLineDriver.class,**/TestHiveServer2Concurrency.class,**/*$*.class,${test.junit.exclude}" /> diff --git build.xml build.xml index cf75b3d..cf03804 100644 --- build.xml +++ build.xml @@ -263,6 +263,12 @@ + + + + + + @@ -283,8 +289,13 @@ + + + + @@ -741,6 +752,7 @@ + diff --git common/src/java/org/apache/hadoop/hive/conf/HiveConf.java common/src/java/org/apache/hadoop/hive/conf/HiveConf.java index e971644..f27d1d4 100644 --- common/src/java/org/apache/hadoop/hive/conf/HiveConf.java +++ common/src/java/org/apache/hadoop/hive/conf/HiveConf.java @@ -802,6 +802,9 @@ // Whether to show the unquoted partition names in query results. HIVE_DECODE_PARTITION_NAME("hive.decode.partition.name", false), + + //Vectorization enabled + HIVE_VECTORIZATION_ENABLED("hive.vectorized.execution.enabled", false), ; public final String varname; diff --git conf/hive-default.xml.template conf/hive-default.xml.template index 1ee756c..c2b158c 100644 --- conf/hive-default.xml.template +++ conf/hive-default.xml.template @@ -1980,6 +1980,15 @@ + hive.vectorized.execution.enabled + false + + This flag should be set to true to enable vectorized mode of query execution. + The default value is false. + + + + hive.metastore.schema.verification false @@ -1991,5 +2000,4 @@ - diff --git data/files/alltypesorc data/files/alltypesorc new file mode 100644 index 0000000000000000000000000000000000000000..95c68cabd15e0ce34d472d552f4bb60193614b6d GIT binary patch literal 377237 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

b9O{w&^2BYT~@HLwFDdoJ) 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⩔Df?{gZwi2L_ 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

n9@$s5b4$R|Pw9@R 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ℜ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 D00_eh literal 0 HcmV?d00001 diff --git ql/build.xml ql/build.xml index ac2b7b0..be8e10f 100644 --- ql/build.xml +++ ql/build.xml @@ -190,7 +190,7 @@ extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum1; + private int colNum2; + private int outputColumn; + + public (int colNum1, int colNum2, int outputColumn) { + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector1 = () batch.cols[colNum1]; + inputColVector2 = () batch.cols[colNum2]; + outputColVector = () batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + [] vector1 = inputColVector1.vector; + [] vector2 = inputColVector2.vector; + [] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + outputColVector.isRepeating = + inputColVector1.isRepeating && inputColVector2.isRepeating + || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0] + || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0]; + + // Handle nulls first + NullUtil.propagateNullsColCol( + inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse); + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputVector[0] = vector1[0] vector2[0]; + } else if (inputColVector1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] vector2[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[0] vector2[i]; + } + } + } else if (inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] vector2[0]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[i] vector2[0]; + } + } + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] vector2[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[i] vector2[i]; + } + } + } + + /* For the case when the output can have null values, follow + * the convention that the data values must be 1 for long and + * NaN for double. This is to prevent possible later zero-divide errors + * in complex arithmetic expressions like col2 / (col1 - 1) + * in the case when some col1 entries are null. + */ + NullUtil.setNullDataEntries(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return ""; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalar.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalar.txt new file mode 100644 index 0000000..35890f8 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalar.txt @@ -0,0 +1,134 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil; + +/** + * Generated from template ColumnArithmeticScalar.txt, which covers binary arithmetic + * expressions between a column and a scalar. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private value; + private int outputColumn; + + public (int colNum, value, int outputColumn) { + this.colNum = colNum; + this.value = value; + this.outputColumn = outputColumn; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + outputColVector = () batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector.noNulls; + outputColVector.isRepeating = inputColVector.isRepeating; + int n = batch.size; + [] vector = inputColVector.vector; + [] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.isRepeating) { + outputVector[0] = vector[0] value; + + // Even if there are no nulls, we always copy over entry 0. Simplifies code. + outputIsNull[0] = inputIsNull[0]; + } else if (inputColVector.noNulls) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector[i] value; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector[i] value; + } + } + } else /* there are nulls */ { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector[i] value; + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector[i] value; + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + } + + NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return ""; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public getValue() { + return value; + } + + public void setValue( value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt new file mode 100644 index 0000000..e333224 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt @@ -0,0 +1,149 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Generated from template ColumnCompareScalar.txt, which covers binary comparison + * expressions between a column and a scalar. The boolean output is stored in a + * separate boolean column. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private value; + private int outputColumn; + + public (int colNum, value, int outputColumn) { + this.colNum = colNum; + this.value = value; + this.outputColumn = outputColumn; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + outputColVector = () batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + boolean[] outNulls = outputColVector.isNull; + int n = batch.size; + [] vector = inputColVector.vector; + [] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + outputColVector.isRepeating = false; + outputColVector.noNulls = inputColVector.noNulls; + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + outputVector[0] = vector[0] value ? 1 : 0; + outputColVector.isRepeating = true; + } else if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector[i] value ? 1 : 0; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector[i] value ? 1 : 0; + } + } + } else { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!nullPos[0]) { + outputVector[0] = vector[0] value ? 1 : 0; + outNulls[0] = false; + } else { + outNulls[0] = true; + } + outputColVector.isRepeating = true; + } else if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + outputVector[i] = vector[i] value ? 1 : 0; + outNulls[i] = false; + } else { + //comparison with null is null + outNulls[i] = true; + } + } + } else { + System.arraycopy(nullPos, 0, outNulls, 0, n); + for(int i = 0; i != n; i++) { + if (!nullPos[i]) { + outputVector[i] = vector[i] value ? 1 : 0; + } + } + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return ""; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public getValue() { + return value; + } + + public void setValue( value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnUnaryMinus.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnUnaryMinus.txt new file mode 100644 index 0000000..085145a --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/ColumnUnaryMinus.txt @@ -0,0 +1,122 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Generated from template ColumnUnaryMinus.txt, which covers unary negation operator. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private int outputColumn; + + public (int colNum, int outputColumn) { + this.colNum = colNum; + this.outputColumn = outputColumn; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + this.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + outputColVector = () batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector.noNulls; + int n = batch.size; + [] vector = inputColVector.vector; + [] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + outputVector[0] = - vector[0]; + // Even if there are no nulls, we always copy over entry 0. Simplifies code. + outputIsNull[0] = inputIsNull[0]; + outputColVector.isRepeating = true; + } else if (inputColVector.noNulls) { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + outputVector[i] = -vector[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = -vector[i]; + } + } + outputColVector.isRepeating = false; + } else /* there are nulls */ { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + outputVector[i] = -vector[i]; + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = -vector[i]; + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + outputColVector.isRepeating = false; + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return ""; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt new file mode 100644 index 0000000..1c16816 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt @@ -0,0 +1,254 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Generated from template FilterColumnCompareColumn.txt, which covers binary comparison + * expressions between two columns, however output is not produced in a separate column. + * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum1; + private int colNum2; + + public (int colNum1, int colNum2) { + this.colNum1 = colNum1; + this.colNum2 = colNum2; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector1 = () batch.cols[colNum1]; + inputColVector2 = () batch.cols[colNum2]; + int[] sel = batch.selected; + boolean[] nullPos1 = inputColVector1.isNull; + boolean[] nullPos2 = inputColVector2.isNull; + int n = batch.size; + [] vector1 = inputColVector1.vector; + [] vector2 = inputColVector2.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector1.noNulls && inputColVector2.noNulls) { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!(vector1[0] vector2[0])) { + batch.size = 0; + } + } else if (inputColVector1.isRepeating) { + if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (vector1[0] vector2[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (vector1[0] vector2[i]) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector2.isRepeating) { + if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (vector1[i] vector2[0]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (vector1[i] vector2[0]) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (vector1[i] vector2[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (vector1[i] vector2[i]) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (nullPos1[0] || nullPos2[0]) { + batch.size = 0; + } + } else if (inputColVector1.isRepeating) { + if (nullPos1[0]) { + batch.size = 0; + } else { + if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos2[i]) { + if (vector1[0] vector2[i]) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos2[i]) { + if (vector1[0] vector2[i]) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } else if (inputColVector2.isRepeating) { + if (nullPos2[0]) { + batch.size = 0; + } else { + if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i]) { + if (vector1[i] vector2[0]) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos1[i]) { + if (vector1[i] vector2[0]) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i] && !nullPos2[i]) { + if (vector1[i] vector2[i]) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos1[i] && !nullPos2[i]) { + if (vector1[i] vector2[i]) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + + @Override + public String getOutputType() { + return "boolean"; + } + + @Override + public int getOutputColumn() { + return -1; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt new file mode 100644 index 0000000..bf02419 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt @@ -0,0 +1,158 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Generated from template FilterColumnCompareScalar.txt, which covers binary comparison + * expressions between a column and a scalar, however output is not produced in a separate column. + * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private value; + + public (int colNum, value) { + this.colNum = colNum; + this.value = value; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + [] vector = inputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!(vector[0] value)) { + //Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (vector[i] value) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (vector[i] value) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!nullPos[0]) { + if (!(vector[0] value)) { + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (vector[i] value) { + sel[newSize++] = i; + } + } + } + //Change the selected vector + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (vector[i] value) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public getValue() { + return value; + } + + public void setValue( value) { + this.value = value; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt new file mode 100644 index 0000000..9a1d741 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt @@ -0,0 +1,158 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Generated from template FilterScalarCompareColumn.txt, which covers binary comparison + * expressions between a scalar and a column, however output is not produced in a separate column. + * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private value; + + public (int colNum, value) { + this.colNum = colNum; + this.value = value; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + [] vector = inputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!(value vector[0])) { + //Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (value vector[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (value vector[i]) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!nullPos[0]) { + if (!(value vector[0])) { + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (value vector[i]) { + sel[newSize++] = i; + } + } + } + //Change the selected vector + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (value vector[i]) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public getValue() { + return value; + } + + public void setValue( value) { + this.value = value; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareColumn.txt new file mode 100644 index 0000000..449c010 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareColumn.txt @@ -0,0 +1,477 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Filter the rows in a batch by comparing one string column to another. + * This code is generated from a template. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum1; + private int colNum2; + + public (int colNum1, int colNum2) { + this.colNum1 = colNum1; + this.colNum2 = colNum2; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inputColVector1 = (BytesColumnVector) batch.cols[colNum1]; + BytesColumnVector inputColVector2 = (BytesColumnVector) batch.cols[colNum2]; + int[] sel = batch.selected; + boolean[] nullPos1 = inputColVector1.isNull; + boolean[] nullPos2 = inputColVector2.isNull; + int n = batch.size; + byte[][] vector1 = inputColVector1.vector; + byte[][] vector2 = inputColVector2.vector; + int[] start1 = inputColVector1.start; + int[] start2 = inputColVector2.start; + int[] length1 = inputColVector1.length; + int[] length2 = inputColVector2.length; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + // handle case where neither input has nulls + if (inputColVector1.noNulls && inputColVector2.noNulls) { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + + /* Either all must remain selected or all will be eliminated. + * Repeating property will not change. + */ + if (!(StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[0], start2[0], length2[0]) 0)) { + batch.size = 0; + } + } else if (inputColVector1.isRepeating) { + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector2.isRepeating) { + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + + // handle case where only input 2 has nulls + } else if (inputColVector1.noNulls) { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (nullPos2[0] || + !(StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[0], start2[0], length2[0]) 0)) { + batch.size = 0; + } + } else if (inputColVector1.isRepeating) { + + // no need to check for nulls in input 1 + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector2.isRepeating) { + if (nullPos2[0]) { + + // no values will qualify because every comparison will be with NULL + batch.size = 0; + return; + } + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { // neither input is repeating + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + + // handle case where only input 1 has nulls + } else if (inputColVector2.noNulls) { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (nullPos1[0] || + !(StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[0], start2[0], length2[0]) 0)) { + batch.size = 0; + return; + } + } else if (inputColVector1.isRepeating) { + if (nullPos1[0]) { + + // if repeating value is null then every comparison will fail so nothing qualifies + batch.size = 0; + return; + } + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector2.isRepeating) { + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { // neither input is repeating + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos1[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + + // handle case where both inputs have nulls + } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (nullPos1[0] || nullPos2[0] || + !(StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[0], start2[0], length2[0]) 0)) { + batch.size = 0; + } + } else if (inputColVector1.isRepeating) { + if (nullPos1[0]) { + batch.size = 0; + return; + } + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos2[i]) { + if (StringExpr.compare(vector1[0], start1[0], length1[0], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else if (inputColVector2.isRepeating) { + if (nullPos2[0]) { + batch.size = 0; + return; + } + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos1[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[0], start2[0], length2[0]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { // neither input is repeating + if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos1[i] && !nullPos2[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos1[i] && !nullPos2[i]) { + if (StringExpr.compare(vector1[i], start1[i], length1[i], + vector2[i], start2[i], length2[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < batch.size) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + } + + @Override + public String getOutputType() { + return "boolean"; + } + + @Override + public int getOutputColumn() { + return -1; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareScalar.txt ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareScalar.txt new file mode 100644 index 0000000..690dd3c --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnCompareScalar.txt @@ -0,0 +1,161 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This is a generated class to evaluate a comparison on a vector of strings. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private byte[] value; + + public (int colNum, byte[] value) { + this.colNum = colNum; + this.value = value; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int[] length = inputColVector.length; + int[] start = inputColVector.start; + + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!(StringExpr.compare(vector[0], start[0], length[0], value, 0, value.length) 0)) { + + //Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(vector[i], start[i], length[i], value, 0, value.length) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(vector[i], start[i], length[i], value, 0, value.length) 0) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!nullPos[0]) { + if (!(StringExpr.compare(vector[0], start[0], length[0], value, 0, value.length) 0)) { + + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (StringExpr.compare(vector[i], start[i], length[i], value, 0, value.length) 0) { + sel[newSize++] = i; + } + } + } + + //Change the selected vector + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (StringExpr.compare(vector[i], start[i], length[i], value, 0, value.length) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public byte[] getValue() { + return value; + } + + public void setValue(byte[] value) { + this.value = value; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterStringScalarCompareColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterStringScalarCompareColumn.txt new file mode 100644 index 0000000..5ba7703 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/FilterStringScalarCompareColumn.txt @@ -0,0 +1,162 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This is a generated class to evaluate a comparison on a vector of strings. + * Do not edit the generated code directly. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private byte[] value; + + public (int colNum, byte[] value) { + this.colNum = colNum; + this.value = value; + } + + public () { + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int[] length = inputColVector.length; + int[] start = inputColVector.start; + + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!(StringExpr.compare(value, 0, value.length, vector[0], start[0], length[0]) 0)) { + + //Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (StringExpr.compare(value, 0, value.length, vector[i], start[i], length[i]) 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (StringExpr.compare(value, 0, value.length, vector[i], start[i], length[i]) 0) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!nullPos[0]) { + if (!(StringExpr.compare(value, 0, value.length, vector[0], start[0], length[0]) 0)) { + + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (StringExpr.compare(value, 0, value.length, vector[i], start[i], length[i]) 0) { + sel[newSize++] = i; + } + } + } + + //Change the selected vector + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (StringExpr.compare(value, 0, value.length, vector[i], start[i], length[i]) 0) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public byte[] getValue() { + return value; + } + + public void setValue(byte[] value) { + this.value = value; + } +} diff --git ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumn.txt ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumn.txt new file mode 100644 index 0000000..d9efbe7 --- /dev/null +++ ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumn.txt @@ -0,0 +1,147 @@ +/** + * 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.exec.vector.expressions.gen; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; + +/* + * Because of the templatized nature of the code, either or both + * of these ColumnVector imports may be needed. Listing both of them + * rather than using ....vectorization.*; + */ +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil; + +/** + * Generated from template ScalarArithmeticColumn.txt. + * Implements a vectorized arithmetic operator with a scalar on the left and a + * column vector on the right. The result is output to an output column vector. + */ +public class extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private value; + private int outputColumn; + + public ( value, int colNum, int outputColumn) { + this.colNum = colNum; + this.value = value; + this.outputColumn = outputColumn; + } + + public () { + } + + @Override + /** + * Method to evaluate scalar-column operation in vectorized fashion. + * + * @batch a package of rows with each column stored in a vector + */ + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + inputColVector = () batch.cols[colNum]; + outputColVector = () batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector.noNulls; + outputColVector.isRepeating = inputColVector.isRepeating; + int n = batch.size; + [] vector = inputColVector.vector; + [] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.isRepeating) { + outputVector[0] = value vector[0]; + + // Even if there are no nulls, we always copy over entry 0. Simplifies code. + outputIsNull[0] = inputIsNull[0]; + } else if (inputColVector.noNulls) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = value vector[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = value vector[i]; + } + } + } else { /* there are nulls */ + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = value vector[i]; + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = value vector[i]; + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + } + + NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return ""; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public getValue() { + return value; + } + + public void setValue( value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } + +} diff --git ql/src/gen/vectorization/TestTemplates/TestClass.txt ql/src/gen/vectorization/TestTemplates/TestClass.txt new file mode 100644 index 0000000..c8de5de --- /dev/null +++ ql/src/gen/vectorization/TestTemplates/TestClass.txt @@ -0,0 +1,44 @@ +/** + * 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.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * . + * + */ +public class { + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + +} + + diff --git ql/src/gen/vectorization/TestTemplates/TestColumnColumnFilterVectorExpressionEvaluation.txt ql/src/gen/vectorization/TestTemplates/TestColumnColumnFilterVectorExpressionEvaluation.txt new file mode 100644 index 0000000..2bb1aa3 --- /dev/null +++ ql/src/gen/vectorization/TestTemplates/TestColumnColumnFilterVectorExpressionEvaluation.txt @@ -0,0 +1,69 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + inputColumnVector1 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector2 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + vectorExpression = + new (0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "" + + inputColumnVector2.vector[i] + " is not in rowBatch selected index", + i, + rowBatch.selected[selectedIndex]); + selectedIndex++; + } + } + } + + assertEquals("Row batch size not set to number of selected rows: " + selectedIndex, + selectedIndex, rowBatch.size); + + if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) { + assertEquals( + "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: " + + selectedIndex, + true, rowBatch.selectedInUse); + } else if(selectedIndex == BATCH_SIZE) { + assertEquals( + "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: " + + selectedIndex, + false, rowBatch.selectedInUse); + } + } \ No newline at end of file diff --git ql/src/gen/vectorization/TestTemplates/TestColumnColumnOperationVectorExpressionEvaluation.txt ql/src/gen/vectorization/TestTemplates/TestColumnColumnOperationVectorExpressionEvaluation.txt new file mode 100644 index 0000000..4ab3e76 --- /dev/null +++ ql/src/gen/vectorization/TestTemplates/TestColumnColumnOperationVectorExpressionEvaluation.txt @@ -0,0 +1,64 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + outputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector1 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector2 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + vectorExpression = + new (0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + (!inputColumnVector1.noNulls && inputColumnVector1.isRepeating) + || (!inputColumnVector2.noNulls && inputColumnVector2.isRepeating) + || inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + //if repeating, only the first value matters + if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } \ No newline at end of file diff --git ql/src/gen/vectorization/TestTemplates/TestColumnScalarFilterVectorExpressionEvaluation.txt ql/src/gen/vectorization/TestTemplates/TestColumnScalarFilterVectorExpressionEvaluation.txt new file mode 100644 index 0000000..af30490 --- /dev/null +++ ql/src/gen/vectorization/TestTemplates/TestColumnScalarFilterVectorExpressionEvaluation.txt @@ -0,0 +1,78 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + inputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + + scalarValue = 0; + do { + scalarValue = rand.next(); + } while(scalarValue == 0); + + vectorExpression = + new (0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + + int selectedIndex = 0; + int i=0; + //check for isRepeating optimization + if(inputColumnVector.isRepeating) { + //null vector is safe to check, as it is always initialized to match the data vector + selectedIndex = + !inputColumnVector.isNull[i] && + ? BATCH_SIZE : 0; + } else { + for(i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if( ) { + assertEquals( + "Vector index that passes filter " + + + "" + + + " is not in rowBatch selected index", + i, + rowBatch.selected[selectedIndex]); + selectedIndex++; + } + } + } + } + + assertEquals("Row batch size not set to number of selected rows: " + selectedIndex, + selectedIndex, rowBatch.size); + + if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) { + assertEquals( + "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: " + + selectedIndex, + true, rowBatch.selectedInUse); + } else if(selectedIndex == BATCH_SIZE) { + assertEquals( + "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: " + + selectedIndex, + false, rowBatch.selectedInUse); + } + } \ No newline at end of file diff --git ql/src/gen/vectorization/TestTemplates/TestColumnScalarOperationVectorExpressionEvaluation.txt ql/src/gen/vectorization/TestTemplates/TestColumnScalarOperationVectorExpressionEvaluation.txt new file mode 100644 index 0000000..e5f3f18 --- /dev/null +++ ql/src/gen/vectorization/TestTemplates/TestColumnScalarOperationVectorExpressionEvaluation.txt @@ -0,0 +1,59 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + outputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + scalarValue = 0; + do { + scalarValue = rand.next(); + } while(scalarValue == 0); + + vectorExpression = + new (, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } \ No newline at end of file diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt new file mode 100644 index 0000000..cb94145 --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt @@ -0,0 +1,474 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; + +/** + * Generated from template VectorUDAFAvg.txt. + */ +@Description(name = "avg", + value = "_FUNC_(expr) - Returns the average value of expr (vectorized, type: )") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** class for storing the current aggregate value. */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private double sum; + transient private long count; + transient private boolean isNull; + + public void sumValue( value) { + if (isNull) { + sum = value; + count = 1; + isNull = false; + } else { + sum += value; + count++; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + private VectorExpression inputExpression; + transient private Object[] partialResult; + transient private LongWritable resultCount; + transient private DoubleWritable resultSum; + transient private StructObjectInspector soi; + + public (VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public () { + super(); + partialResult = new Object[2]; + resultCount = new LongWritable(); + resultSum = new DoubleWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; + initPartialResultInspector(); + } + + private void initPartialResultInspector() { + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + inputVector = ( )batch. + cols[this.inputExpression.getOutputColumn()]; + [] vector = inputVector.vector; + + if (inputVector.noNulls) { + if (inputVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize); + } + } + } else { + if (inputVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize, inputVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize, inputVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + value, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + [] values, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(values[selection[i]]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + [] values, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(values[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + value, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[selection[i]]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + value, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + [] values, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + j); + myagg.sumValue(values[i]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + [] values, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(values[i]); + } + } + } + + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + inputVector = + ()batch.cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + myagg.sum += vector[0]*batchSize; + myagg.count += batchSize; + } + return; + } + + if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + value = vector[i]; + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + myagg.sum += value; + myagg.count += 1; + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + + for (int i=0; i< batchSize; ++i) { + value = vector[selected[i]]; + myagg.sum += value; + myagg.count += 1; + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i value = vector[i]; + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + myagg.sum += value; + myagg.count += 1; + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + + for (int i=0;i value = vector[i]; + myagg.sum += value; + myagg.count += 1; + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput( + AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + assert(0 < myagg.count); + resultCount.set (myagg.count); + resultSum.set (myagg.sum); + return partialResult; + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return soi; + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.primitive2() * 2, + model.memoryAlign()); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + // No-op + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMax.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMax.txt new file mode 100644 index 0000000..2b0364c --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMax.txt @@ -0,0 +1,441 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriterFactory; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; + +/** +* . Vectorized implementation for MIN/MAX aggregates. +*/ +@Description(name = "", + value = "") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + * class for storing the current aggregate value. + */ + static private final class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private value; + transient private boolean isNull; + + public void checkValue( value) { + if (isNull) { + isNull = false; + this.value = value; + } else if (value this.value) { + this.value = value; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + private VectorExpression inputExpression; + private transient VectorExpressionWriter resultWriter; + + public (VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public () { + super(); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + resultWriter = VectorExpressionWriterFactory.genVectorExpressionWritable( + desc.getParameters().get(0)); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregrateIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + [] vector = inputVector.vector; + + if (inputVector.noNulls) { + if (inputVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector, batchSize); + } + } + } else { + if (inputVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector[0], batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector[0], batchSize, inputVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector, batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + vector, batchSize, inputVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + value, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(value); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + [] values, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(values[selection[i]]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + [] values, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(values[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + value, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[selection[i]]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(value); + } + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + value, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(value); + } + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + [] values, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + j); + myagg.checkValue(values[i]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + [] values, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(values[i]); + } + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls && + (myagg.isNull || (vector[0] myagg.value))) { + myagg.isNull = false; + myagg.value = vector[0]; + } + return; + } + + if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + value = vector[i]; + if (myagg.isNull) { + myagg.isNull = false; + myagg.value = value; + } + else if (value myagg.value) { + myagg.value = value; + } + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.value = vector[selected[0]]; + myagg.isNull = false; + } + + for (int i=0; i< batchSize; ++i) { + value = vector[selected[i]]; + if (value myagg.value) { + myagg.value = value; + } + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i value = vector[i]; + if (myagg.isNull) { + myagg.value = value; + myagg.isNull = false; + } + else if (value myagg.value) { + myagg.value = value; + } + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize) { + if (myagg.isNull) { + myagg.value = vector[0]; + myagg.isNull = false; + } + + for (int i=0;i value = vector[i]; + if (value myagg.value) { + myagg.value = value; + } + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput( + AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + return resultWriter.writeValue(myagg.value); + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return resultWriter.getObjectInspector(); + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.primitive2(), + model.memoryAlign()); + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt new file mode 100644 index 0000000..36f483e --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt @@ -0,0 +1,400 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import java.util.ArrayList; +import java.util.Arrays; +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.Text; + +/** +* . Vectorized implementation for MIN/MAX aggregates. +*/ +@Description(name = "", + value = "") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + * class for storing the current aggregate value. + */ + static private final class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private final static int MIN_BUFFER_SIZE = 16; + transient private byte[] bytes = new byte[MIN_BUFFER_SIZE]; + transient private int length; + transient private boolean isNull; + + public void checkValue(byte[] bytes, int start, int length) { + if (isNull) { + isNull = false; + assign(bytes, start, length); + } else if (StringExpr.compare( + bytes, start, length, + this.bytes, 0, this.length) 0) { + assign(bytes, start, length); + } + } + + public void assign(byte[] bytes, int start, int length) { + // Avoid new allocation if possible + if (this.bytes.length < length) { + this.bytes = new byte[length]; + } + System.arraycopy(bytes, start, this.bytes, 0, length); + this.length = length; + } + @Override + public int getVariableSize() { + JavaDataModel model = JavaDataModel.get(); + return model.lengthForByteArrayOfSize(bytes.length); + } + } + + private VectorExpression inputExpression; + transient private Text result; + + public (VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public () { + super(); + result = new Text(); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregrateIndex); + return myagg; + } + +@Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + BytesColumnVector inputColumn = (BytesColumnVector)batch. + cols[this.inputExpression.getOutputColumn()]; + + if (inputColumn.noNulls) { + if (inputColumn.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + inputColumn, batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + inputColumn, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + inputColumn, batchSize); + } + } + } else { + if (inputColumn.isRepeating) { + // All nulls, no-op for min/max + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + inputColumn, batchSize, batch.selected); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, aggregrateIndex, + inputColumn, batchSize); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + BytesColumnVector inputColumn, + int batchSize) { + + byte[] bytes = inputColumn.vector[0]; + int start = inputColumn.start[0]; + int length = inputColumn.length[0]; + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(bytes, start, length); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + BytesColumnVector inputColumn, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + int row = selection[i]; + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(inputColumn.vector[row], + inputColumn.start[row], + inputColumn.length[row]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + BytesColumnVector inputColumn, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + BytesColumnVector inputColumn, + int batchSize, + int[] selection) { + + for (int i=0; i < batchSize; ++i) { + int row = selection[i]; + if (!inputColumn.isNull[row]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(inputColumn.vector[row], + inputColumn.start[row], + inputColumn.length[row]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregrateIndex, + BytesColumnVector inputColumn, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + if (!inputColumn.isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregrateIndex, + i); + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + BytesColumnVector inputColumn = (BytesColumnVector)batch. + cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + if (inputColumn.isRepeating) { + if (inputColumn.noNulls) { + myagg.checkValue(inputColumn.vector[0], + inputColumn.start[0], + inputColumn.length[0]); + } + return; + } + + if (!batch.selectedInUse && inputColumn.noNulls) { + iterateNoSelectionNoNulls(myagg, inputColumn, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, inputColumn, batchSize); + } + else if (inputColumn.noNulls){ + iterateSelectionNoNulls(myagg, inputColumn, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, inputColumn, batchSize, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + BytesColumnVector inputColumn, + int batchSize, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!inputColumn.isNull[i]) { + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + BytesColumnVector inputColumn, + int batchSize, + int[] selected) { + + for (int i=0; i< batchSize; ++i) { + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + BytesColumnVector inputColumn, + int batchSize) { + + for (int i=0; i< batchSize; ++i) { + if (!inputColumn.isNull[i]) { + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + BytesColumnVector inputColumn, + int batchSize) { + for (int i=0; i< batchSize; ++i) { + myagg.checkValue(inputColumn.vector[i], + inputColumn.start[i], + inputColumn.length[i]); + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput( + AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + result.set(myagg.bytes, 0, myagg.length); + return result; + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return PrimitiveObjectInspectorFactory.writableStringObjectInspector; + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.ref()+ + model.primitive1()*2, + model.memoryAlign()); + } + + @Override + public boolean hasVariableSize() { + return true; + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + // No-op + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt new file mode 100644 index 0000000..3573997 --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt @@ -0,0 +1,436 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; + +/** +* . Vectorized implementation for SUM aggregates. +*/ +@Description(name = "sum", + value = "_FUNC_(expr) - Returns the sum value of expr (vectorized, type: )") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + * class for storing the current aggregate value. + */ + private static final class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private sum; + transient private boolean isNull; + + public void sumValue( value) { + if (isNull) { + sum = value; + isNull = false; + } else { + sum += value; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + private VectorExpression inputExpression; + transient private final result; + + public (VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public () { + super(); + result = new (); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregateIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + [] vector = inputVector.vector; + + if (inputVector.noNulls) { + if (inputVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector, batchSize); + } + } + } else { + if (inputVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector[0], batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector[0], batchSize, inputVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector, batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + vector, batchSize, inputVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + value, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(value); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] values, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(values[selection[i]]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] values, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(values[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + value, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[selection[i]]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(value); + } + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + value, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(value); + } + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] values, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + j); + myagg.sumValue(values[i]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] values, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.sumValue(values[i]); + } + } + } + + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + } + myagg.sum += vector[0]*batchSize; + } + return; + } + + if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + value = vector[i]; + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + } + myagg.sum += value; + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.sum = 0; + myagg.isNull = false; + } + + for (int i=0; i< batchSize; ++i) { + value = vector[selected[i]]; + myagg.sum += value; + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i value = vector[i]; + if (myagg.isNull) { + myagg.sum = 0; + myagg.isNull = false; + } + myagg.sum += value; + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize) { + if (myagg.isNull) { + myagg.sum = 0; + myagg.isNull = false; + } + + for (int i=0;i value = vector[i]; + myagg.sum += value; + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput(AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + result.set(myagg.sum); + return result; + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return ; + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object(), + model.memoryAlign()); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + // No-op + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt new file mode 100644 index 0000000..7c0e58f --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt @@ -0,0 +1,520 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; + +/** +* . Vectorized implementation for VARIANCE aggregates. +*/ +@Description(name = "", + value = "") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + /* class for storing the current aggregate value. + */ + private static final class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private double sum; + transient private long count; + transient private double variance; + transient private boolean isNull; + + public void init() { + isNull = false; + sum = 0; + count = 0; + variance = 0; + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + private VectorExpression inputExpression; + transient private LongWritable resultCount; + transient private DoubleWritable resultSum; + transient private DoubleWritable resultVariance; + transient private Object[] partialResult; + + transient private ObjectInspector soi; + + + public (VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public () { + super(); + partialResult = new Object[3]; + resultCount = new LongWritable(); + resultSum = new DoubleWritable(); + resultVariance = new DoubleWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; + partialResult[2] = resultVariance; + initPartialResultInspector(); + } + + private void initPartialResultInspector() { + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); + + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + fname.add("variance"); + + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregateIndex); + return myagg; + } + + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + VectorizedRowBatch batch) throws HiveException { + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls || !inputVector.isNull[0]) { + iterateRepeatingNoNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, vector[0], batchSize); + } + } + else if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, vector, batchSize, + inputVector.isNull, batch.selected); + } + + } + + private void iterateRepeatingNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + double value, + int batchSize) { + + for (int i=0; i 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + + private void iterateSelectionHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + j); + int i = selected[j]; + if (!isNull[i]) { + double value = vector[i]; + if (myagg.isNull) { + myagg.init (); + } + myagg.sum += value; + myagg.count += 1; + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + } + + private void iterateSelectionNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] vector, + int batchSize, + int[] selected) { + + for (int i=0; i< batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + double value = vector[selected[i]]; + if (myagg.isNull) { + myagg.init (); + } + myagg.sum += value; + myagg.count += 1; + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + + private void iterateNoSelectionHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + } + + private void iterateNoSelectionNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + [] vector, + int batchSize) { + + for (int i=0; i 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + inputVector = ()batch. + cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls) { + iterateRepeatingNoNulls(myagg, vector[0], batchSize); + } + } + else if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateRepeatingNoNulls( + Aggregation myagg, + double value, + int batchSize) { + + if (myagg.isNull) { + myagg.init (); + } + + // TODO: conjure a formula w/o iterating + // + + myagg.sum += value; + myagg.count += 1; + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + + // We pulled out i=0 so we can remove the count > 1 check in the loop + for (int i=1; i[] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + double value = vector[i]; + if (myagg.isNull) { + myagg.init (); + } + myagg.sum += value; + myagg.count += 1; + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.init (); + } + + double value = vector[selected[0]]; + myagg.sum += value; + myagg.count += 1; + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + + // i=0 was pulled out to remove the count > 1 check in the loop + // + for (int i=1; i< batchSize; ++i) { + value = vector[selected[i]]; + myagg.sum += value; + myagg.count += 1; + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + [] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + [] vector, + int batchSize) { + + if (myagg.isNull) { + myagg.init (); + } + + double value = vector[0]; + myagg.sum += value; + myagg.count += 1; + + if(myagg.count > 1) { + double t = myagg.count*value - myagg.sum; + myagg.variance += (t*t) / ((double)myagg.count*(myagg.count-1)); + } + + // i=0 was pulled out to remove count > 1 check + for (int i=1; i bucketMap = new HashMap(); + protected transient boolean multiFileSpray; + protected transient final Map bucketMap = new HashMap(); private transient ObjectInspector[] partitionObjectInspectors; - private transient HivePartitioner prtner; - private transient final HiveKey key = new HiveKey(); + protected transient HivePartitioner prtner; + protected transient final HiveKey key = new HiveKey(); private transient Configuration hconf; - private transient FSPaths fsp; - private transient boolean bDynParts; + protected transient FSPaths fsp; + protected transient boolean bDynParts; private transient SubStructObjectInspector subSetOI; private transient int timeOut; // JT timeout in msec. private transient long lastProgressReport = System.currentTimeMillis(); @@ -279,7 +283,7 @@ public void abortWriters(FileSystem fs, boolean abort, boolean delete) throws Hi Class outputClass; String taskId; - private boolean filesCreated = false; + protected boolean filesCreated = false; private void initializeSpecPath() { // For a query of the type: @@ -432,7 +436,7 @@ private void dpSetup() { } } - private void createBucketFiles(FSPaths fsp) throws HiveException { + protected void createBucketFiles(FSPaths fsp) throws HiveException { try { int filesIdx = 0; Set seenBuckets = new HashSet(); @@ -544,7 +548,7 @@ private void createBucketFiles(FSPaths fsp) throws HiveException { * * @return true if a new progress update is reported, false otherwise. */ - private boolean updateProgress() { + protected boolean updateProgress() { if (reporter != null && (System.currentTimeMillis() - lastProgressReport) > timeOut) { reporter.progress(); @@ -555,7 +559,7 @@ private boolean updateProgress() { } } - Writable recordValue; + protected Writable recordValue; @Override public void processOp(Object row, int tag) throws HiveException { @@ -661,7 +665,7 @@ public void processOp(Object row, int tag) throws HiveException { * @return * @throws HiveException */ - private FSPaths lookupListBucketingPaths(String lbDirName) throws HiveException { + protected FSPaths lookupListBucketingPaths(String lbDirName) throws HiveException { FSPaths fsp2 = valToPaths.get(lbDirName); if (fsp2 == null) { fsp2 = createNewPaths(lbDirName); @@ -699,7 +703,7 @@ private FSPaths createNewPaths(String dirName) throws HiveException { * @param row row to process. * @return directory name. */ - private String generateListBucketingDirName(Object row) { + protected String generateListBucketingDirName(Object row) { if (!this.isSkewedStoredAsSubDirectories) { return null; } @@ -740,7 +744,7 @@ private String generateListBucketingDirName(Object row) { return lbDirName; } - private FSPaths getDynOutPaths(List row, String lbDirName) throws HiveException { + protected FSPaths getDynOutPaths(List row, String lbDirName) throws HiveException { FSPaths fp; diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/FilterOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/FilterOperator.java index d2c981d..516ba42 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/FilterOperator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/FilterOperator.java @@ -46,13 +46,14 @@ FILTERED, PASSED } - private final transient LongWritable filtered_count, passed_count; + protected final transient LongWritable filtered_count; + protected final transient LongWritable passed_count; private transient ExprNodeEvaluator conditionEvaluator; private transient PrimitiveObjectInspector conditionInspector; private transient int consecutiveFails; private transient int consecutiveSearches; private transient IOContext ioContext; - transient int heartbeatInterval; + protected transient int heartbeatInterval; public FilterOperator() { super(); diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/GroupByOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/GroupByOperator.java index e498327..7d05982 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/GroupByOperator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/GroupByOperator.java @@ -141,8 +141,16 @@ transient StructObjectInspector newKeyObjectInspector; transient StructObjectInspector currentKeyObjectInspector; public static MemoryMXBean memoryMXBean; - private long maxMemory; - private float memoryThreshold; + + /** + * Total amount of memory allowed for JVM heap. + */ + protected long maxMemory; + + /** + * configure percent of memory threshold usable by QP. + */ + protected float memoryThreshold; private boolean groupingSetsPresent; private int groupingSetsPosition; @@ -159,10 +167,18 @@ transient List[] aggrPositions; transient int fixedRowSize; - transient long maxHashTblMemory; + + /** + * Max memory usable by the hashtable before it should flush. + */ + protected transient long maxHashTblMemory; transient int totalVariableSize; transient int numEntriesVarSize; - transient int numEntriesHashTable; + + /** + * Current number of entries in the hash table. + */ + protected transient int numEntriesHashTable; transient int countAfterReport; // report or forward transient int heartbeatInterval; diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/KeyWrapper.java ql/src/java/org/apache/hadoop/hive/ql/exec/KeyWrapper.java index c303b30..f14f1d9 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/KeyWrapper.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/KeyWrapper.java @@ -22,9 +22,9 @@ import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; public abstract class KeyWrapper { - abstract void getNewKey(Object row, ObjectInspector rowInspector) throws HiveException; - abstract void setHashKey(); - abstract KeyWrapper copyKey(); - abstract void copyKey(KeyWrapper oldWrapper); - abstract Object[] getKeyArray(); + public abstract void getNewKey(Object row, ObjectInspector rowInspector) throws HiveException; + public abstract void setHashKey(); + public abstract KeyWrapper copyKey(); + public abstract void copyKey(KeyWrapper oldWrapper); + public abstract Object[] getKeyArray(); } diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/Operator.java ql/src/java/org/apache/hadoop/hive/ql/exec/Operator.java index 3b15667..690f00a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/Operator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/Operator.java @@ -101,7 +101,7 @@ protected transient State state = State.UNINIT; - static transient boolean fatalError = false; // fatalError is shared acorss + protected static transient boolean fatalError = false; // fatalError is shared acorss // all operators static { @@ -1436,6 +1436,60 @@ public boolean supportSkewJoinOptimization() { return ret; } + /** + * Clones only the operator. The children and parent are set + * to null. + * @return Cloned operator + * @throws CloneNotSupportedException + */ + public Operator cloneOp() throws CloneNotSupportedException { + T descClone = (T) conf.clone(); + Operator ret = + (Operator) OperatorFactory.getAndMakeChild( + descClone, getSchema()); + return ret; + } + + /** + * Recursively clones all the children of the tree, + * Fixes the pointers to children, parents and the pointers to itself coming from the children. + * It does not fix the pointers to itself coming from parents, parents continue to point to + * the original child. + * @return Cloned operator + * @throws CloneNotSupportedException + */ + public Operator cloneRecursiveChildren() + throws CloneNotSupportedException { + Operator newOp = this.cloneOp(); + newOp.setParentOperators(this.parentOperators); + // Fix parent in all children + if (this.getChildOperators() == null) { + newOp.setChildOperators(null); + return newOp; + } + List> newChildren = + new ArrayList>(); + + for (Operator childOp : this.getChildOperators()) { + List> parentList = + new ArrayList>(); + for (Operator parent : childOp.getParentOperators()) { + if (parent.equals(this)) { + parentList.add(newOp); + } else { + parentList.add(parent); + } + } + // Recursively clone the children + Operator clonedChildOp = childOp.cloneRecursiveChildren(); + clonedChildOp.setParentOperators(parentList); + } + + newOp.setChildOperators(newChildren); + return newOp; + } + + /* * True only for operators which produce atmost 1 output row per input * row to it. This will allow the output column names to be directly diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/OperatorFactory.java ql/src/java/org/apache/hadoop/hive/ql/exec/OperatorFactory.java index 85a22b7..8ab5395 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/OperatorFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/OperatorFactory.java @@ -22,12 +22,17 @@ import java.util.List; import java.util.Map; +import org.apache.hadoop.hive.ql.exec.vector.VectorFileSinkOperator; +import org.apache.hadoop.hive.ql.exec.vector.VectorFilterOperator; +import org.apache.hadoop.hive.ql.exec.vector.VectorGroupByOperator; +import org.apache.hadoop.hive.ql.exec.vector.VectorReduceSinkOperator; +import org.apache.hadoop.hive.ql.exec.vector.VectorSelectOperator; +import org.apache.hadoop.hive.ql.exec.vector.VectorizationContext; import org.apache.hadoop.hive.ql.plan.CollectDesc; -import org.apache.hadoop.hive.ql.plan.MuxDesc; import org.apache.hadoop.hive.ql.plan.DemuxDesc; import org.apache.hadoop.hive.ql.plan.DummyStoreDesc; -import org.apache.hadoop.hive.ql.plan.ExtractDesc; import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExtractDesc; import org.apache.hadoop.hive.ql.plan.FileSinkDesc; import org.apache.hadoop.hive.ql.plan.FilterDesc; import org.apache.hadoop.hive.ql.plan.ForwardDesc; @@ -39,6 +44,7 @@ import org.apache.hadoop.hive.ql.plan.LateralViewJoinDesc; import org.apache.hadoop.hive.ql.plan.LimitDesc; import org.apache.hadoop.hive.ql.plan.MapJoinDesc; +import org.apache.hadoop.hive.ql.plan.MuxDesc; import org.apache.hadoop.hive.ql.plan.OperatorDesc; import org.apache.hadoop.hive.ql.plan.PTFDesc; import org.apache.hadoop.hive.ql.plan.ReduceSinkDesc; @@ -106,6 +112,38 @@ public OpTuple(Class descClass, Class> opClass) { MuxOperator.class)); } + public static ArrayList vectorOpvec; + static { + vectorOpvec = new ArrayList(); + vectorOpvec.add(new OpTuple(SelectDesc.class, VectorSelectOperator.class)); + vectorOpvec.add(new OpTuple(GroupByDesc.class, VectorGroupByOperator.class)); + vectorOpvec.add(new OpTuple(ReduceSinkDesc.class, + VectorReduceSinkOperator.class)); + vectorOpvec.add(new OpTuple(FileSinkDesc.class, VectorFileSinkOperator.class)); + vectorOpvec.add(new OpTuple(FilterDesc.class, VectorFilterOperator.class)); + } + + public static Operator getVectorOperator(T conf, + VectorizationContext vContext) { + Class descClass = (Class) conf.getClass(); + for (OpTuple o : vectorOpvec) { + if (o.descClass == descClass) { + try { + Operator op = (Operator) o.opClass.getDeclaredConstructor( + VectorizationContext.class, OperatorDesc.class).newInstance( + vContext, conf); + op.initializeCounters(); + return op; + } catch (Exception e) { + e.printStackTrace(); + throw new RuntimeException(e); + } + } + } + throw new RuntimeException("No vector operator for descriptor class " + + descClass.getName()); + } + public static Operator get(Class opClass) { for (OpTuple o : opvec) { diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/ReduceSinkOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/ReduceSinkOperator.java index 1f763a4..615c854 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/ReduceSinkOperator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/ReduceSinkOperator.java @@ -43,6 +43,7 @@ import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.UnionObjectInspector; import org.apache.hadoop.io.BytesWritable; +import org.apache.hadoop.io.Writable; import org.apache.hadoop.io.Text; /** @@ -72,11 +73,11 @@ // TODO: we use MetadataTypedColumnsetSerDe for now, till DynamicSerDe is // ready - transient Serializer keySerializer; - transient boolean keyIsText; - transient Serializer valueSerializer; + protected transient Serializer keySerializer; + protected transient boolean keyIsText; + protected transient Serializer valueSerializer; transient int tag; - transient byte[] tagByte = new byte[1]; + protected transient byte[] tagByte = new byte[1]; transient protected int numDistributionKeys; transient protected int numDistinctExprs; transient String inputAlias; // input alias of this RS for join (used for PPD) @@ -163,12 +164,15 @@ private TopNHash createTopKHash() { } transient InspectableObject tempInspectableObject = new InspectableObject(); - transient HiveKey keyWritable = new HiveKey(); + protected transient HiveKey keyWritable = new HiveKey(); + protected transient Writable value; transient StructObjectInspector keyObjectInspector; transient StructObjectInspector valueObjectInspector; transient ObjectInspector[] partitionObjectInspectors; + protected transient Object[] cachedValues; + protected transient List> distinctColIndices; /** * This two dimensional array holds key data and a corresponding Union object * which contains the tag identifying the aggregate expression for distinct columns. @@ -183,13 +187,9 @@ private TopNHash createTopKHash() { * in this case, child GBY evaluates distict values with expression like KEY.col2:0.dist1 * see {@link ExprNodeColumnEvaluator} */ - transient Object[][] cachedKeys; - transient Object[] cachedValues; - transient List> distinctColIndices; - + protected transient Object[][] cachedKeys; boolean firstRow; - - transient Random random; + protected transient Random random; /** * Initializes array of ExprNodeEvaluator. Adds Union field for distinct diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/Utilities.java ql/src/java/org/apache/hadoop/hive/ql/exec/Utilities.java index c6cecb5..db1f3b3 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/Utilities.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/Utilities.java @@ -578,7 +578,7 @@ private static void setPlanPath(Configuration conf, String hiveScratchDir) throw } } - private static Path getPlanPath(Configuration conf) { + public static Path getPlanPath(Configuration conf) { String plan = HiveConf.getVar(conf, HiveConf.ConfVars.PLAN); if (plan != null && !plan.isEmpty()) { return new Path(plan); diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/mr/ExecDriver.java ql/src/java/org/apache/hadoop/hive/ql/exec/mr/ExecDriver.java index bd9d0bb..a961f11 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/mr/ExecDriver.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/mr/ExecDriver.java @@ -237,6 +237,7 @@ public int execute(DriverContext driverContext) { ShimLoader.getHadoopShims().prepareJobOutput(job); //See the javadoc on HiveOutputFormatImpl and HadoopShims.prepareJobOutput() job.setOutputFormat(HiveOutputFormatImpl.class); + job.setMapperClass(ExecMapper.class); job.setMapOutputKeyClass(HiveKey.class); @@ -828,3 +829,4 @@ public void shutdown() { } } } + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/BytesColumnVector.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/BytesColumnVector.java new file mode 100644 index 0000000..e1d4543 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/BytesColumnVector.java @@ -0,0 +1,222 @@ +/** + * 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.exec.vector; + +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Text; +import org.apache.hadoop.io.Writable; + +/** + * This class supports string and binary data by value reference -- i.e. each field is + * explicitly present, as opposed to provided by a dictionary reference. + * In some cases, all the values will be in the same byte array to begin with, + * but this need not be the case. If each value is in a separate byte + * array to start with, or not all of the values are in the same original + * byte array, you can still assign data by reference into this column vector. + * This gives flexibility to use this in multiple situations. + *

+ * When setting data by reference, the caller + * is responsible for allocating the byte arrays used to hold the data. + * You can also set data by value, as long as you call the initBuffer() method first. + * You can mix "by value" and "by reference" in the same column vector, + * though that use is probably not typical. + */ +public class BytesColumnVector extends ColumnVector { + public byte[][] vector; + public int[] start; // start offset of each field + + /* + * The length of each field. If the value repeats for every entry, then it is stored + * in vector[0] and isRepeating from the superclass is set to true. + */ + public int[] length; + private byte[] buffer; // optional buffer to use when actually copying in data + private int nextFree; // next free position in buffer + + // Reusable text object + private final Text textObject = new Text(); + + // Estimate that there will be 16 bytes per entry + static final int DEFAULT_BUFFER_SIZE = 16 * VectorizedRowBatch.DEFAULT_SIZE; + + // Proportion of extra space to provide when allocating more buffer space. + static final float EXTRA_SPACE_FACTOR = (float) 1.2; + + /** + * Use this constructor for normal operation. + * All column vectors should be the default size normally. + */ + public BytesColumnVector() { + this(VectorizedRowBatch.DEFAULT_SIZE); + } + + /** + * Don't call this constructor except for testing purposes. + * + * @param size number of elements in the column vector + */ + public BytesColumnVector(int size) { + super(size); + vector = new byte[size][]; + start = new int[size]; + length = new int[size]; + } + + /** Set a field by reference. + * + * @param elementNum index within column vector to set + * @param sourceBuf container of source data + * @param start start byte position within source + * @param length length of source byte sequence + */ + public void setRef(int elementNum, byte[] sourceBuf, int start, int length) { + vector[elementNum] = sourceBuf; + this.start[elementNum] = start; + this.length[elementNum] = length; + } + + /** + * You must call initBuffer first before using setVal(). + * Provide the estimated number of bytes needed to hold + * a full column vector worth of byte string data. + * + * @param estimatedValueSize Estimated size of buffer space needed + */ + public void initBuffer(int estimatedValueSize) { + nextFree = 0; + + // if buffer is already allocated, keep using it, don't re-allocate + if (buffer != null) { + return; + } + + // allocate a little extra space to limit need to re-allocate + int bufferSize = this.vector.length * (int)(estimatedValueSize * EXTRA_SPACE_FACTOR); + if (bufferSize < DEFAULT_BUFFER_SIZE) { + bufferSize = DEFAULT_BUFFER_SIZE; + } + buffer = new byte[bufferSize]; + } + + /** + * Initialize buffer to default size. + */ + public void initBuffer() { + initBuffer(0); + } + + /** + * @return amount of buffer space currently allocated + */ + public int bufferSize() { + if (buffer == null) { + return 0; + } + return buffer.length; + } + + /** + * Set a field by actually copying in to a local buffer. + * If you must actually copy data in to the array, use this method. + * DO NOT USE this method unless it's not practical to set data by reference with setRef(). + * Setting data by reference tends to run a lot faster than copying data in. + * + * @param elementNum index within column vector to set + * @param sourceBuf container of source data + * @param start start byte position within source + * @param length length of source byte sequence + */ + public void setVal(int elementNum, byte[] sourceBuf, int start, int length) { + if ((nextFree + length) > buffer.length) { + increaseBufferSpace(length); + } + System.arraycopy(sourceBuf, start, buffer, nextFree, length); + vector[elementNum] = buffer; + this.start[elementNum] = nextFree; + this.length[elementNum] = length; + nextFree += length; + } + + /** + * Set a field to the concatenation of two string values. Result data is copied + * into the internal buffer. + * + * @param elementNum index within column vector to set + * @param leftSourceBuf container of left argument + * @param leftStart start of left argument + * @param leftLen length of left argument + * @param rightSourceBuf container of right argument + * @param rightStart start of right argument + * @param rightLen length of right arugment + */ + public void setConcat(int elementNum, byte[] leftSourceBuf, int leftStart, int leftLen, + byte[] rightSourceBuf, int rightStart, int rightLen) { + int newLen = leftLen + rightLen; + if ((nextFree + newLen) > buffer.length) { + increaseBufferSpace(newLen); + } + vector[elementNum] = buffer; + this.start[elementNum] = nextFree; + this.length[elementNum] = newLen; + + System.arraycopy(leftSourceBuf, leftStart, buffer, nextFree, leftLen); + nextFree += leftLen; + System.arraycopy(rightSourceBuf, rightStart, buffer, nextFree, rightLen); + nextFree += rightLen; + } + + /** + * Increase buffer space enough to accommodate next element. + * This uses an exponential increase mechanism to rapidly + * increase buffer size to enough to hold all data. + * As batches get re-loaded, buffer space allocated will quickly + * stabilize. + * + * @param nextElemLength size of next element to be added + */ + public void increaseBufferSpace(int nextElemLength) { + + // Keep doubling buffer size until there will be enough space for next element. + int newLength = 2 * buffer.length; + while((nextFree + nextElemLength) > newLength) { + newLength *= 2; + } + + // Allocate new buffer, copy data to it, and set buffer to new buffer. + byte[] newBuffer = new byte[newLength]; + System.arraycopy(buffer, 0, newBuffer, 0, nextFree); + buffer = newBuffer; + } + + @Override + public Writable getWritableObject(int index) { + if (this.isRepeating) { + index = 0; + } + Writable result = null; + if (!isNull[index] && vector[index] != null) { + textObject.clear(); + textObject.append(vector[index], start[index], length[index]); + result = textObject; + } else { + result = NullWritable.get(); + } + return result; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/ColumnVector.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/ColumnVector.java new file mode 100644 index 0000000..8b4c615 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/ColumnVector.java @@ -0,0 +1,64 @@ +/** + * 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.exec.vector; + +import org.apache.hadoop.io.Writable; + +/** + * ColumnVector contains the shared structure for the sub-types, + * including NULL information, and whether this vector + * repeats, i.e. has all values the same, so only the first + * one is set. This is used to accelerate query performance + * by handling a whole vector in O(1) time when applicable. + * + * The fields are public by design since this is a performance-critical + * structure that is used in the inner loop of query execution. + */ +public abstract class ColumnVector { + + /* + * If hasNulls is true, then this array contains true if the value + * is null, otherwise false. The array is always allocated, so a batch can be re-used + * later and nulls added. + */ + public boolean[] isNull; + + // If the whole column vector has no nulls, this is true, otherwise false. + public boolean noNulls; + + /* + * True if same value repeats for whole column vector. + * If so, vector[0] holds the repeating value. + */ + public boolean isRepeating; + public abstract Writable getWritableObject(int index); + + /** + * Constructor for super-class ColumnVector. This is not called directly, + * but used to initialize inherited fields. + * + * @param len Vector length + */ + public ColumnVector(int len) { + isNull = new boolean[len]; + noNulls = true; + isRepeating = false; + } +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/DoubleColumnVector.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/DoubleColumnVector.java new file mode 100644 index 0000000..d3bb28e --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/DoubleColumnVector.java @@ -0,0 +1,70 @@ +/** + * 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.exec.vector; + +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Writable; + +/** + * This class represents a nullable double precision floating point column vector. + * This class will be used for operations on all floating point types (float, double) + * and as such will use a 64-bit double value to hold the biggest possible value. + * During copy-in/copy-out, smaller types (i.e. float) will be converted as needed. This will + * reduce the amount of code that needs to be generated and also will run fast since the + * machine operates with 64-bit words. + * + * The vector[] field is public by design for high-performance access in the inner + * loop of query execution. + */ +public class DoubleColumnVector extends ColumnVector { + public double[] vector; + private final DoubleWritable writableObj = new DoubleWritable(); + public static final double NULL_VALUE = Double.NaN; + + /** + * Use this constructor by default. All column vectors + * should normally be the default size. + */ + public DoubleColumnVector() { + this(VectorizedRowBatch.DEFAULT_SIZE); + } + + /** + * Don't use this except for testing purposes. + * + * @param len + */ + public DoubleColumnVector(int len) { + super(len); + vector = new double[len]; + } + + @Override + public Writable getWritableObject(int index) { + if (this.isRepeating) { + index = 0; + } + if (!noNulls && isNull[index]) { + return NullWritable.get(); + } else { + writableObj.set(vector[index]); + return writableObj; + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/LongColumnVector.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/LongColumnVector.java new file mode 100644 index 0000000..f65e8fa --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/LongColumnVector.java @@ -0,0 +1,70 @@ +/** + * 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.exec.vector; + +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Writable; + +/** + * This class represents a nullable int column vector. + * This class will be used for operations on all integer types (tinyint, smallint, int, bigint) + * and as such will use a 64-bit long value to hold the biggest possible value. + * During copy-in/copy-out, smaller int types will be converted as needed. This will + * reduce the amount of code that needs to be generated and also will run fast since the + * machine operates with 64-bit words. + * + * The vector[] field is public by design for high-performance access in the inner + * loop of query execution. + */ +public class LongColumnVector extends ColumnVector { + public long[] vector; + private final LongWritable writableObj = new LongWritable(); + public static final long NULL_VALUE = 1; + + /** + * Use this constructor by default. All column vectors + * should normally be the default size. + */ + public LongColumnVector() { + this(VectorizedRowBatch.DEFAULT_SIZE); + } + + /** + * Don't use this except for testing purposes. + * + * @param len + */ + public LongColumnVector(int len) { + super(len); + vector = new long[len]; + } + + @Override + public Writable getWritableObject(int index) { + if (this.isRepeating) { + index = 0; + } + if (!noNulls && isNull[index]) { + return NullWritable.get(); + } else { + writableObj.set(vector[index]); + return writableObj; + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/TimestampUtils.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/TimestampUtils.java new file mode 100644 index 0000000..b9b7744 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/TimestampUtils.java @@ -0,0 +1,35 @@ +/** + * 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.exec.vector; + +import java.sql.Timestamp; + +public final class TimestampUtils { + + public static void assignTimeInNanoSec(long timeInNanoSec, Timestamp t) { + t.setTime((timeInNanoSec)/1000000); + t.setNanos((int)((t.getNanos()) + (timeInNanoSec % 1000000))); + } + + public static long getTimeNanoSec(Timestamp t) { + long time = t.getTime(); + int nanos = t.getNanos(); + return (time * 1000000) + (nanos % 1000000); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorAggregationBufferBatch.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorAggregationBufferBatch.java new file mode 100644 index 0000000..630046d --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorAggregationBufferBatch.java @@ -0,0 +1,165 @@ +/** + * 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.exec.vector; + +import java.util.Arrays; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.util.JavaDataModel; + +/** + * This maps a batch to the aggregation buffers sets to use for each row (key) + * + */ +public class VectorAggregationBufferBatch { + + /** + * Batch sized array of aggregation buffer sets. + * The array is preallocated and is reused for each batch, but the individual entries + * will reference different aggregation buffer set from batch to batch. + * the array is not reset between batches, content past this.index will be stale. + */ + private final VectorAggregationBufferRow[] aggregationBuffers; + + /** + * Same as aggregationBuffers but only distinct buffers + */ + private final VectorAggregationBufferRow[] distinctAggregationBuffers; + + /** + * versioning number gets incremented on each batch. This allows us to cache the selection + * mapping info in the aggregation buffer set themselves while still being able to + * detect stale info. + */ + private int version; + + /** + * Get the number of distinct aggregation buffer sets (ie. keys) used in current batch. + */ + private int distinctCount; + + /** + * Memory consumed by a set of aggregation buffers + */ + private int aggregatorsFixedSize; + + /** + * Array of indexes for aggregators that have variable size + */ + private int[] variableSizeAggregators;; + + /** + * returns True if any of the aggregators has a variable size + * @return + */ + public boolean getHasVariableSize() { + return variableSizeAggregators.length > 0; + } + + /** + * Returns the fixed size consumed by the aggregation buffers + * @return + */ + public int getAggregatorsFixedSize() { + return aggregatorsFixedSize; + } + + /** + * the array of aggregation buffers for the current batch. + * content past the {@link #getDistinctBufferSetCount()} index + * is stale from previous batches. + * @return + */ + public VectorAggregationBufferRow[] getAggregationBuffers() { + return aggregationBuffers; + } + + /** + * number of distinct aggregation buffer sets (ie. keys) in the current batch. + * @return + */ + public int getDistinctBufferSetCount () { + return distinctCount; + } + + + public VectorAggregationBufferBatch() { + aggregationBuffers = new VectorAggregationBufferRow[VectorizedRowBatch.DEFAULT_SIZE]; + distinctAggregationBuffers = new VectorAggregationBufferRow[VectorizedRowBatch.DEFAULT_SIZE]; + } + + /** + * resets the internal aggregation buffers sets index and increments the versioning + * used to optimize the selection vector population. + */ + public void startBatch() { + version++; + distinctCount = 0; + } + + /** + * assigns the given aggregation buffer set to a given batch row (by row number). + * populates the selection vector appropriately. This is where the versioning numbers + * play a role in determining if the index cached on the aggregation buffer set is stale. + */ + public void mapAggregationBufferSet(VectorAggregationBufferRow bufferSet, int row) { + if (version != bufferSet.getVersion()) { + bufferSet.setVersionAndIndex(version, distinctCount); + distinctAggregationBuffers[distinctCount] = bufferSet; + ++distinctCount; + } + aggregationBuffers[row] = bufferSet; + } + + public void compileAggregationBatchInfo(VectorAggregateExpression[] aggregators) { + JavaDataModel model = JavaDataModel.get(); + int[] variableSizeAggregators = new int[aggregators.length]; + int indexVariableSizes = 0; + + aggregatorsFixedSize = JavaDataModel.alignUp( + model.object() + + model.primitive1()*2 + + model.ref(), + model.memoryAlign()); + + aggregatorsFixedSize += model.lengthForObjectArrayOfSize(aggregators.length); + for(int i=0;i 0) { + forward(vrg, null); + } + } + + static public String getOperatorName() { + return "FIL"; + } + + public VectorExpression getConditionEvaluator() { + return conditionEvaluator; + } + + public void setConditionEvaluator(VectorExpression conditionEvaluator) { + this.conditionEvaluator = conditionEvaluator; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorGroupByOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorGroupByOperator.java new file mode 100644 index 0000000..f213ee8 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorGroupByOperator.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.exec.vector; + +import java.lang.management.ManagementFactory; +import java.lang.management.MemoryMXBean; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.ql.exec.GroupByOperator; +import org.apache.hadoop.hive.ql.exec.KeyWrapper; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriterFactory; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.GroupByDesc; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; + +/** + * Vectorized GROUP BY operator implementation. Consumes the vectorized input and + * stores the aggregate operators' intermediate states. Emits row mode output. + * + */ +public class VectorGroupByOperator extends GroupByOperator { + + private static final Log LOG = LogFactory.getLog( + VectorGroupByOperator.class.getName()); + + /** + * This is the vector of aggregators. They are stateless and only implement + * the algorithm of how to compute the aggregation. state is kept in the + * aggregation buffers and is our responsibility to match the proper state for each key. + */ + private VectorAggregateExpression[] aggregators; + + /** + * Key vector expressions. + */ + private VectorExpression[] keyExpressions; + + private transient VectorExpressionWriter[] keyOutputWriters; + + /** + * The aggregation buffers to use for the current batch. + */ + private transient VectorAggregationBufferBatch aggregationBatchInfo; + + /** + * The current batch key wrappers. + * The very same instance gets reused for all batches. + */ + private transient VectorHashKeyWrapperBatch keyWrappersBatch; + + /** + * Total per hashtable entry fixed memory (does not depend on key/agg values). + */ + private transient int fixedHashEntrySize; + + /** + * Average per hashtable entry variable size memory (depends on key/agg value). + */ + private transient int avgVariableSize; + + /** + * Number of entries added to the hashtable since the last check if it should flush. + */ + private transient int numEntriesSinceCheck; + + /** + * Sum of batch size processed (ie. rows). + */ + private transient long sumBatchSize; + + /** + * The number of new entries that must be added to the hashtable before a memory size check. + */ + private static final int FLUSH_CHECK_THRESHOLD = 10000; + + /** + * Percent of entries to flush when memory threshold exceeded. + */ + private static final float PERCENT_ENTRIES_TO_FLUSH = 0.1f; + + /** + * The global key-aggregation hash map. + */ + private transient Map mapKeysAggregationBuffers; + + private static final long serialVersionUID = 1L; + + public VectorGroupByOperator(VectorizationContext vContext, OperatorDesc conf) + throws HiveException { + this(); + GroupByDesc desc = (GroupByDesc) conf; + this.conf = desc; + vContext.setOperatorType(OperatorType.GROUPBY); + List keysDesc = desc.getKeys(); + keyExpressions = vContext.getVectorExpressions(keysDesc); + ArrayList aggrDesc = desc.getAggregators(); + aggregators = new VectorAggregateExpression[aggrDesc.size()]; + for (int i = 0; i < aggrDesc.size(); ++i) { + AggregationDesc aggDesc = aggrDesc.get(i); + aggregators[i] = vContext.getAggregatorExpression(aggDesc); + } + } + + public VectorGroupByOperator() { + super(); + } + + @Override + protected void initializeOp(Configuration hconf) throws HiveException { + + List objectInspectors = new ArrayList(); + + List keysDesc = conf.getKeys(); + try { + + keyOutputWriters = new VectorExpressionWriter[keyExpressions.length]; + + for(int i = 0; i < keyExpressions.length; ++i) { + keyOutputWriters[i] = VectorExpressionWriterFactory. + genVectorExpressionWritable(keysDesc.get(i)); + objectInspectors.add(keyOutputWriters[i].getObjectInspector()); + } + + for (int i = 0; i < aggregators.length; ++i) { + aggregators[i].init(conf.getAggregators().get(i)); + objectInspectors.add(aggregators[i].getOutputObjectInspector()); + } + + keyWrappersBatch = VectorHashKeyWrapperBatch.compileKeyWrapperBatch(keyExpressions); + aggregationBatchInfo = new VectorAggregationBufferBatch(); + aggregationBatchInfo.compileAggregationBatchInfo(aggregators); + mapKeysAggregationBuffers = new HashMap(); + + List outputFieldNames = conf.getOutputColumnNames(); + outputObjInspector = ObjectInspectorFactory.getStandardStructObjectInspector( + outputFieldNames, objectInspectors); + + } catch (HiveException he) { + throw he; + } catch (Throwable e) { + throw new HiveException(e); + } + + computeMemoryLimits(); + + initializeChildren(hconf); + } + + /** + * Computes the memory limits for hash table flush (spill). + */ + private void computeMemoryLimits() { + JavaDataModel model = JavaDataModel.get(); + + fixedHashEntrySize = + model.hashMapEntry() + + keyWrappersBatch.getKeysFixedSize() + + aggregationBatchInfo.getAggregatorsFixedSize(); + + MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean(); + maxMemory = memoryMXBean.getHeapMemoryUsage().getMax(); + memoryThreshold = conf.getMemoryThreshold(); + // Tests may leave this unitialized, so better set it to 1 + if (memoryThreshold == 0.0f) { + memoryThreshold = 1.0f; + } + + maxHashTblMemory = (int)(maxMemory * memoryThreshold); + + if (LOG.isDebugEnabled()) { + LOG.debug(String.format("maxMemory:%dMb (%d * %f) fixSize:%d (key:%d agg:%d)", + maxHashTblMemory/1024/1024, + maxMemory/1024/1024, + memoryThreshold, + fixedHashEntrySize, + keyWrappersBatch.getKeysFixedSize(), + aggregationBatchInfo.getAggregatorsFixedSize())); + } + + } + + @Override + public void processOp(Object row, int tag) throws HiveException { + VectorizedRowBatch batch = (VectorizedRowBatch) row; + + // First we traverse the batch to evaluate and prepare the KeyWrappers + // After this the KeyWrappers are properly set and hash code is computed + keyWrappersBatch.evaluateBatch(batch); + + // Next we locate the aggregation buffer set for each key + prepareBatchAggregationBufferSets(batch); + + // Finally, evaluate the aggregators + processAggregators(batch); + + //Flush if memory limits were reached + if (shouldFlush(batch)) { + flush(false); + } + + if (sumBatchSize == 0 && 0 != batch.size) { + // Sample the first batch processed for variable sizes. + updateAvgVariableSize(batch); + } + + sumBatchSize += batch.size; + } + + /** + * Flushes the entries in the hash table by emiting output (forward). + * When parameter 'all' is true all the entries are flushed. + * @param all + * @throws HiveException + */ + private void flush(boolean all) throws HiveException { + + int entriesToFlush = all ? numEntriesHashTable : + (int)(numEntriesHashTable * PERCENT_ENTRIES_TO_FLUSH); + int entriesFlushed = 0; + + if (LOG.isDebugEnabled()) { + LOG.debug(String.format("Flush %d %s entries:%d fixed:%d variable:%d (used:%dMb max:%dMb)", + entriesToFlush, all ? "(all)" : "", + numEntriesHashTable, fixedHashEntrySize, avgVariableSize, + numEntriesHashTable * (fixedHashEntrySize + avgVariableSize)/1024/1024, + maxHashTblMemory/1024/1024)); + } + + Object[] forwardCache = new Object[keyExpressions.length + aggregators.length]; + if (keyExpressions.length == 0 && mapKeysAggregationBuffers.isEmpty()) { + // if this is a global aggregation (no keys) and empty set, must still emit NULLs + VectorAggregationBufferRow emptyBuffers = allocateAggregationBuffer(); + for (int i = 0; i < aggregators.length; ++i) { + forwardCache[i] = aggregators[i].evaluateOutput(emptyBuffers.getAggregationBuffer(i)); + } + forward(forwardCache, outputObjInspector); + } else { + /* Iterate the global (keywrapper,aggregationbuffers) map and emit + a row for each key */ + Iterator> iter = + mapKeysAggregationBuffers.entrySet().iterator(); + while(iter.hasNext()) { + Map.Entry pair = iter.next(); + int fi = 0; + for (int i = 0; i < keyExpressions.length; ++i) { + VectorHashKeyWrapper kw = (VectorHashKeyWrapper)pair.getKey(); + forwardCache[fi++] = keyWrappersBatch.getWritableKeyValue ( + kw, i, keyOutputWriters[i]); + } + for (int i = 0; i < aggregators.length; ++i) { + forwardCache[fi++] = aggregators[i].evaluateOutput(pair.getValue() + .getAggregationBuffer(i)); + } + if (LOG.isDebugEnabled()) { + LOG.debug(String.format("forwarding keys: %s: %s", + pair.getKey().toString(), Arrays.toString(forwardCache))); + } + forward(forwardCache, outputObjInspector); + + if (!all) { + iter.remove(); + --numEntriesHashTable; + if (++entriesFlushed >= entriesToFlush) { + break; + } + } + } + } + + if (all) { + mapKeysAggregationBuffers.clear(); + numEntriesHashTable = 0; + } + } + + /** + * Returns true if the memory threshold for the hash table was reached. + */ + private boolean shouldFlush(VectorizedRowBatch batch) { + if (numEntriesSinceCheck < FLUSH_CHECK_THRESHOLD || + batch.size == 0) { + return false; + } + // Were going to update the average variable row size by sampling the current batch + updateAvgVariableSize(batch); + numEntriesSinceCheck = 0; + return numEntriesHashTable * (fixedHashEntrySize + avgVariableSize) > maxHashTblMemory; + } + + /** + * Updates the average variable size of the hash table entries. + * The average is only updates by probing the batch that added the entry in the hash table + * that caused the check threshold to be reached. + */ + private void updateAvgVariableSize(VectorizedRowBatch batch) { + int keyVariableSize = keyWrappersBatch.getVariableSize(batch.size); + int aggVariableSize = aggregationBatchInfo.getVariableSize(batch.size); + + // This assumes the distribution of variable size keys/aggregates in the input + // is the same as the distribution of variable sizes in the hash entries + avgVariableSize = (int)((avgVariableSize * sumBatchSize + keyVariableSize +aggVariableSize) / + (sumBatchSize + batch.size)); + } + + /** + * Evaluates the aggregators on the current batch. + * The aggregationBatchInfo must have been prepared + * by calling {@link #prepareBatchAggregationBufferSets} first. + */ + private void processAggregators(VectorizedRowBatch batch) throws HiveException { + // We now have a vector of aggregation buffer sets to use for each row + // We can start computing the aggregates. + // If the number of distinct keys in the batch is 1 we can + // use the optimized code path of aggregateInput + VectorAggregationBufferRow[] aggregationBufferSets = + aggregationBatchInfo.getAggregationBuffers(); + if (aggregationBatchInfo.getDistinctBufferSetCount() == 1) { + VectorAggregateExpression.AggregationBuffer[] aggregationBuffers = + aggregationBufferSets[0].getAggregationBuffers(); + for (int i = 0; i < aggregators.length; ++i) { + aggregators[i].aggregateInput(aggregationBuffers[i], batch); + } + } else { + for (int i = 0; i < aggregators.length; ++i) { + aggregators[i].aggregateInputSelection( + aggregationBufferSets, + i, + batch); + } + } + } + + /** + * Locates the aggregation buffer sets to use for each key in the current batch. + * The keyWrappersBatch must have evaluated the current batch first. + */ + private void prepareBatchAggregationBufferSets(VectorizedRowBatch batch) throws HiveException { + // The aggregation batch vector needs to know when we start a new batch + // to bump its internal version. + aggregationBatchInfo.startBatch(); + + // We now have to probe the global hash and find-or-allocate + // the aggregation buffers to use for each key present in the batch + VectorHashKeyWrapper[] keyWrappers = keyWrappersBatch.getVectorHashKeyWrappers(); + for (int i=0; i < batch.size; ++i) { + VectorHashKeyWrapper kw = keyWrappers[i]; + VectorAggregationBufferRow aggregationBuffer = mapKeysAggregationBuffers.get(kw); + if (null == aggregationBuffer) { + // the probe failed, we must allocate a set of aggregation buffers + // and push the (keywrapper,buffers) pair into the hash. + // is very important to clone the keywrapper, the one we have from our + // keyWrappersBatch is going to be reset/reused on next batch. + aggregationBuffer = allocateAggregationBuffer(); + mapKeysAggregationBuffers.put(kw.copyKey(), aggregationBuffer); + numEntriesHashTable++; + numEntriesSinceCheck++; + } + aggregationBatchInfo.mapAggregationBufferSet(aggregationBuffer, i); + } + } + + /** + * allocates a new aggregation buffer set. + */ + private VectorAggregationBufferRow allocateAggregationBuffer() throws HiveException { + VectorAggregateExpression.AggregationBuffer[] aggregationBuffers = + new VectorAggregateExpression.AggregationBuffer[aggregators.length]; + for (int i=0; i < aggregators.length; ++i) { + aggregationBuffers[i] = aggregators[i].getNewAggregationBuffer(); + aggregators[i].reset(aggregationBuffers[i]); + } + VectorAggregationBufferRow bufferSet = new VectorAggregationBufferRow(aggregationBuffers); + return bufferSet; + } + + @Override + public void closeOp(boolean aborted) throws HiveException { + if (!aborted) { + flush(true); + } + } + + static public String getOperatorName() { + return "GBY"; + } + + public VectorExpression[] getKeyExpressions() { + return keyExpressions; + } + + public void setKeyExpressions(VectorExpression[] keyExpressions) { + this.keyExpressions = keyExpressions; + } + + public VectorAggregateExpression[] getAggregators() { + return aggregators; + } + + public void setAggregators(VectorAggregateExpression[] aggregators) { + this.aggregators = aggregators; + } + +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorHashKeyWrapper.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorHashKeyWrapper.java new file mode 100644 index 0000000..f083d86 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorHashKeyWrapper.java @@ -0,0 +1,257 @@ +/** + * 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.exec.vector; + +import java.util.Arrays; + +import org.apache.hadoop.hive.ql.exec.KeyWrapper; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; + +/** + * A hash map key wrapper for vectorized processing. + * It stores the key values as primitives in arrays for each supported primitive type. + * This works in conjunction with + * {@link org.apache.hadoop.hive.ql.exec.VectorHashKeyWrapperBatch VectorHashKeyWrapperBatch} + * to hash vectorized processing units (batches). + */ +public class VectorHashKeyWrapper extends KeyWrapper { + + private long[] longValues; + private double[] doubleValues; + + private byte[][] byteValues; + private int[] byteStarts; + private int[] byteLengths; + + private boolean[] isNull; + private int hashcode; + + public VectorHashKeyWrapper(int longValuesCount, int doubleValuesCount, int byteValuesCount) { + longValues = new long[longValuesCount]; + doubleValues = new double[doubleValuesCount]; + byteValues = new byte[byteValuesCount][]; + byteStarts = new int[byteValuesCount]; + byteLengths = new int[byteValuesCount]; + isNull = new boolean[longValuesCount + doubleValuesCount + byteValuesCount]; + } + + private VectorHashKeyWrapper() { + } + + @Override + public void getNewKey(Object row, ObjectInspector rowInspector) throws HiveException { + throw new HiveException("Should not be called"); + } + + @Override + public void setHashKey() { + hashcode = Arrays.hashCode(longValues) ^ + Arrays.hashCode(doubleValues) ^ + Arrays.hashCode(isNull); + + // This code, with branches and all, is not executed if there are no string keys + for (int i = 0; i < byteValues.length; ++i) { + /* + * Hashing the string is potentially expensive so is better to branch. + * Additionally not looking at values for nulls allows us not reset the values. + */ + if (!isNull[longValues.length + doubleValues.length + i]) { + byte[] bytes = byteValues[i]; + int start = byteStarts[i]; + int length = byteLengths[i]; + if (length == bytes.length && start == 0) { + hashcode ^= Arrays.hashCode(bytes); + } + else { + // Unfortunately there is no Arrays.hashCode(byte[], start, length) + for(int j = start; j < start + length; ++j) { + // use 461 as is a (sexy!) prime. + hashcode ^= 461 * bytes[j]; + } + } + } + } + } + + @Override + public int hashCode() { + return hashcode; + } + + @Override + public boolean equals(Object that) { + if (that instanceof VectorHashKeyWrapper) { + VectorHashKeyWrapper keyThat = (VectorHashKeyWrapper)that; + return hashcode == keyThat.hashcode && + Arrays.equals(longValues, keyThat.longValues) && + Arrays.equals(doubleValues, keyThat.doubleValues) && + Arrays.equals(isNull, keyThat.isNull) && + byteValues.length == keyThat.byteValues.length && + (0 == byteValues.length || bytesEquals(keyThat)); + } + return false; + } + + private boolean bytesEquals(VectorHashKeyWrapper keyThat) { + //By the time we enter here the byteValues.lentgh and isNull must have already been compared + for (int i = 0; i < byteValues.length; ++i) { + // the byte comparison is potentially expensive so is better to branch on null + if (!isNull[longValues.length + doubleValues.length + i]) { + if (0 != StringExpr.compare( + byteValues[i], + byteStarts[i], + byteLengths[i], + keyThat.byteValues[i], + keyThat.byteStarts[i], + keyThat.byteLengths[i])) { + return false; + } + } + } + return true; + } + + @Override + protected Object clone() { + VectorHashKeyWrapper clone = new VectorHashKeyWrapper(); + clone.longValues = longValues.clone(); + clone.doubleValues = doubleValues.clone(); + clone.isNull = isNull.clone(); + + clone.byteValues = new byte[byteValues.length][]; + clone.byteStarts = new int[byteValues.length]; + clone.byteLengths = byteLengths.clone(); + for (int i = 0; i < byteValues.length; ++i) { + // avoid allocation/copy of nulls, because it potentially expensive. branch instead. + if (!isNull[longValues.length + doubleValues.length + i]) { + clone.byteValues[i] = Arrays.copyOfRange( + byteValues[i], + byteStarts[i], + byteStarts[i] + byteLengths[i]); + } + } + clone.hashcode = hashcode; + assert clone.equals(this); + return clone; + } + + @Override + public KeyWrapper copyKey() { + return (KeyWrapper) clone(); + } + + @Override + public void copyKey(KeyWrapper oldWrapper) { + throw new UnsupportedOperationException(); + } + + @Override + public Object[] getKeyArray() { + throw new UnsupportedOperationException(); + } + + public void assignDouble(int index, double d) { + doubleValues[index] = d; + isNull[longValues.length + index] = false; + } + + public void assignNullDouble(int index) { + doubleValues[index] = 0; // assign 0 to simplify hashcode + isNull[longValues.length + index] = true; + } + + public void assignLong(int index, long v) { + longValues[index] = v; + isNull[index] = false; + } + + public void assignNullLong(int index) { + longValues[index] = 0; // assign 0 to simplify hashcode + isNull[index] = true; + } + + public void assignString(int index, byte[] bytes, int start, int length) { + byteValues[index] = bytes; + byteStarts[index] = start; + byteLengths[index] = length; + isNull[longValues.length + doubleValues.length + index] = false; + } + + public void assignNullString(int index) { + // We do not assign the value to byteValues[] because the value is never used on null + isNull[longValues.length + doubleValues.length + index] = true; + } + + @Override + public String toString() + { + return String.format("%d[%s] %d[%s] %d[%s]", + longValues.length, Arrays.toString(longValues), + doubleValues.length, Arrays.toString(doubleValues), + byteValues.length, Arrays.toString(byteValues)); + } + + public boolean getIsLongNull(int i) { + return isNull[i]; + } + + public boolean getIsDoubleNull(int i) { + return isNull[longValues.length + i]; + } + + public boolean getIsBytesNull(int i) { + return isNull[longValues.length + doubleValues.length + i]; + } + + + public long getLongValue(int i) { + return longValues[i]; + } + + public double getDoubleValue(int i) { + return doubleValues[i]; + } + + public byte[] getBytes(int i) { + return byteValues[i]; + } + + public int getByteStart(int i) { + return byteStarts[i]; + } + + public int getByteLength(int i) { + return byteLengths[i]; + } + + public int getVariableSize() { + int variableSize = 0; + for (int i=0; i + *

  • Evaluates each key vector expression.
  • + *
  • Copies out each key's primitive values into the key wrappers
  • + *
  • computes the hashcode of the key wrappers
  • + * + * @param batch + * @throws HiveException + */ + public void evaluateBatch(VectorizedRowBatch batch) throws HiveException { + for(int i = 0; i < keyExpressions.length; ++i) { + keyExpressions[i].evaluate(batch); + } + for(int i = 0; i< longIndices.length; ++i) { + int keyIndex = longIndices[i]; + int columnIndex = keyExpressions[keyIndex].getOutputColumn(); + LongColumnVector columnVector = (LongColumnVector) batch.cols[columnIndex]; + if (columnVector.noNulls && !columnVector.isRepeating && !batch.selectedInUse) { + assignLongNoNullsNoRepeatingNoSelection(i, batch.size, columnVector); + } else if (columnVector.noNulls && !columnVector.isRepeating && batch.selectedInUse) { + assignLongNoNullsNoRepeatingSelection(i, batch.size, columnVector, batch.selected); + } else if (columnVector.noNulls && columnVector.isRepeating) { + assignLongNoNullsRepeating(i, batch.size, columnVector); + } else if (!columnVector.noNulls && !columnVector.isRepeating && !batch.selectedInUse) { + assignLongNullsNoRepeatingNoSelection(i, batch.size, columnVector); + } else if (!columnVector.noNulls && columnVector.isRepeating) { + assignLongNullsRepeating(i, batch.size, columnVector); + } else if (!columnVector.noNulls && !columnVector.isRepeating && batch.selectedInUse) { + assignLongNullsNoRepeatingSelection (i, batch.size, columnVector, batch.selected); + } else { + throw new HiveException (String.format( + "Unimplemented Long null/repeat/selected combination %b/%b/%b", + columnVector.noNulls, columnVector.isRepeating, batch.selectedInUse)); + } + } + for(int i=0;i= 0) { + return kw.getIsLongNull(klh.longIndex) ? null : + keyOutputWriter.writeValue(kw.getLongValue(klh.longIndex)); + } else if (klh.doubleIndex >= 0) { + return kw.getIsDoubleNull(klh.doubleIndex) ? null : + keyOutputWriter.writeValue(kw.getDoubleValue(klh.doubleIndex)); + } else if (klh.stringIndex >= 0) { + return kw.getIsBytesNull(klh.stringIndex) ? null : + keyOutputWriter.writeValue( + kw.getBytes(klh.stringIndex), + kw.getByteStart(klh.stringIndex), + kw.getByteLength(klh.stringIndex)); + } else { + throw new HiveException(String.format( + "Internal inconsistent KeyLookupHelper at index [%d]:%d %d %d", + i, klh.longIndex, klh.doubleIndex, klh.stringIndex)); + } + } + + public int getVariableSize(int batchSize) { + int variableSize = 0; + if ( 0 < stringIndices.length) { + for (int k=0; k %s", + keyObjectInspector.getClass(), + keyObjectInspector, + colNames)); + + partitionWriters = VectorExpressionWriterFactory.getExpressionWriters(conf.getPartitionCols()); + + TableDesc valueTableDesc = conf.getValueSerializeInfo(); + valueSerializer = (Serializer) valueTableDesc.getDeserializerClass() + .newInstance(); + valueSerializer.initialize(null, valueTableDesc.getProperties()); + + /* + * Compute and assign the value writers and the value object inspector + */ + VectorExpressionWriterFactory.processVectorExpressions( + conf.getValueCols(), + conf.getOutputValueColumnNames(), + new VectorExpressionWriterFactory.Closure() { + @Override + public void assign(VectorExpressionWriter[] writers, + ObjectInspector objectInspector) { + valueWriters = writers; + valueObjectInspector = objectInspector; + } + }); + + colNames = ""; + for(String colName : conf.getOutputValueColumnNames()) { + colNames = String.format("%s %s", colNames, colName); + } + + LOG.info(String.format("valueObjectInspector [%s]%s => %s", + valueObjectInspector.getClass(), + valueObjectInspector, + colNames)); + + int numKeys = numDistinctExprs > 0 ? numDistinctExprs : 1; + int keyLen = numDistinctExprs > 0 ? numDistributionKeys + 1 : + numDistributionKeys; + cachedKeys = new Object[numKeys][keyLen]; + cachedValues = new Object[valueEval.length]; + + } catch(Exception e) { + throw new HiveException(e); + } + } + + @Override + public void processOp(Object row, int tag) throws HiveException { + VectorizedRowBatch vrg = (VectorizedRowBatch) row; + + LOG.info(String.format("sinking %d rows, %d values, %d keys, %d parts", + vrg.size, + valueEval.length, + keyEval.length, + partitionEval.length)); + + try { + + for (int i = 0; i < partitionEval.length; i++) { + partitionEval[i].evaluate(vrg); + } + + // run the vector evaluations + for (int i = 0; i < valueEval.length; i++) { + valueEval[i].evaluate(vrg); + } + // Evaluate the keys + for (int i = 0; i < keyEval.length; i++) { + keyEval[i].evaluate(vrg); + } + + Object[] distributionKeys = new Object[numDistributionKeys]; + + // Emit a (k,v) pair for each row in the batch + // + for (int j = 0 ; j < vrg.size; ++j) { + int rowIndex = j; + if (vrg.selectedInUse) { + rowIndex = vrg.selected[j]; + } + for (int i = 0; i < valueEval.length; i++) { + int batchColumn = valueEval[i].getOutputColumn(); + ColumnVector vectorColumn = vrg.cols[batchColumn]; + cachedValues[i] = valueWriters[i].writeValue(vectorColumn, rowIndex); + } + // Serialize the value + value = valueSerializer.serialize(cachedValues, valueObjectInspector); + + for (int i = 0; i < keyEval.length; i++) { + int batchColumn = keyEval[i].getOutputColumn(); + ColumnVector vectorColumn = vrg.cols[batchColumn]; + distributionKeys[i] = keyWriters[i].writeValue(vectorColumn, rowIndex); + } + // no distinct key + System.arraycopy(distributionKeys, 0, cachedKeys[0], 0, numDistributionKeys); + // Serialize the keys and append the tag + for (int i = 0; i < cachedKeys.length; i++) { + if (keyIsText) { + Text key = (Text) keySerializer.serialize(cachedKeys[i], + keyObjectInspector); + if (tag == -1) { + keyWritable.set(key.getBytes(), 0, key.getLength()); + } else { + int keyLength = key.getLength(); + keyWritable.setSize(keyLength + 1); + System.arraycopy(key.getBytes(), 0, keyWritable.get(), 0, keyLength); + keyWritable.get()[keyLength] = tagByte[0]; + } + } else { + // Must be BytesWritable + BytesWritable key = (BytesWritable) keySerializer.serialize( + cachedKeys[i], keyObjectInspector); + if (tag == -1) { + keyWritable.set(key.getBytes(), 0, key.getLength()); + } else { + int keyLength = key.getLength(); + keyWritable.setSize(keyLength + 1); + System.arraycopy(key.getBytes(), 0, keyWritable.get(), 0, keyLength); + keyWritable.get()[keyLength] = tagByte[0]; + } + } + // Evaluate the HashCode + int keyHashCode = 0; + if (partitionEval.length == 0) { + // If no partition cols, just distribute the data uniformly to provide + // better + // load balance. If the requirement is to have a single reducer, we + // should set + // the number of reducers to 1. + // Use a constant seed to make the code deterministic. + if (random == null) { + random = new Random(12345); + } + keyHashCode = random.nextInt(); + } else { + for (int p = 0; p < partitionEval.length; p++) { + ColumnVector columnVector = vrg.cols[partitionEval[p].getOutputColumn()]; + Object partitionValue = partitionWriters[p].writeValue(columnVector, rowIndex); + keyHashCode = keyHashCode + * 31 + + ObjectInspectorUtils.hashCode( + partitionValue, + partitionWriters[p].getObjectInspector()); + } + } + keyWritable.setHashCode(keyHashCode); + if (out != null) { + out.collect(keyWritable, value); + // Since this is a terminal operator, update counters explicitly - + // forward is not called + if (counterNameToEnum != null) { + ++outputRows; + if (outputRows % 1000 == 0) { + incrCounter(numOutputRowsCntr, outputRows); + outputRows = 0; + } + } + } + } + } + } catch (SerDeException e) { + throw new HiveException(e); + } catch (IOException e) { + throw new HiveException(e); + } + } + + static public String getOperatorName() { + return "RS"; + } + + public VectorExpression[] getPartitionEval() { + return partitionEval; + } + + public void setPartitionEval(VectorExpression[] partitionEval) { + this.partitionEval = partitionEval; + } + + public VectorExpression[] getValueEval() { + return valueEval; + } + + public void setValueEval(VectorExpression[] valueEval) { + this.valueEval = valueEval; + } + + public VectorExpression[] getKeyEval() { + return keyEval; + } + + public void setKeyEval(VectorExpression[] keyEval) { + this.keyEval = keyEval; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorSelectOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorSelectOperator.java new file mode 100644 index 0000000..0fb763a --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorSelectOperator.java @@ -0,0 +1,147 @@ +/** + * 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.exec.vector; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.ql.exec.SelectOperator; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriterFactory; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.SelectDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; + +/** + * Select operator implementation. + */ +public class VectorSelectOperator extends SelectOperator { + + private static final long serialVersionUID = 1L; + + protected VectorExpression[] vExpressions = null; + + private transient int [] projectedColumns = null; + + private transient VectorExpressionWriter [] valueWriters = null; + + public VectorSelectOperator(VectorizationContext vContext, OperatorDesc conf) + throws HiveException { + this.conf = (SelectDesc) conf; + List colList = this.conf.getColList(); + vContext.setOperatorType(OperatorType.SELECT); + vExpressions = new VectorExpression[colList.size()]; + for (int i = 0; i < colList.size(); i++) { + vExpressions[i] = vContext.getVectorExpression(colList.get(i)); + String columnName = this.conf.getOutputColumnNames().get(i); + // Update column map with output column names + vContext.addToColumnMap(columnName, vExpressions[i].getOutputColumn()); + } + } + + public VectorSelectOperator() { + } + + @Override + protected void initializeOp(Configuration hconf) throws HiveException { + // Just forward the row as is + if (conf.isSelStarNoCompute()) { + initializeChildren(hconf); + return; + } + + List objectInspectors = new ArrayList(); + + List colList = conf.getColList(); + valueWriters = VectorExpressionWriterFactory.getExpressionWriters(colList); + for (VectorExpressionWriter vew : valueWriters) { + objectInspectors.add(vew.getObjectInspector()); + } + + List outputFieldNames = conf.getOutputColumnNames(); + outputObjInspector = ObjectInspectorFactory.getStandardStructObjectInspector( + outputFieldNames, objectInspectors); + + initializeChildren(hconf); + projectedColumns = new int [vExpressions.length]; + for (int i = 0; i < projectedColumns.length; i++) { + projectedColumns[i] = vExpressions[i].getOutputColumn(); + } + } + + @Override + public void processOp(Object row, int tag) throws HiveException { + + // Just forward the row as is + if (conf.isSelStarNoCompute()) { + forward(row, inputObjInspectors[tag]); + return; + } + + VectorizedRowBatch vrg = (VectorizedRowBatch) row; + for (int i = 0; i < vExpressions.length; i++) { + try { + vExpressions[i].evaluate(vrg); + } catch (RuntimeException e) { + throw new HiveException("Error evaluating " + + conf.getColList().get(i).getExprString(), e); + } + } + + // Prepare output, set the projections + VectorExpressionWriter [] originalValueWriters = vrg.valueWriters; + vrg.setValueWriters(valueWriters); + int[] originalProjections = vrg.projectedColumns; + int originalProjectionSize = vrg.projectionSize; + vrg.projectionSize = vExpressions.length; + vrg.projectedColumns = this.projectedColumns; + forward(vrg, outputObjInspector); + + // Revert the projected columns back, because vrg will be re-used. + vrg.projectionSize = originalProjectionSize; + vrg.projectedColumns = originalProjections; + vrg.valueWriters = originalValueWriters; + } + + static public String getOperatorName() { + return "SEL"; + } + + public VectorExpression[] getvExpressions() { + return vExpressions; + } + + public VectorExpression[] getVExpressions() { + return vExpressions; + } + + public void setvExpressions(VectorExpression[] vExpressions) { + this.vExpressions = vExpressions; + } + + public void setVExpressions(VectorExpression[] vExpressions) { + this.vExpressions = vExpressions; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java new file mode 100644 index 0000000..02ebe14 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java @@ -0,0 +1,1585 @@ +/** + * 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.exec.vector; + +import java.lang.reflect.Constructor; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.ql.exec.ExprNodeEvaluator; +import org.apache.hadoop.hive.ql.exec.ExprNodeEvaluatorFactory; +import org.apache.hadoop.hive.ql.exec.FunctionInfo; +import org.apache.hadoop.hive.ql.exec.FunctionRegistry; +import org.apache.hadoop.hive.ql.exec.UDF; +import org.apache.hadoop.hive.ql.exec.vector.expressions.ConstantVectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterConstantBooleanVectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterExprAndExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterExprOrExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterStringColLikeStringScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.IdentityExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.SelectColumnIsNotNull; +import org.apache.hadoop.hive.ql.exec.vector.expressions.SelectColumnIsNull; +import org.apache.hadoop.hive.ql.exec.vector.expressions.SelectColumnIsTrue; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringConcatColCol; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringConcatColScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringConcatScalarCol; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringSubstrColStart; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringSubstrColStartLen; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFUnixTimeStampLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFCount; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFCountStar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxString; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMinDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMinLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMinString; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFStdPopDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFStdPopLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFStdSampDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFStdSampLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFSumDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFSumLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFVarPopDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFVarPopLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFVarSampDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFVarSampLong; +import org.apache.hadoop.hive.ql.exec.vector.udf.VectorUDFAdaptor; +import org.apache.hadoop.hive.ql.exec.vector.udf.VectorUDFArgDesc; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFConcat; +import org.apache.hadoop.hive.ql.udf.UDFDayOfMonth; +import org.apache.hadoop.hive.ql.udf.UDFHour; +import org.apache.hadoop.hive.ql.udf.UDFLTrim; +import org.apache.hadoop.hive.ql.udf.UDFLength; +import org.apache.hadoop.hive.ql.udf.UDFLike; +import org.apache.hadoop.hive.ql.udf.UDFMinute; +import org.apache.hadoop.hive.ql.udf.UDFMonth; +import org.apache.hadoop.hive.ql.udf.UDFOPDivide; +import org.apache.hadoop.hive.ql.udf.UDFOPMinus; +import org.apache.hadoop.hive.ql.udf.UDFOPMod; +import org.apache.hadoop.hive.ql.udf.UDFOPMultiply; +import org.apache.hadoop.hive.ql.udf.UDFOPNegative; +import org.apache.hadoop.hive.ql.udf.UDFOPPlus; +import org.apache.hadoop.hive.ql.udf.UDFOPPositive; +import org.apache.hadoop.hive.ql.udf.UDFRTrim; +import org.apache.hadoop.hive.ql.udf.UDFSecond; +import org.apache.hadoop.hive.ql.udf.UDFSubstr; +import org.apache.hadoop.hive.ql.udf.UDFTrim; +import org.apache.hadoop.hive.ql.udf.UDFWeekOfYear; +import org.apache.hadoop.hive.ql.udf.UDFYear; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFLower; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPAnd; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNot; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotNull; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNull; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPOr; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToUnixTimeStamp; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFUpper; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils; +import org.apache.hadoop.io.Text; + +/** + * Context class for vectorization execution. + * Main role is to map column names to column indices and serves as a + * factory class for building vectorized expressions out of descriptors. + * + */ +public class VectorizationContext { + private static final Log LOG = LogFactory.getLog( + VectorizationContext.class.getName()); + + //columnName to column position map + private final Map columnMap; + private final int firstOutputColumnIndex; + + private OperatorType opType; + //Map column number to type + private final OutputColumnManager ocm; + + public VectorizationContext(Map columnMap, + int initialOutputCol) { + this.columnMap = columnMap; + this.ocm = new OutputColumnManager(initialOutputCol); + this.firstOutputColumnIndex = initialOutputCol; + } + + private int getInputColumnIndex(String name) { + if (columnMap == null) { + //Null is treated as test call, is used for validation test. + return 0; + } else { + return columnMap.get(name); + } + } + + /* Return true if we are running in the planner, and false if we + * are running in a task. + */ + /* + private boolean isPlanner() { + + // This relies on the behavior that columnMap is null in the planner. + return columnMap == null; + } + */ + + private class OutputColumnManager { + private final int initialOutputCol; + private int outputColCount = 0; + + OutputColumnManager(int initialOutputCol) { + this.initialOutputCol = initialOutputCol; + } + + //The complete list of output columns. These should be added to the + //Vectorized row batch for processing. The index in the row batch is + //equal to the index in this array plus initialOutputCol. + //Start with size 100 and double when needed. + private String [] outputColumnsTypes = new String[100]; + + private final Set usedOutputColumns = new HashSet(); + + int allocateOutputColumn(String columnType) { + int relativeCol = allocateOutputColumnInternal(columnType); + return initialOutputCol + relativeCol; + } + + private int allocateOutputColumnInternal(String columnType) { + for (int i = 0; i < outputColCount; i++) { + if (usedOutputColumns.contains(i) || + !(outputColumnsTypes)[i].equalsIgnoreCase(columnType)) { + continue; + } + //Use i + usedOutputColumns.add(i); + return i; + } + //Out of allocated columns + if (outputColCount < outputColumnsTypes.length) { + int newIndex = outputColCount; + outputColumnsTypes[outputColCount++] = columnType; + usedOutputColumns.add(newIndex); + return newIndex; + } else { + //Expand the array + outputColumnsTypes = Arrays.copyOf(outputColumnsTypes, 2*outputColCount); + int newIndex = outputColCount; + outputColumnsTypes[outputColCount++] = columnType; + usedOutputColumns.add(newIndex); + return newIndex; + } + } + + void freeOutputColumn(int index) { + int colIndex = index-initialOutputCol; + if (colIndex >= 0) { + usedOutputColumns.remove(index-initialOutputCol); + } + } + } + + public void setOperatorType(OperatorType opType) { + this.opType = opType; + } + + private VectorExpression getVectorExpression(ExprNodeColumnDesc + exprDesc) { + int columnNum = getInputColumnIndex(exprDesc.getColumn()); + VectorExpression expr = null; + switch (opType) { + case FILTER: + //Important: It will come here only if the column is being used as a boolean + expr = new SelectColumnIsTrue(columnNum); + break; + case SELECT: + case GROUPBY: + case REDUCESINK: + expr = new IdentityExpression(columnNum, exprDesc.getTypeString()); + break; + } + return expr; + } + + public VectorExpression[] getVectorExpressions(List exprNodes) throws HiveException { + int i = 0; + if (null == exprNodes) { + return new VectorExpression[0]; + } + VectorExpression[] ret = new VectorExpression[exprNodes.size()]; + for (ExprNodeDesc e : exprNodes) { + ret[i++] = getVectorExpression(e); + } + return ret; + } + + /** + * Returns a vector expression for a given expression + * description. + * @param exprDesc, Expression description + * @return {@link VectorExpression} + * @throws HiveException + */ + public VectorExpression getVectorExpression(ExprNodeDesc exprDesc) throws HiveException { + VectorExpression ve = null; + if (exprDesc instanceof ExprNodeColumnDesc) { + ve = getVectorExpression((ExprNodeColumnDesc) exprDesc); + } else if (exprDesc instanceof ExprNodeGenericFuncDesc) { + ExprNodeGenericFuncDesc expr = (ExprNodeGenericFuncDesc) exprDesc; + if (isCustomUDF(expr)) { + ve = getCustomUDFExpression(expr); + } else { + ve = getVectorExpression(expr.getGenericUDF(), + expr.getChildExprs()); + } + } else if (exprDesc instanceof ExprNodeConstantDesc) { + ve = getConstantVectorExpression((ExprNodeConstantDesc) exprDesc); + } + if (ve == null) { + throw new HiveException("Could not vectorize expression: "+exprDesc.getName()); + } + return ve; + } + + // Return true if this is a custom UDF or custom GenericUDF. + // This is for use only in the planner. It will fail in a task. + public static boolean isCustomUDF(ExprNodeGenericFuncDesc expr) { + String udfName = expr.getFuncText(); + if (udfName == null) { + return false; + } + FunctionInfo funcInfo = FunctionRegistry.getFunctionInfo(udfName); + if (funcInfo == null) { + return false; + } + boolean isNativeFunc = funcInfo.isNative(); + return !isNativeFunc; + } + + /** + * Handles only the special case of unary operators on a constant. + * @param exprDesc + * @return The same expression if no folding done, else return the constant + * expression. + * @throws HiveException + */ + private ExprNodeDesc foldConstantsForUnaryExpression(ExprNodeDesc exprDesc) throws HiveException { + if (!(exprDesc instanceof ExprNodeGenericFuncDesc)) { + return exprDesc; + } + + if (exprDesc.getChildren() == null || (exprDesc.getChildren().size() != 1) || + (!( exprDesc.getChildren().get(0) instanceof ExprNodeConstantDesc))) { + return exprDesc; + } + + GenericUDF gudf = ((ExprNodeGenericFuncDesc) exprDesc).getGenericUDF(); + if (!(gudf instanceof GenericUDFBridge)) { + return exprDesc; + } + + Class cl = ((GenericUDFBridge) gudf).getUdfClass(); + + ExprNodeConstantDesc constExpr = (ExprNodeConstantDesc) exprDesc.getChildren().get(0); + + if (cl.equals(UDFOPNegative.class) || cl.equals(UDFOPPositive.class)) { + ExprNodeEvaluator evaluator = ExprNodeEvaluatorFactory.get(exprDesc); + ObjectInspector output = evaluator.initialize(null); + + Object constant = evaluator.evaluate(null); + Object java = ObjectInspectorUtils.copyToStandardJavaObject(constant, output); + return new ExprNodeConstantDesc(java); + } else { + return exprDesc; + } + } + + private VectorExpression getConstantVectorExpression(ExprNodeConstantDesc exprDesc) + throws HiveException { + String type = exprDesc.getTypeString(); + String colVectorType = this.getOutputColType(type, "constant"); + int outCol = ocm.allocateOutputColumn(colVectorType); + if (type.equalsIgnoreCase("long") || type.equalsIgnoreCase("int") || + type.equalsIgnoreCase("short") || type.equalsIgnoreCase("byte")) { + return new ConstantVectorExpression(outCol, + ((Number) exprDesc.getValue()).longValue()); + } else if (type.equalsIgnoreCase("double") || type.equalsIgnoreCase("float")) { + return new ConstantVectorExpression(outCol, ((Number) exprDesc.getValue()).doubleValue()); + } else if (type.equalsIgnoreCase("string")) { + return new ConstantVectorExpression(outCol, ((String) exprDesc.getValue()).getBytes()); + } else if (type.equalsIgnoreCase("boolean")) { + if (this.opType == OperatorType.FILTER) { + if (((Boolean) exprDesc.getValue()).booleanValue()) { + return new FilterConstantBooleanVectorExpression(1); + } else { + return new FilterConstantBooleanVectorExpression(0); + } + } else { + if (((Boolean) exprDesc.getValue()).booleanValue()) { + return new ConstantVectorExpression(outCol, 1); + } else { + return new ConstantVectorExpression(outCol, 0); + } + } + } else { + throw new HiveException("Unsupported constant type: "+type.toString()); + } + } + + private VectorExpression getUnaryMinusExpression(List childExprList) + throws HiveException { + ExprNodeDesc childExpr = childExprList.get(0); + int inputCol; + String colType; + VectorExpression v1 = null; + if (childExpr instanceof ExprNodeGenericFuncDesc) { + v1 = getVectorExpression(childExpr); + inputCol = v1.getOutputColumn(); + colType = v1.getOutputType(); + } else if (childExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) childExpr; + inputCol = getInputColumnIndex(colDesc.getColumn()); + colType = colDesc.getTypeString(); + } else { + throw new HiveException("Expression not supported: "+childExpr); + } + String outputColumnType = getNormalizedTypeName(colType); + int outputCol = ocm.allocateOutputColumn(outputColumnType); + String className = "org.apache.hadoop.hive.ql.exec.vector.expressions.gen." + + outputColumnType + "ColUnaryMinus"; + VectorExpression expr; + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol, outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + if (v1 != null) { + expr.setChildExpressions(new VectorExpression [] {v1}); + ocm.freeOutputColumn(v1.getOutputColumn()); + } + return expr; + } + + private VectorExpression getUnaryPlusExpression(List childExprList) + throws HiveException { + ExprNodeDesc childExpr = childExprList.get(0); + int inputCol; + String colType; + VectorExpression v1 = null; + if (childExpr instanceof ExprNodeGenericFuncDesc) { + v1 = getVectorExpression(childExpr); + inputCol = v1.getOutputColumn(); + colType = v1.getOutputType(); + } else if (childExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) childExpr; + inputCol = getInputColumnIndex(colDesc.getColumn()); + colType = colDesc.getTypeString(); + } else { + throw new HiveException("Expression not supported: "+childExpr); + } + VectorExpression expr = new IdentityExpression(inputCol, colType); + if (v1 != null) { + expr.setChildExpressions(new VectorExpression [] {v1}); + } + return expr; + } + + private VectorExpression getVectorExpression(GenericUDF udf, + List childExpr) throws HiveException { + if (udf instanceof GenericUDFOPLessThan) { + return getVectorBinaryComparisonFilterExpression("Less", childExpr); + } else if (udf instanceof GenericUDFOPEqualOrLessThan) { + return getVectorBinaryComparisonFilterExpression("LessEqual", childExpr); + } else if (udf instanceof GenericUDFOPEqual) { + return getVectorBinaryComparisonFilterExpression("Equal", childExpr); + } else if (udf instanceof GenericUDFOPGreaterThan) { + return getVectorBinaryComparisonFilterExpression("Greater", childExpr); + } else if (udf instanceof GenericUDFOPEqualOrGreaterThan) { + return getVectorBinaryComparisonFilterExpression("GreaterEqual", childExpr); + } else if (udf instanceof GenericUDFOPNotEqual) { + return getVectorBinaryComparisonFilterExpression("NotEqual", childExpr); + } else if (udf instanceof GenericUDFOPNotNull) { + return getVectorExpression((GenericUDFOPNotNull) udf, childExpr); + } else if (udf instanceof GenericUDFOPNull) { + return getVectorExpression((GenericUDFOPNull) udf, childExpr); + } else if (udf instanceof GenericUDFOPAnd) { + return getVectorExpression((GenericUDFOPAnd) udf, childExpr); + } else if (udf instanceof GenericUDFOPNot) { + return getVectorExpression((GenericUDFOPNot) udf, childExpr); + } else if (udf instanceof GenericUDFOPOr) { + return getVectorExpression((GenericUDFOPOr) udf, childExpr); + } else if (udf instanceof GenericUDFBridge) { + return getVectorExpression((GenericUDFBridge) udf, childExpr); + } else if(udf instanceof GenericUDFToUnixTimeStamp) { + return getVectorExpression((GenericUDFToUnixTimeStamp) udf, childExpr); + } else if (udf instanceof GenericUDFLower) { + return getUnaryStringExpression("StringLower", "String", childExpr); + } else if (udf instanceof GenericUDFUpper) { + return getUnaryStringExpression("StringUpper", "String", childExpr); + } else if (udf instanceof GenericUDFConcat) { + return getConcatExpression(childExpr); + } + + throw new HiveException("Udf: "+udf.getClass().getSimpleName()+", is not supported"); + } + + private VectorExpression getVectorExpression(GenericUDFToUnixTimeStamp udf, + List childExpr) throws HiveException { + ExprNodeDesc leftExpr = childExpr.get(0); + leftExpr = foldConstantsForUnaryExpression(leftExpr); + VectorExpression v1 = getVectorExpression(leftExpr); + String colType = v1.getOutputType(); + String outputType = "long"; + if(colType.equalsIgnoreCase("timestamp")) { + int inputCol = v1.getOutputColumn(); + int outputCol = ocm.allocateOutputColumn(outputType); + try { + VectorExpression v2 = new VectorUDFUnixTimeStampLong(inputCol, outputCol); + return v2; + } catch(Exception e) { + e.printStackTrace(); + throw new HiveException("Udf: Vector"+udf+", could not be initialized for " + colType, e); + } + } + throw new HiveException("Udf: "+udf.getClass().getSimpleName()+", is not supported"); + } + + private VectorExpression getVectorExpression(GenericUDFBridge udf, + List childExpr) throws HiveException { + Class cl = udf.getUdfClass(); + // (UDFBaseNumericOp.class.isAssignableFrom(cl)) == true + if (cl.equals(UDFOPPlus.class)) { + return getBinaryArithmeticExpression("Add", childExpr); + } else if (cl.equals(UDFOPMinus.class)) { + return getBinaryArithmeticExpression("Subtract", childExpr); + } else if (cl.equals(UDFOPMultiply.class)) { + return getBinaryArithmeticExpression("Multiply", childExpr); + } else if (cl.equals(UDFOPDivide.class)) { + return getBinaryArithmeticExpression("Divide", childExpr); + } else if (cl.equals(UDFOPMod.class)) { + return getBinaryArithmeticExpression("Modulo", childExpr); + } else if (cl.equals(UDFOPNegative.class)) { + return getUnaryMinusExpression(childExpr); + } else if (cl.equals(UDFOPPositive.class)) { + return getUnaryPlusExpression(childExpr); + } else if (cl.equals(UDFYear.class) || + cl.equals(UDFMonth.class) || + cl.equals(UDFWeekOfYear.class) || + cl.equals(UDFDayOfMonth.class) || + cl.equals(UDFHour.class) || + cl.equals(UDFMinute.class) || + cl.equals(UDFSecond.class)) { + return getTimestampFieldExpression(cl.getSimpleName(), childExpr); + } else if (cl.equals(UDFLike.class)) { + return getLikeExpression(childExpr); + } else if (cl.equals(UDFLength.class)) { + return getUnaryStringExpression("StringLength", "Long", childExpr); + } else if (cl.equals(UDFSubstr.class)) { + return getSubstrExpression(childExpr); + } else if (cl.equals(UDFLTrim.class)) { + return getUnaryStringExpression("StringLTrim", "String", childExpr); + } else if (cl.equals(UDFRTrim.class)) { + return getUnaryStringExpression("StringRTrim", "String", childExpr); + } else if (cl.equals(UDFTrim.class)) { + return getUnaryStringExpression("StringTrim", "String", childExpr); + } + + throw new HiveException("Udf: "+udf.getClass().getSimpleName()+", is not supported"); + } + + /* Return a vector expression for string concatenation, including the column-scalar, + * scalar-column, and column-column cases. + */ + private VectorExpression getConcatExpression(List childExprList) + throws HiveException { + ExprNodeDesc left = childExprList.get(0); + ExprNodeDesc right = childExprList.get(1); + int inputColLeft = -1; + int inputColRight = -1; + VectorExpression vLeft = null; + VectorExpression vRight = null; + VectorExpression expr = null; + + // Generate trees to evaluate non-leaf inputs, if there are any. + if (left instanceof ExprNodeGenericFuncDesc) { + vLeft = getVectorExpression(left); + inputColLeft = vLeft.getOutputColumn(); + } + + if (right instanceof ExprNodeGenericFuncDesc) { + vRight = getVectorExpression(right); + inputColRight = vRight.getOutputColumn(); + } + + // Handle case for left input a column and right input a constant + if ((left instanceof ExprNodeColumnDesc || inputColLeft != -1) && + right instanceof ExprNodeConstantDesc) { + if (inputColLeft == -1) { + inputColLeft = getInputColumnIndex(((ExprNodeColumnDesc) left).getColumn()); + } + int outputCol = ocm.allocateOutputColumn("String"); + byte[] constant = (byte[]) getScalarValue((ExprNodeConstantDesc) right); + expr = new StringConcatColScalar(inputColLeft, outputCol, constant); + if (vLeft != null) { + expr.setChildExpressions(new VectorExpression [] {vLeft}); + } + } + + // Handle case for left input a constant and right input a column + else if ((left instanceof ExprNodeConstantDesc) && + (right instanceof ExprNodeColumnDesc || inputColRight != -1)) { + if (inputColRight == -1) { + inputColRight = getInputColumnIndex(((ExprNodeColumnDesc) right).getColumn()); + } + int outputCol = ocm.allocateOutputColumn("String"); + byte[] constant = (byte[]) getScalarValue((ExprNodeConstantDesc) left); + expr = new StringConcatScalarCol(constant, inputColRight, outputCol); + if (vRight != null) { + expr.setChildExpressions(new VectorExpression [] {vRight}); + } + } + + // Handle case where both left and right inputs are columns + else if ((left instanceof ExprNodeColumnDesc || inputColLeft != -1) && + (right instanceof ExprNodeColumnDesc || inputColRight != -1)) { + if (inputColLeft == -1) { + inputColLeft = getInputColumnIndex(((ExprNodeColumnDesc) left).getColumn()); + } + if (inputColRight == -1) { + inputColRight = getInputColumnIndex(((ExprNodeColumnDesc) right).getColumn()); + } + int outputCol = ocm.allocateOutputColumn("String"); + expr = new StringConcatColCol(inputColLeft, inputColRight, outputCol); + if (vLeft == null && vRight != null) { + expr.setChildExpressions(new VectorExpression [] {vRight}); + } else if (vLeft != null && vRight == null) { + expr.setChildExpressions(new VectorExpression [] {vLeft}); + } else if (vLeft != null && vRight != null) { + + // Both left and right have child expressions + expr.setChildExpressions(new VectorExpression [] {vLeft, vRight}); + } + } else { + throw new HiveException("Failed to vectorize CONCAT()"); + } + + // Free output columns if inputs have non-leaf expression trees. + if (vLeft != null) { + ocm.freeOutputColumn(vLeft.getOutputColumn()); + } + if (vRight != null) { + ocm.freeOutputColumn(vRight.getOutputColumn()); + } + return expr; + } + + /* + * Return vector expression for a custom (i.e. not built-in) UDF. + */ + private VectorExpression getCustomUDFExpression(ExprNodeGenericFuncDesc expr) + throws HiveException { + + //GenericUDFBridge udfBridge = (GenericUDFBridge) expr.getGenericUDF(); + List childExprList = expr.getChildExprs(); + + // argument descriptors + VectorUDFArgDesc[] argDescs = new VectorUDFArgDesc[expr.getChildExprs().size()]; + for (int i = 0; i < argDescs.length; i++) { + argDescs[i] = new VectorUDFArgDesc(); + } + + // positions of variable arguments (columns or non-constant expressions) + List variableArgPositions = new ArrayList(); + + // Column numbers of batch corresponding to expression result arguments + List exprResultColumnNums = new ArrayList(); + + // Prepare children + List vectorExprs = new ArrayList(); + + for (int i = 0; i < childExprList.size(); i++) { + ExprNodeDesc child = childExprList.get(i); + if (child instanceof ExprNodeGenericFuncDesc) { + VectorExpression e = getVectorExpression(child); + vectorExprs.add(e); + variableArgPositions.add(i); + exprResultColumnNums.add(e.getOutputColumn()); + argDescs[i].setVariable(e.getOutputColumn()); + } else if (child instanceof ExprNodeColumnDesc) { + variableArgPositions.add(i); + argDescs[i].setVariable(getInputColumnIndex(((ExprNodeColumnDesc) child).getColumn())); + } else if (child instanceof ExprNodeConstantDesc) { + + // this is a constant + argDescs[i].setConstant((ExprNodeConstantDesc) child); + } else { + throw new HiveException("Unable to vectorize Custom UDF"); + } + } + + // Allocate output column and get column number; + int outputCol = -1; + String resultColVectorType; + String resultType = expr.getTypeInfo().getTypeName(); + if (resultType.equalsIgnoreCase("string")) { + resultColVectorType = "String"; + } else if (isIntFamily(resultType)) { + resultColVectorType = "Long"; + } else if (isFloatFamily(resultType)) { + resultColVectorType = "Double"; + } else if (resultType.equalsIgnoreCase("timestamp")) { + resultColVectorType = "Long"; + } else { + throw new HiveException("Unable to vectorize due to unsupported custom UDF return type " + + resultType); + } + outputCol = ocm.allocateOutputColumn(resultColVectorType); + + // Make vectorized operator + VectorExpression ve; + ve = new VectorUDFAdaptor(expr, outputCol, resultColVectorType, argDescs); + + // Set child expressions + VectorExpression[] childVEs = null; + if (exprResultColumnNums.size() != 0) { + childVEs = new VectorExpression[exprResultColumnNums.size()]; + for (int i = 0; i < childVEs.length; i++) { + childVEs[i] = vectorExprs.get(i); + } + } + ve.setChildExpressions(childVEs); + + // Free output columns if inputs have non-leaf expression trees. + for (Integer i : exprResultColumnNums) { + ocm.freeOutputColumn(i); + } + return ve; + } + + // return true if this is any kind of float + public static boolean isFloatFamily(String resultType) { + return resultType.equalsIgnoreCase("double") + || resultType.equalsIgnoreCase("float"); + } + + // Return true if this data type is handled in the output vector as an integer. + public static boolean isIntFamily(String resultType) { + return resultType.equalsIgnoreCase("tinyint") + || resultType.equalsIgnoreCase("smallint") + || resultType.equalsIgnoreCase("int") + || resultType.equalsIgnoreCase("bigint") + || resultType.equalsIgnoreCase("boolean"); + } + + /* Return a unary string vector expression. This is used for functions like + * UPPER() and LOWER(). + */ + private VectorExpression getUnaryStringExpression(String vectorExprClassName, + String resultType, // result type name + List childExprList) throws HiveException { + + /* Create an instance of the class vectorExprClassName for the input column or expression result + * and return it. + */ + + ExprNodeDesc childExpr = childExprList.get(0); + int inputCol; + VectorExpression v1 = null; + if (childExpr instanceof ExprNodeGenericFuncDesc) { + v1 = getVectorExpression(childExpr); + inputCol = v1.getOutputColumn(); + } else if (childExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) childExpr; + inputCol = getInputColumnIndex(colDesc.getColumn()); + } else { + // TODO? add code to handle constant argument case + throw new HiveException("Expression not supported: "+childExpr); + } + String outputColumnType = getNormalizedTypeName(resultType); + int outputCol = ocm.allocateOutputColumn(outputColumnType); + String className = "org.apache.hadoop.hive.ql.exec.vector.expressions." + + vectorExprClassName; + VectorExpression expr; + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol, outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + if (v1 != null) { + expr.setChildExpressions(new VectorExpression [] {v1}); + ocm.freeOutputColumn(v1.getOutputColumn()); + } + return expr; + } + + private VectorExpression getSubstrExpression( + List childExprList) throws HiveException { + + ExprNodeDesc childExpr = childExprList.get(0); + ExprNodeDesc startExpr = childExprList.get(1); + startExpr = foldConstantsForUnaryExpression(startExpr); + + // Get second and optionally third arguments + int start; + if (startExpr instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) startExpr; + start = ((Integer) constDesc.getValue()).intValue(); + } else { + throw new HiveException("Cannot vectorize non-constant start argument for SUBSTR"); + } + ExprNodeDesc lengthExpr = null; + int length = 0; + if (childExprList.size() == 3) { + lengthExpr = childExprList.get(2); + lengthExpr = foldConstantsForUnaryExpression(lengthExpr); + if (lengthExpr instanceof ExprNodeConstantDesc) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) lengthExpr; + length = ((Integer) constDesc.getValue()).intValue(); + } else { + throw new HiveException("Cannot vectorize non-constant length argument for SUBSTR"); + } + } + + // Prepare first argument (whether it is a column or an expression) + int inputCol; + VectorExpression v1 = null; + if (childExpr instanceof ExprNodeGenericFuncDesc) { + v1 = getVectorExpression(childExpr); + inputCol = v1.getOutputColumn(); + } else if (childExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) childExpr; + inputCol = getInputColumnIndex(colDesc.getColumn()); + } else { + throw new HiveException("Expression not supported: " + childExpr); + } + int outputCol = ocm.allocateOutputColumn("String"); + + // Create appropriate vector expression for 2 or 3 argument version of SUBSTR() + VectorExpression expr = null; + if (childExprList.size() == 2) { + expr = new StringSubstrColStart(inputCol, start, outputCol); + } else if (childExprList.size() == 3) { + expr = new StringSubstrColStartLen(inputCol, start, length, outputCol); + } else { + throw new HiveException("Invalid number of arguments for SUBSTR()"); + } + + if (v1 != null) { + expr.setChildExpressions(new VectorExpression [] {v1}); + ocm.freeOutputColumn(v1.getOutputColumn()); + } + return expr; + } + + private VectorExpression getLikeExpression(List childExpr) throws HiveException { + ExprNodeDesc leftExpr = childExpr.get(0); + ExprNodeDesc rightExpr = childExpr.get(1); + + VectorExpression v1 = null; + VectorExpression expr = null; + int inputCol; + ExprNodeConstantDesc constDesc; + + if ((leftExpr instanceof ExprNodeColumnDesc) && + (rightExpr instanceof ExprNodeConstantDesc) ) { + ExprNodeColumnDesc leftColDesc = (ExprNodeColumnDesc) leftExpr; + constDesc = (ExprNodeConstantDesc) rightExpr; + inputCol = getInputColumnIndex(leftColDesc.getColumn()); + expr = (VectorExpression) new FilterStringColLikeStringScalar(inputCol, + new Text((byte[]) getScalarValue(constDesc))); + } else if ((leftExpr instanceof ExprNodeGenericFuncDesc) && + (rightExpr instanceof ExprNodeConstantDesc)) { + v1 = getVectorExpression(leftExpr); + inputCol = v1.getOutputColumn(); + constDesc = (ExprNodeConstantDesc) rightExpr; + expr = (VectorExpression) new FilterStringColLikeStringScalar(inputCol, + new Text((byte[]) getScalarValue(constDesc))); + } + // TODO add logic to handle cases where left input is an expression. + if (expr == null) { + throw new HiveException("Vector LIKE filter expression could not be initialized"); + } + if (v1 != null) { + expr.setChildExpressions(new VectorExpression [] {v1}); + ocm.freeOutputColumn(v1.getOutputColumn()); + } + return expr; + } + + private VectorExpression getTimestampFieldExpression(String udf, + List childExpr) throws HiveException { + ExprNodeDesc leftExpr = childExpr.get(0); + leftExpr = foldConstantsForUnaryExpression(leftExpr); + VectorExpression v1 = getVectorExpression(leftExpr); + String colType = v1.getOutputType(); + String outputType = "long"; + if(colType.equalsIgnoreCase("timestamp")) { + int inputCol = v1.getOutputColumn(); + int outputCol = ocm.allocateOutputColumn(outputType); + String pkg = "org.apache.hadoop.hive.ql.exec.vector.expressions"; + // org.apache.hadoop.hive.ql.exec.vector.expressions.VectorUDFYearLong + String vectorUDF = pkg + ".Vector"+udf+"Long"; + try { + VectorExpression v2 = (VectorExpression) getConstructor(vectorUDF). + newInstance(inputCol,outputCol); + return v2; + } catch(Exception e) { + e.printStackTrace(); + throw new HiveException("Udf: Vector"+udf+", could not be initialized for " + colType, e); + } + } + throw new HiveException("Udf: "+udf+", is not supported for " + colType); + } + + private VectorExpression getBinaryArithmeticExpression(String method, + List childExpr) throws HiveException { + ExprNodeDesc leftExpr = childExpr.get(0); + ExprNodeDesc rightExpr = childExpr.get(1); + + // TODO: Remove this when constant folding is fixed in the optimizer. + leftExpr = foldConstantsForUnaryExpression(leftExpr); + rightExpr = foldConstantsForUnaryExpression(rightExpr); + + VectorExpression v1 = null; + VectorExpression v2 = null; + + VectorExpression expr = null; + if ( (leftExpr instanceof ExprNodeColumnDesc) && + (rightExpr instanceof ExprNodeConstantDesc) ) { + ExprNodeColumnDesc leftColDesc = (ExprNodeColumnDesc) leftExpr; + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) rightExpr; + int inputCol = getInputColumnIndex(leftColDesc.getColumn()); + String colType = leftColDesc.getTypeString(); + String scalarType = constDesc.getTypeString(); + String className = getBinaryColumnScalarExpressionClassName(colType, + scalarType, method); + int outputCol = ocm.allocateOutputColumn(getOutputColType(colType, + scalarType, method)); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol, + getScalarValue(constDesc), outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + } else if ( (leftExpr instanceof ExprNodeConstantDesc) && + (rightExpr instanceof ExprNodeColumnDesc) ) { + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) rightExpr; + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) leftExpr; + int inputCol = getInputColumnIndex(rightColDesc.getColumn()); + String colType = rightColDesc.getTypeString(); + String scalarType = constDesc.getTypeString(); + String className = getBinaryScalarColumnExpressionClassName(colType, + scalarType, method); + String outputColType = getOutputColType(colType, scalarType, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + try { + expr = (VectorExpression) getConstructor(className).newInstance(getScalarValue(constDesc), + inputCol, outputCol); + } catch (Exception ex) { + throw new HiveException("Could not instantiate: "+className, ex); + } + } else if ( (rightExpr instanceof ExprNodeColumnDesc) && + (leftExpr instanceof ExprNodeColumnDesc) ) { + ExprNodeColumnDesc leftColDesc = (ExprNodeColumnDesc) leftExpr; + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol1 = getInputColumnIndex(leftColDesc.getColumn()); + int inputCol2 = getInputColumnIndex(rightColDesc.getColumn()); + String colType1 = leftColDesc.getTypeString(); + String colType2 = rightColDesc.getTypeString(); + String outputColType = getOutputColType(colType1, colType2, method); + String className = getBinaryColumnColumnExpressionClassName(colType1, + colType2, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2, + outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + } else if ((leftExpr instanceof ExprNodeGenericFuncDesc) + && (rightExpr instanceof ExprNodeColumnDesc)) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) rightExpr; + v1 = getVectorExpression(leftExpr); + int inputCol1 = v1.getOutputColumn(); + int inputCol2 = getInputColumnIndex(colDesc.getColumn()); + String colType1 = v1.getOutputType(); + String colType2 = colDesc.getTypeString(); + String outputColType = getOutputColType(colType1, colType2, method); + String className = getBinaryColumnColumnExpressionClassName(colType1, + colType2, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2, + outputCol); + } catch (Exception ex) { + throw new HiveException((ex)); + } + expr.setChildExpressions(new VectorExpression [] {v1}); + } else if ((leftExpr instanceof ExprNodeGenericFuncDesc) + && (rightExpr instanceof ExprNodeConstantDesc)) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) rightExpr; + v1 = getVectorExpression(leftExpr); + int inputCol1 = v1.getOutputColumn(); + String colType1 = v1.getOutputType(); + String scalarType = constDesc.getTypeString(); + String outputColType = getOutputColType(colType1, scalarType, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + String className = getBinaryColumnScalarExpressionClassName(colType1, + scalarType, method); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, + getScalarValue(constDesc), outputCol); + } catch (Exception ex) { + throw new HiveException((ex)); + } + expr.setChildExpressions(new VectorExpression [] {v1}); + } else if ((leftExpr instanceof ExprNodeColumnDesc) + && (rightExpr instanceof ExprNodeGenericFuncDesc)) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) leftExpr; + v2 = getVectorExpression(rightExpr); + int inputCol1 = getInputColumnIndex(colDesc.getColumn()); + int inputCol2 = v2.getOutputColumn(); + String colType1 = colDesc.getTypeString(); + String colType2 = v2.getOutputType(); + String outputColType = getOutputColType(colType1, colType2, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + String className = getBinaryColumnColumnExpressionClassName(colType1, + colType2, method); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2, + outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v2}); + } else if ((leftExpr instanceof ExprNodeConstantDesc) + && (rightExpr instanceof ExprNodeGenericFuncDesc)) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) leftExpr; + v2 = getVectorExpression(rightExpr); + int inputCol2 = v2.getOutputColumn(); + String colType2 = v2.getOutputType(); + String scalarType = constDesc.getTypeString(); + String outputColType = getOutputColType(colType2, scalarType, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + String className = getBinaryScalarColumnExpressionClassName(colType2, + scalarType, method); + try { + expr = (VectorExpression) getConstructor(className).newInstance(getScalarValue(constDesc), + inputCol2, outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v2}); + } else if ((leftExpr instanceof ExprNodeGenericFuncDesc) + && (rightExpr instanceof ExprNodeGenericFuncDesc)) { + //For arithmetic expression, the child expressions must be materializing + //columns + v1 = getVectorExpression(leftExpr); + v2 = getVectorExpression(rightExpr); + int inputCol1 = v1.getOutputColumn(); + int inputCol2 = v2.getOutputColumn(); + String colType1 = v1.getOutputType(); + String colType2 = v2.getOutputType(); + String outputColType = getOutputColType(colType1, colType2, method); + int outputCol = ocm.allocateOutputColumn(outputColType); + String className = getBinaryColumnColumnExpressionClassName(colType1, + colType2, method); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2, + outputCol); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v1, v2}); + } + //Reclaim output columns of children to be re-used later + if (v1 != null) { + ocm.freeOutputColumn(v1.getOutputColumn()); + } + if (v2 != null) { + ocm.freeOutputColumn(v2.getOutputColumn()); + } + return expr; + } + + private VectorExpression getVectorExpression(GenericUDFOPOr udf, + List childExpr) throws HiveException { + ExprNodeDesc leftExpr = childExpr.get(0); + ExprNodeDesc rightExpr = childExpr.get(1); + + VectorExpression ve1; + VectorExpression ve2; + if (leftExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) leftExpr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + ve1 = new SelectColumnIsTrue(inputCol); + } else { + ve1 = getVectorExpression(leftExpr); + } + + if (rightExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + ve2 = new SelectColumnIsTrue(inputCol); + } else { + ve2 = getVectorExpression(rightExpr); + } + + return new FilterExprOrExpr(ve1,ve2); + } + + private VectorExpression getVectorExpression(GenericUDFOPNot udf, + List childExpr) throws HiveException { + throw new HiveException("Not is not supported"); + } + + private VectorExpression getVectorExpression(GenericUDFOPAnd udf, + List childExpr) throws HiveException { + + ExprNodeDesc leftExpr = childExpr.get(0); + ExprNodeDesc rightExpr = childExpr.get(1); + + VectorExpression ve1; + VectorExpression ve2; + if (leftExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) leftExpr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + ve1 = new SelectColumnIsTrue(inputCol); + } else { + ve1 = getVectorExpression(leftExpr); + } + + if (rightExpr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + ve2 = new SelectColumnIsTrue(inputCol); + } else { + ve2 = getVectorExpression(rightExpr); + } + + return new FilterExprAndExpr(ve1,ve2); + } + + private VectorExpression getVectorExpression(GenericUDFOPNull udf, + List childExpr) throws HiveException { + ExprNodeDesc expr = childExpr.get(0); + VectorExpression ve = null; + if (expr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) expr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + ve = new SelectColumnIsNull(inputCol); + } else { + throw new HiveException("Not supported"); + } + return ve; + } + + private VectorExpression getVectorExpression(GenericUDFOPNotNull udf, + List childExpr) throws HiveException { + ExprNodeDesc expr = childExpr.get(0); + if (expr instanceof ExprNodeColumnDesc) { + ExprNodeColumnDesc colDesc = (ExprNodeColumnDesc) expr; + int inputCol = getInputColumnIndex(colDesc.getColumn()); + VectorExpression ve = new SelectColumnIsNotNull(inputCol); + return ve; + } else { + throw new HiveException("Not supported"); + } + } + + private Object getScalarValue(ExprNodeConstantDesc constDesc) + throws HiveException { + if (constDesc.getTypeString().equalsIgnoreCase("String")) { + try { + byte[] bytes = ((String) constDesc.getValue()).getBytes("UTF-8"); + return bytes; + } catch (Exception ex) { + throw new HiveException(ex); + } + } else { + return constDesc.getValue(); + } + } + + private VectorExpression getVectorBinaryComparisonFilterExpression(String + opName, List childExpr) throws HiveException { + + ExprNodeDesc leftExpr = childExpr.get(0); + ExprNodeDesc rightExpr = childExpr.get(1); + + // TODO: Remove this when constant folding is fixed in the optimizer. + leftExpr = foldConstantsForUnaryExpression(leftExpr); + rightExpr = foldConstantsForUnaryExpression(rightExpr); + + VectorExpression expr = null; + VectorExpression v1 = null; + VectorExpression v2 = null; + if ( (leftExpr instanceof ExprNodeColumnDesc) && + (rightExpr instanceof ExprNodeConstantDesc) ) { + ExprNodeColumnDesc leftColDesc = (ExprNodeColumnDesc) leftExpr; + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) rightExpr; + int inputCol = getInputColumnIndex(leftColDesc.getColumn()); + String colType = leftColDesc.getTypeString(); + String scalarType = constDesc.getTypeString(); + String className = getFilterColumnScalarExpressionClassName(colType, + scalarType, opName); + try { + Constructor ctor = getConstructor(className); + expr = (VectorExpression) ctor.newInstance(inputCol, + getScalarValue(constDesc)); + } catch (Exception ex) { + throw new HiveException(ex); + } + } else if ((leftExpr instanceof ExprNodeConstantDesc) && + (rightExpr instanceof ExprNodeColumnDesc)) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) leftExpr; + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol = getInputColumnIndex(rightColDesc.getColumn()); + String colType = rightColDesc.getTypeString(); + String scalarType = constDesc.getTypeString(); + String className = getFilterScalarColumnExpressionClassName(colType, + scalarType, opName); + try { + //Constructor + expr = (VectorExpression) getConstructor(className).newInstance(inputCol, + getScalarValue(constDesc)); + } catch (Exception ex) { + throw new HiveException(ex); + } + } else if ( (rightExpr instanceof ExprNodeColumnDesc) && + (leftExpr instanceof ExprNodeColumnDesc) ) { + ExprNodeColumnDesc leftColDesc = (ExprNodeColumnDesc) leftExpr; + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol1 = getInputColumnIndex(leftColDesc.getColumn()); + int inputCol2 = getInputColumnIndex(rightColDesc.getColumn()); + String colType1 = leftColDesc.getTypeString(); + String colType2 = rightColDesc.getTypeString(); + String className = getFilterColumnColumnExpressionClassName(colType1, + colType2, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2); + } catch (Exception ex) { + throw new HiveException(ex); + } + } else if ( (leftExpr instanceof ExprNodeGenericFuncDesc) && + (rightExpr instanceof ExprNodeColumnDesc) ) { + v1 = getVectorExpression((ExprNodeGenericFuncDesc) leftExpr); + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) rightExpr; + int inputCol1 = v1.getOutputColumn(); + int inputCol2 = getInputColumnIndex(rightColDesc.getColumn()); + String colType1 = v1.getOutputType(); + String colType2 = rightColDesc.getTypeString(); + String className = getFilterColumnColumnExpressionClassName(colType1, + colType2, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v1}); + } else if ( (leftExpr instanceof ExprNodeColumnDesc) && + (rightExpr instanceof ExprNodeGenericFuncDesc) ) { + ExprNodeColumnDesc rightColDesc = (ExprNodeColumnDesc) leftExpr; + v2 = getVectorExpression((ExprNodeGenericFuncDesc) rightExpr); + int inputCol1 = getInputColumnIndex(rightColDesc.getColumn()); + int inputCol2 = v2.getOutputColumn(); + String colType1 = rightColDesc.getTypeString(); + String colType2 = v2.getOutputType(); + String className = getFilterColumnColumnExpressionClassName(colType1, + colType2, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v2}); + } else if ( (leftExpr instanceof ExprNodeGenericFuncDesc) && + (rightExpr instanceof ExprNodeConstantDesc) ) { + v1 = getVectorExpression((ExprNodeGenericFuncDesc) leftExpr); + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) rightExpr; + int inputCol1 = v1.getOutputColumn(); + String colType1 = v1.getOutputType(); + String scalarType = constDesc.getTypeString(); + String className = getFilterColumnScalarExpressionClassName(colType1, + scalarType, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, + getScalarValue(constDesc)); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v1}); + } else if ( (leftExpr instanceof ExprNodeConstantDesc) && + (rightExpr instanceof ExprNodeGenericFuncDesc) ) { + ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) leftExpr; + v2 = getVectorExpression((ExprNodeGenericFuncDesc) rightExpr); + int inputCol2 = v2.getOutputColumn(); + String scalarType = constDesc.getTypeString(); + String colType = v2.getOutputType(); + String className = getFilterScalarColumnExpressionClassName(colType, + scalarType, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol2, + getScalarValue(constDesc)); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v2}); + } else { + //For comparison expression, the child expressions must be materializing + //columns + v1 = getVectorExpression(leftExpr); + v2 = getVectorExpression(rightExpr); + int inputCol1 = v1.getOutputColumn(); + int inputCol2 = v2.getOutputColumn(); + String colType1 = v1.getOutputType(); + String colType2 = v2.getOutputType(); + String className = getFilterColumnColumnExpressionClassName(colType1, + colType2, opName); + try { + expr = (VectorExpression) getConstructor(className).newInstance(inputCol1, inputCol2); + } catch (Exception ex) { + throw new HiveException(ex); + } + expr.setChildExpressions(new VectorExpression [] {v1, v2}); + } + if (v1 != null) { + ocm.freeOutputColumn(v1.getOutputColumn()); + } + if (v2 != null) { + ocm.freeOutputColumn(v2.getOutputColumn()); + } + return expr; + } + + private Constructor getConstructor(String className) throws HiveException { + try { + Class cl = Class.forName(className); + Constructor [] ctors = cl.getDeclaredConstructors(); + Constructor defaultCtor = cl.getConstructor(); + for (Constructor ctor : ctors) { + if (!ctor.equals(defaultCtor)) { + return ctor; + } + } + throw new HiveException("Only default constructor found"); + } catch (Exception ex) { + throw new HiveException(ex); + } + } + + private String getNormalizedTypeName(String colType) throws HiveException { + validateInputType(colType); + String normalizedType = null; + if (colType.equalsIgnoreCase("Double") || colType.equalsIgnoreCase("Float")) { + normalizedType = "Double"; + } else if (colType.equalsIgnoreCase("String")) { + normalizedType = "String"; + } else { + normalizedType = "Long"; + } + return normalizedType; + } + + private String getFilterColumnColumnExpressionClassName(String colType1, + String colType2, String opName) throws HiveException { + StringBuilder b = new StringBuilder(); + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + if (opType.equals(OperatorType.FILTER)) { + b.append("Filter"); + } + b.append(getNormalizedTypeName(colType1)); + b.append("Col"); + b.append(opName); + b.append(getNormalizedTypeName(colType2)); + b.append("Column"); + return b.toString(); + } + + private String getFilterColumnScalarExpressionClassName(String colType, String + scalarType, String opName) throws HiveException { + StringBuilder b = new StringBuilder(); + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + if (opType.equals(OperatorType.FILTER)) { + b.append("Filter"); + } + b.append(getNormalizedTypeName(colType)); + b.append("Col"); + b.append(opName); + b.append(getNormalizedTypeName(scalarType)); + b.append("Scalar"); + return b.toString(); + } + + private String getFilterScalarColumnExpressionClassName(String colType, String + scalarType, String opName) throws HiveException { + StringBuilder b = new StringBuilder(); + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + if (opType.equals(OperatorType.FILTER)) { + b.append("Filter"); + } + b.append(getNormalizedTypeName(scalarType)); + b.append("Scalar"); + b.append(opName); + b.append(getNormalizedTypeName(colType)); + b.append("Column"); + return b.toString(); + } + + private String getBinaryColumnScalarExpressionClassName(String colType, + String scalarType, String method) throws HiveException { + StringBuilder b = new StringBuilder(); + String normColType = getNormalizedTypeName(colType); + String normScalarType = getNormalizedTypeName(scalarType); + if (normColType.equalsIgnoreCase("long") && normScalarType.equalsIgnoreCase("long") + && method.equalsIgnoreCase("divide")) { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions."); + } else { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + } + b.append(normColType); + b.append("Col"); + b.append(method); + b.append(normScalarType); + b.append("Scalar"); + return b.toString(); + } + + private String getBinaryScalarColumnExpressionClassName(String colType, + String scalarType, String method) throws HiveException { + StringBuilder b = new StringBuilder(); + String normColType = getNormalizedTypeName(colType); + String normScalarType = getNormalizedTypeName(scalarType); + if (normColType.equalsIgnoreCase("long") && normScalarType.equalsIgnoreCase("long") + && method.equalsIgnoreCase("divide")) { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions."); + } else { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + } + b.append(normScalarType); + b.append("Scalar"); + b.append(method); + b.append(normColType); + b.append("Column"); + return b.toString(); + } + + private String getBinaryColumnColumnExpressionClassName(String colType1, + String colType2, String method) throws HiveException { + StringBuilder b = new StringBuilder(); + String normColType1 = getNormalizedTypeName(colType1); + String normColType2 = getNormalizedTypeName(colType2); + if (normColType1.equalsIgnoreCase("long") && normColType2.equalsIgnoreCase("long") + && method.equalsIgnoreCase("divide")) { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions."); + } else { + b.append("org.apache.hadoop.hive.ql.exec.vector.expressions.gen."); + } + b.append(normColType1); + b.append("Col"); + b.append(method); + b.append(normColType2); + b.append("Column"); + return b.toString(); + } + + private String getOutputColType(String inputType1, String inputType2, String method) + throws HiveException { + validateInputType(inputType1); + validateInputType(inputType2); + if (method.equalsIgnoreCase("divide") || inputType1.equalsIgnoreCase("double") || + inputType2.equalsIgnoreCase("double") || inputType1.equalsIgnoreCase("float") || + inputType2.equalsIgnoreCase("float")) { + return "double"; + } else { + if (inputType1.equalsIgnoreCase("string") || inputType2.equalsIgnoreCase("string")) { + return "string"; + } else { + return "long"; + } + } + } + + private void validateInputType(String inputType) throws HiveException { + if (! (inputType.equalsIgnoreCase("float") || + inputType.equalsIgnoreCase("double") || + inputType.equalsIgnoreCase("string") || + inputType.equalsIgnoreCase("tinyint") || + inputType.equalsIgnoreCase("smallint") || + inputType.equalsIgnoreCase("short") || + inputType.equalsIgnoreCase("byte") || + inputType.equalsIgnoreCase("int") || + inputType.equalsIgnoreCase("long") || + inputType.equalsIgnoreCase("bigint") || + inputType.equalsIgnoreCase("boolean") || + inputType.equalsIgnoreCase("timestamp") ) ) { + throw new HiveException("Unsupported input type: "+inputType); + } + } + + private String getOutputColType(String inputType, String method) throws HiveException { + validateInputType(inputType); + if (inputType.equalsIgnoreCase("float") || inputType.equalsIgnoreCase("double")) { + return "double"; + } else if (inputType.equalsIgnoreCase("string")) { + return "string"; + } else { + return "long"; + } + } + + static Object[][] aggregatesDefinition = { + {"min", "Long", VectorUDAFMinLong.class}, + {"min", "Double", VectorUDAFMinDouble.class}, + {"min", "String", VectorUDAFMinString.class}, + {"max", "Long", VectorUDAFMaxLong.class}, + {"max", "Double", VectorUDAFMaxDouble.class}, + {"max", "String", VectorUDAFMaxString.class}, + {"count", null, VectorUDAFCountStar.class}, + {"count", "Long", VectorUDAFCount.class}, + {"count", "Double", VectorUDAFCount.class}, + {"count", "String", VectorUDAFCount.class}, + {"sum", "Long", VectorUDAFSumLong.class}, + {"sum", "Double", VectorUDAFSumDouble.class}, + {"avg", "Long", VectorUDAFAvgLong.class}, + {"avg", "Double", VectorUDAFAvgDouble.class}, + {"variance", "Long", VectorUDAFVarPopLong.class}, + {"var_pop", "Long", VectorUDAFVarPopLong.class}, + {"variance", "Double", VectorUDAFVarPopDouble.class}, + {"var_pop", "Double", VectorUDAFVarPopDouble.class}, + {"var_samp", "Long", VectorUDAFVarSampLong.class}, + {"var_samp" , "Double", VectorUDAFVarSampDouble.class}, + {"std", "Long", VectorUDAFStdPopLong.class}, + {"stddev", "Long", VectorUDAFStdPopLong.class}, + {"stddev_pop","Long", VectorUDAFStdPopLong.class}, + {"std", "Double", VectorUDAFStdPopDouble.class}, + {"stddev", "Double", VectorUDAFStdPopDouble.class}, + {"stddev_pop","Double", VectorUDAFStdPopDouble.class}, + {"stddev_samp","Long", VectorUDAFStdSampLong.class}, + {"stddev_samp","Double",VectorUDAFStdSampDouble.class}, + }; + + public VectorAggregateExpression getAggregatorExpression(AggregationDesc desc) + throws HiveException { + + ArrayList paramDescList = desc.getParameters(); + VectorExpression[] vectorParams = new VectorExpression[paramDescList.size()]; + + for (int i = 0; i< paramDescList.size(); ++i) { + ExprNodeDesc exprDesc = paramDescList.get(i); + vectorParams[i] = this.getVectorExpression(exprDesc); + } + + String aggregateName = desc.getGenericUDAFName(); + String inputType = null; + + if (paramDescList.size() > 0) { + ExprNodeDesc inputExpr = paramDescList.get(0); + inputType = getNormalizedTypeName(inputExpr.getTypeString()); + } + + for (Object[] aggDef : aggregatesDefinition) { + if (aggregateName.equalsIgnoreCase((String) aggDef[0]) && + ((aggDef[1] == null && inputType == null) || + (aggDef[1] != null && aggDef[1].equals(inputType)))) { + Class aggClass = + (Class) (aggDef[2]); + try + { + Constructor ctor = + aggClass.getConstructor(VectorExpression.class); + VectorAggregateExpression aggExpr = ctor.newInstance( + vectorParams.length > 0 ? vectorParams[0] : null); + aggExpr.init(desc); + return aggExpr; + } + // TODO: change to 1.7 syntax when possible + //catch (InvocationTargetException | IllegalAccessException + // | NoSuchMethodException | InstantiationException) + catch (Exception e) + { + throw new HiveException("Internal exception for vector aggregate : \"" + + aggregateName + "\" for type: \"" + inputType + "", e); + } + } + } + + throw new HiveException("Vector aggregate not implemented: \"" + aggregateName + + "\" for type: \"" + inputType + ""); + } + + static Object[][] columnTypes = { + {"Double", DoubleColumnVector.class}, + {"Long", LongColumnVector.class}, + {"String", BytesColumnVector.class}, + }; + + public Map getOutputColumnTypeMap() { + Map map = new HashMap(); + for (int i = 0; i < ocm.outputColCount; i++) { + String type = ocm.outputColumnsTypes[i]; + map.put(i+this.firstOutputColumnIndex, type); + } + return map; + } + + public ColumnVector allocateColumnVector(String type, int defaultSize) { + if (type.equalsIgnoreCase("double")) { + return new DoubleColumnVector(defaultSize); + } else if (type.equalsIgnoreCase("string")) { + return new BytesColumnVector(defaultSize); + } else { + return new LongColumnVector(defaultSize); + } + } + + + public void addToColumnMap(String columnName, int outputColumn) { + if (columnMap != null) { + columnMap.put(columnName, outputColumn); + } + } +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedBatchUtil.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedBatchUtil.java new file mode 100644 index 0000000..80bf671 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedBatchUtil.java @@ -0,0 +1,202 @@ +/** + * 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.exec.vector; + +import java.sql.Timestamp; +import java.util.List; + +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.io.ByteWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.io.ShortWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.StructField; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.FloatWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.Text; + +public class VectorizedBatchUtil { + + /** + * Sets the IsNull value for ColumnVector at specified index + * @param cv + * @param rowIndex + */ + public static void SetNullColIsNullValue(ColumnVector cv, int rowIndex) { + cv.isNull[rowIndex] = true; + if (cv.noNulls) { + cv.noNulls = false; + } + } + + /** + * Iterates thru all the column vectors and sets noNull to + * specified value. + * + * @param valueToSet + * noNull value to set + * @param batch + * Batch on which noNull is set + */ + public static void SetNoNullFields(boolean valueToSet, VectorizedRowBatch batch) { + for (int i = 0; i < batch.numCols; i++) { + batch.cols[i].noNulls = true; + } + } + + /** + * Iterates thru all the columns in a given row and populates the batch + * @param row Deserialized row object + * @param oi Object insepector for that row + * @param rowIndex index to which the row should be added to batch + * @param batch Vectorized batch to which the row is added at rowIndex + * @throws HiveException + */ + public static void AddRowToBatch(Object row, StructObjectInspector oi, int rowIndex, + VectorizedRowBatch batch) throws HiveException { + List fieldRefs = oi.getAllStructFieldRefs(); + // Iterate thru the cols and load the batch + for (int i = 0; i < fieldRefs.size(); i++) { + Object fieldData = oi.getStructFieldData(row, fieldRefs.get(i)); + ObjectInspector foi = fieldRefs.get(i).getFieldObjectInspector(); + + // Vectorization only supports PRIMITIVE data types. Assert the same + assert (foi.getCategory() == Category.PRIMITIVE); + + // Get writable object + PrimitiveObjectInspector poi = (PrimitiveObjectInspector) foi; + Object writableCol = poi.getPrimitiveWritableObject(fieldData); + + // NOTE: The default value for null fields in vectorization is 1 for int types, NaN for + // float/double. String types have no default value for null. + switch (poi.getPrimitiveCategory()) { + case BOOLEAN: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + lcv.vector[rowIndex] = ((BooleanWritable) writableCol).get() ? 1 : 0; + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case BYTE: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + lcv.vector[rowIndex] = ((ByteWritable) writableCol).get(); + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case SHORT: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + lcv.vector[rowIndex] = ((ShortWritable) writableCol).get(); + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case INT: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + lcv.vector[rowIndex] = ((IntWritable) writableCol).get(); + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case LONG: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + lcv.vector[rowIndex] = ((LongWritable) writableCol).get(); + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case FLOAT: { + DoubleColumnVector dcv = (DoubleColumnVector) batch.cols[i]; + if (writableCol != null) { + dcv.vector[rowIndex] = ((FloatWritable) writableCol).get(); + dcv.isNull[rowIndex] = false; + } else { + dcv.vector[rowIndex] = Double.NaN; + SetNullColIsNullValue(dcv, rowIndex); + } + } + break; + case DOUBLE: { + DoubleColumnVector dcv = (DoubleColumnVector) batch.cols[i]; + if (writableCol != null) { + dcv.vector[rowIndex] = ((DoubleWritable) writableCol).get(); + dcv.isNull[rowIndex] = false; + } else { + dcv.vector[rowIndex] = Double.NaN; + SetNullColIsNullValue(dcv, rowIndex); + } + } + break; + case TIMESTAMP: { + LongColumnVector lcv = (LongColumnVector) batch.cols[i]; + if (writableCol != null) { + Timestamp t = ((TimestampWritable) writableCol).getTimestamp(); + lcv.vector[rowIndex] = TimestampUtils.getTimeNanoSec(t); + lcv.isNull[rowIndex] = false; + } else { + lcv.vector[rowIndex] = 1; + SetNullColIsNullValue(lcv, rowIndex); + } + } + break; + case STRING: { + BytesColumnVector bcv = (BytesColumnVector) batch.cols[i]; + if (writableCol != null) { + bcv.isNull[rowIndex] = false; + Text colText = (Text) writableCol; + bcv.setRef(rowIndex, colText.getBytes(), 0, colText.getLength()); + } else { + SetNullColIsNullValue(bcv, rowIndex); + } + } + break; + default: + throw new HiveException("Vectorizaton is not supported for datatype:" + + poi.getPrimitiveCategory()); + } + } + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedColumnarSerDe.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedColumnarSerDe.java new file mode 100644 index 0000000..69553d9 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedColumnarSerDe.java @@ -0,0 +1,256 @@ +/** + * 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.exec.vector; + +import java.nio.ByteBuffer; +import java.sql.Timestamp; +import java.util.List; + +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.ByteStream; +import org.apache.hadoop.hive.serde2.SerDe; +import org.apache.hadoop.hive.serde2.SerDeException; +import org.apache.hadoop.hive.serde2.SerDeStats; +import org.apache.hadoop.hive.serde2.columnar.BytesRefArrayWritable; +import org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.lazy.LazyLong; +import org.apache.hadoop.hive.serde2.lazy.LazyTimestamp; +import org.apache.hadoop.hive.serde2.lazy.LazyUtils; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.StructField; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.io.ObjectWritable; +import org.apache.hadoop.io.Text; +import org.apache.hadoop.io.Writable; + +/** + * VectorizedColumnarSerDe is used by Vectorized query execution engine + * for columnar based storage supported by RCFile. + */ +public class VectorizedColumnarSerDe extends ColumnarSerDe implements VectorizedSerde { + + public VectorizedColumnarSerDe() throws SerDeException { + } + + private final BytesRefArrayWritable[] byteRefArray = new BytesRefArrayWritable[VectorizedRowBatch.DEFAULT_SIZE]; + private final ObjectWritable ow = new ObjectWritable(); + private final ByteStream.Output serializeVectorStream = new ByteStream.Output(); + + /** + * Serialize a vectorized row batch + * + * @param obj + * Vectorized row batch to serialize + * @param objInspector + * The ObjectInspector for the row object + * @return The serialized Writable object + * @throws SerDeException + * @see SerDe#serialize(Object, ObjectInspector) + */ + @Override + public Writable serializeVector(VectorizedRowBatch vrg, ObjectInspector objInspector) + throws SerDeException { + try { + // Validate that the OI is of struct type + if (objInspector.getCategory() != Category.STRUCT) { + throw new UnsupportedOperationException(getClass().toString() + + " can only serialize struct types, but we got: " + + objInspector.getTypeName()); + } + + VectorizedRowBatch batch = (VectorizedRowBatch) vrg; + StructObjectInspector soi = (StructObjectInspector) objInspector; + List fields = soi.getAllStructFieldRefs(); + + // Reset the byte buffer + serializeVectorStream.reset(); + int count = 0; + int rowIndex = 0; + for (int i = 0; i < batch.size; i++) { + + // If selectedInUse is true then we need to serialize only + // the selected indexes + if (batch.selectedInUse) { + rowIndex = batch.selected[i]; + } else { + rowIndex = i; + } + + BytesRefArrayWritable byteRow = byteRefArray[i]; + int numCols = fields.size(); + + if (byteRow == null) { + byteRow = new BytesRefArrayWritable(numCols); + byteRefArray[i] = byteRow; + } + + byteRow.resetValid(numCols); + + for (int p = 0; p < batch.projectionSize; p++) { + int k = batch.projectedColumns[p]; + ObjectInspector foi = fields.get(k).getFieldObjectInspector(); + ColumnVector currentColVector = batch.cols[k]; + + switch (foi.getCategory()) { + case PRIMITIVE: { + PrimitiveObjectInspector poi = (PrimitiveObjectInspector) foi; + if (!currentColVector.noNulls + && (currentColVector.isRepeating || currentColVector.isNull[rowIndex])) { + // The column is null hence write null value + serializeVectorStream.write(new byte[0], 0, 0); + } else { + // If here then the vector value is not null. + if (currentColVector.isRepeating) { + // If the vector has repeating values then set rowindex to zero + rowIndex = 0; + } + + switch (poi.getPrimitiveCategory()) { + case BOOLEAN: { + LongColumnVector lcv = (LongColumnVector) batch.cols[k]; + // In vectorization true is stored as 1 and false as 0 + boolean b = lcv.vector[rowIndex] == 1 ? true : false; + if (b) { + serializeVectorStream.write(LazyUtils.trueBytes, 0, LazyUtils.trueBytes.length); + } else { + serializeVectorStream.write(LazyUtils.trueBytes, 0, LazyUtils.trueBytes.length); + } + } + break; + case BYTE: + case SHORT: + case INT: + case LONG: + LongColumnVector lcv = (LongColumnVector) batch.cols[k]; + LazyLong.writeUTF8(serializeVectorStream, lcv.vector[rowIndex]); + break; + case FLOAT: + case DOUBLE: + DoubleColumnVector dcv = (DoubleColumnVector) batch.cols[k]; + ByteBuffer b = Text.encode(String.valueOf(dcv.vector[rowIndex])); + serializeVectorStream.write(b.array(), 0, b.limit()); + break; + case STRING: + BytesColumnVector bcv = (BytesColumnVector) batch.cols[k]; + LazyUtils.writeEscaped(serializeVectorStream, bcv.vector[rowIndex], + bcv.start[rowIndex], + bcv.length[rowIndex], + serdeParams.isEscaped(), serdeParams.getEscapeChar(), serdeParams + .getNeedsEscape()); + break; + case TIMESTAMP: + LongColumnVector tcv = (LongColumnVector) batch.cols[k]; + long timeInNanoSec = tcv.vector[rowIndex]; + Timestamp t = new Timestamp(0); + TimestampUtils.assignTimeInNanoSec(timeInNanoSec, t); + TimestampWritable tw = new TimestampWritable(); + tw.set(t); + LazyTimestamp.writeUTF8(serializeVectorStream, tw); + break; + default: + throw new UnsupportedOperationException( + "Vectorizaton is not supported for datatype:" + + poi.getPrimitiveCategory()); + } + } + break; + } + case LIST: + case MAP: + case STRUCT: + case UNION: + throw new UnsupportedOperationException("Vectorizaton is not supported for datatype:" + + foi.getCategory()); + default: + throw new SerDeException("Unknown ObjectInspector category!"); + + } + + byteRow.get(k).set(serializeVectorStream.getData(), count, serializeVectorStream + .getCount() - count); + count = serializeVectorStream.getCount(); + } + + } + ow.set(byteRefArray); + } catch (Exception e) { + throw new SerDeException(e); + } + return ow; + } + + @Override + public SerDeStats getSerDeStats() { + return null; + } + + @Override + public Class getSerializedClass() { + return BytesRefArrayWritable.class; + } + + @Override + public Object deserialize(Writable blob) throws SerDeException { + + // Ideally this should throw UnsupportedOperationException as the serde is + // vectorized serde. But since RC file reader does not support vectorized reading this + // is left as it is. This function will be called from VectorizedRowBatchCtx::AddRowToBatch + // to deserialize the row one by one and populate the batch. Once RC file reader supports vectorized + // reading this serde and be standalone serde with no dependency on ColumnarSerDe. + return super.deserialize(blob); + } + + @Override + public ObjectInspector getObjectInspector() throws SerDeException { + return cachedObjectInspector; + } + + @Override + public Writable serialize(Object obj, ObjectInspector objInspector) throws SerDeException { + throw new UnsupportedOperationException(); + } + + /** + * Deserializes the rowBlob into Vectorized row batch + * @param rowBlob + * rowBlob row batch to deserialize + * @param rowsInBlob + * Total number of rows in rowBlob to deserialize + * @param reuseBatch + * VectorizedRowBatch to which the rows should be serialized * + * @throws SerDeException + */ + @Override + public void deserializeVector(Object rowBlob, int rowsInBlob, + VectorizedRowBatch reuseBatch) throws SerDeException { + + BytesRefArrayWritable[] refArray = (BytesRefArrayWritable[]) rowBlob; + for (int i = 0; i < rowsInBlob; i++) { + Object row = deserialize(refArray[i]); + try { + VectorizedBatchUtil.AddRowToBatch(row, (StructObjectInspector) cachedObjectInspector, i, reuseBatch); + } catch (HiveException e) { + throw new SerDeException(e); + } + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedInputFormatInterface.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedInputFormatInterface.java new file mode 100644 index 0000000..8e81bb8 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedInputFormatInterface.java @@ -0,0 +1,27 @@ +/** + * 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.exec.vector; + +/** + * Marker interface to indicate a given input format supports + * vectorization input. + */ +public interface VectorizedInputFormatInterface { + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatch.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatch.java new file mode 100644 index 0000000..ff13f89 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatch.java @@ -0,0 +1,176 @@ +/** + * 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.exec.vector; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Writable; + +/** + * A VectorizedRowBatch is a set of rows, organized with each column + * as a vector. It is the unit of query execution, organized to minimize + * the cost per row and achieve high cycles-per-instruction. + * The major fields are public by design to allow fast and convenient + * access by the vectorized query execution code. + */ +public class VectorizedRowBatch implements Writable { + public int numCols; // number of columns + public ColumnVector[] cols; // a vector for each column + public int size; // number of rows that qualify (i.e. haven't been filtered out) + public int[] selected; // array of positions of selected values + public int[] projectedColumns; + public int projectionSize; + + /* + * If no filtering has been applied yet, selectedInUse is false, + * meaning that all rows qualify. If it is true, then the selected[] array + * records the offsets of qualifying rows. + */ + public boolean selectedInUse; + + // If this is true, then there is no data in the batch -- we have hit the end of input. + public boolean endOfFile; + + /* + * This number is carefully chosen to minimize overhead and typically allows + * one VectorizedRowBatch to fit in cache. + */ + public static final int DEFAULT_SIZE = 1024; + + public VectorExpressionWriter[] valueWriters = null; + + /** + * Return a batch with the specified number of columns. + * This is the standard constructor -- all batches should be the same size + * + * @param numCols the number of columns to include in the batch + */ + public VectorizedRowBatch(int numCols) { + this(numCols, DEFAULT_SIZE); + } + + /** + * Return a batch with the specified number of columns and rows. + * Only call this constructor directly for testing purposes. + * Batch size should normally always be defaultSize. + * + * @param numCols the number of columns to include in the batch + * @param size the number of rows to include in the batch + */ + public VectorizedRowBatch(int numCols, int size) { + this.numCols = numCols; + this.size = size; + selected = new int[size]; + selectedInUse = false; + this.cols = new ColumnVector[numCols]; + projectedColumns = new int[numCols]; + + // Initially all columns are projected and in the same order + projectionSize = numCols; + for (int i = 0; i < numCols; i++) { + projectedColumns[i] = i; + } + } + + /** + * Return count of qualifying rows. + * + * @return number of rows that have not been filtered out + */ + public long count() { + return size; + } + + private String toUTF8(Object o) { + if(o == null || o instanceof NullWritable) { + return "\\N"; /* as found in LazySimpleSerDe's nullSequence */ + } + return o.toString(); + } + + @Override + public String toString() { + if (size == 0) { + return ""; + } + StringBuilder b = new StringBuilder(); + try { + if (this.selectedInUse) { + for (int j = 0; j < size; j++) { + int i = selected[j]; + for (int k = 0; k < projectionSize; k++) { + int projIndex = projectedColumns[k]; + ColumnVector cv = cols[projIndex]; + if (k > 0) { + b.append('\u0001'); + } + if (cv.isRepeating) { + b.append(toUTF8(valueWriters[k].writeValue(cv, 0))); + } else { + b.append(toUTF8(valueWriters[k].writeValue(cv, i))); + } + } + if (j < size - 1) { + b.append('\n'); + } + } + } else { + for (int i = 0; i < size; i++) { + for (int k = 0; k < projectionSize; k++) { + int projIndex = projectedColumns[k]; + ColumnVector cv = cols[projIndex]; + if (k > 0) { + b.append('\u0001'); + } + if (cv.isRepeating) { + b.append(toUTF8(valueWriters[k].writeValue(cv, 0))); + } else { + b.append(toUTF8(valueWriters[k].writeValue(cv, i))); + } + } + if (i < size - 1) { + b.append('\n'); + } + } + } + } catch (HiveException ex) { + throw new RuntimeException(ex); + } + return b.toString(); + } + + @Override + public void readFields(DataInput arg0) throws IOException { + throw new UnsupportedOperationException("Do you really need me?"); + } + + @Override + public void write(DataOutput arg0) throws IOException { + throw new UnsupportedOperationException("Don't call me"); + } + + public void setValueWriters(VectorExpressionWriter[] valueWriters) { + this.valueWriters = valueWriters; + } +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatchCtx.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatchCtx.java new file mode 100644 index 0000000..f5a59f0 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedRowBatchCtx.java @@ -0,0 +1,364 @@ +/** + * 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.exec.vector; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.metastore.api.hive_metastoreConstants; +import org.apache.hadoop.hive.ql.exec.Utilities; +import org.apache.hadoop.hive.ql.io.HiveFileFormatUtils; +import org.apache.hadoop.hive.ql.io.IOPrepareCache; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.PartitionDesc; +import org.apache.hadoop.hive.serde2.ColumnProjectionUtils; +import org.apache.hadoop.hive.serde2.Deserializer; +import org.apache.hadoop.hive.serde2.SerDeException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.StructField; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.Writable; +import org.apache.hadoop.mapred.FileSplit; + +/** + * Context for Vectorized row batch. this calss does eager deserialization of row data using serde + * in the RecordReader layer. + * It has supports partitions in this layer so that the vectorized batch is populated correctly + * with the partition column. + */ +public class VectorizedRowBatchCtx { + + // OI for raw row data (EG without partition cols) + private StructObjectInspector rawRowOI; + + // OI for the row (Raw row OI + partition OI) + private StructObjectInspector rowOI; + + // Deserializer for the row data + private Deserializer deserializer; + + // Hash map of partition values. Key=TblColName value=PartitionValue + private Map partitionValues; + + // Column projection list - List of column indexes to include. This + // list does not contain partition columns + private List colsToInclude; + + private Map columnTypeMap = null; + + /** + * Constructor for VectorizedRowBatchCtx + * + * @param rawRowOI + * OI for raw row data (EG without partition cols) + * @param rowOI + * OI for the row (Raw row OI + partition OI) + * @param deserializer + * Deserializer for the row data + * @param partitionValues + * Hash map of partition values. Key=TblColName value=PartitionValue + */ + public VectorizedRowBatchCtx(StructObjectInspector rawRowOI, StructObjectInspector rowOI, + Deserializer deserializer, Map partitionValues) { + this.rowOI = rowOI; + this.rawRowOI = rawRowOI; + this.deserializer = deserializer; + this.partitionValues = partitionValues; + } + + /** + * Constructor for VectorizedRowBatchCtx + */ + public VectorizedRowBatchCtx() { + + } + + /** + * Initializes VectorizedRowBatch context based on the + * split and Hive configuration (Job conf with hive Plan). + * + * @param hiveConf + * Hive configuration using Hive plan is extracted + * @param split + * File split of the file being read + * @throws ClassNotFoundException + * @throws IOException + * @throws SerDeException + * @throws InstantiationException + * @throws IllegalAccessException + * @throws HiveException + */ + public void init(Configuration hiveConf, FileSplit split) throws ClassNotFoundException, + IOException, + SerDeException, + InstantiationException, + IllegalAccessException, HiveException { + + Map pathToPartitionInfo = Utilities + .getMapRedWork(hiveConf).getMapWork().getPathToPartitionInfo(); + + PartitionDesc part = HiveFileFormatUtils + .getPartitionDescFromPathRecursively(pathToPartitionInfo, + split.getPath(), IOPrepareCache.get().getPartitionDescMap()); + Class serdeclass = part.getDeserializerClass(); + + String partitionPath = split.getPath().getParent().toString(); + columnTypeMap = Utilities + .getMapRedWork(hiveConf).getMapWork().getScratchColumnVectorTypes() + .get(partitionPath); + + if (serdeclass == null) { + String className = part.getSerdeClassName(); + if ((className == null) || (className.isEmpty())) { + throw new HiveException( + "SerDe class or the SerDe class name is not set for table: " + + part.getProperties().getProperty("name")); + } + serdeclass = hiveConf.getClassByName(className); + } + + Properties partProps = + (part.getPartSpec() == null || part.getPartSpec().isEmpty()) ? + part.getTableDesc().getProperties() : part.getProperties(); + + Deserializer partDeserializer = (Deserializer) serdeclass.newInstance(); + partDeserializer.initialize(hiveConf, partProps); + StructObjectInspector partRawRowObjectInspector = (StructObjectInspector) partDeserializer + .getObjectInspector(); + + deserializer = partDeserializer; + + // Check to see if this split is part of a partition of a table + String pcols = partProps.getProperty(hive_metastoreConstants.META_TABLE_PARTITION_COLUMNS); + + if (pcols != null && pcols.length() > 0) { + + // Partitions exist for this table. Get the partition object inspector and + // raw row object inspector (row with out partition col) + LinkedHashMap partSpec = part.getPartSpec(); + String[] partKeys = pcols.trim().split("/"); + List partNames = new ArrayList(partKeys.length); + partitionValues = new LinkedHashMap(); + List partObjectInspectors = new ArrayList( + partKeys.length); + for (int i = 0; i < partKeys.length; i++) { + String key = partKeys[i]; + partNames.add(key); + if (partSpec == null) { + // for partitionless table, initialize partValue to empty string. + // We can have partitionless table even if we have partition keys + // when there is only only partition selected and the partition key is not + // part of the projection/include list. + partitionValues.put(key, ""); + } else { + partitionValues.put(key, partSpec.get(key)); + } + + partObjectInspectors + .add(PrimitiveObjectInspectorFactory.writableStringObjectInspector); + } + + // Create partition OI + StructObjectInspector partObjectInspector = ObjectInspectorFactory + .getStandardStructObjectInspector(partNames, partObjectInspectors); + + // Get row OI from partition OI and raw row OI + StructObjectInspector rowObjectInspector = ObjectInspectorFactory + .getUnionStructObjectInspector(Arrays + .asList(new StructObjectInspector[] {partRawRowObjectInspector, partObjectInspector})); + rowOI = rowObjectInspector; + rawRowOI = partRawRowObjectInspector; + } else { + + // No partitions for this table, hence row OI equals raw row OI + rowOI = partRawRowObjectInspector; + rawRowOI = partRawRowObjectInspector; + } + + colsToInclude = ColumnProjectionUtils.getReadColumnIDs(hiveConf); + } + + /** + * Creates a Vectorized row batch and the column vectors. + * + * @return VectorizedRowBatch + * @throws HiveException + */ + public VectorizedRowBatch createVectorizedRowBatch() throws HiveException + { + List fieldRefs = rowOI.getAllStructFieldRefs(); + VectorizedRowBatch result = new VectorizedRowBatch(fieldRefs.size()); + for (int j = 0; j < fieldRefs.size(); j++) { + // If the column is included in the include list or if the column is a + // partition column then create the column vector. Also note that partition columns are not + // in the included list. + if ((colsToInclude == null) || colsToInclude.contains(j) + || ((partitionValues != null) && + (partitionValues.get(fieldRefs.get(j).getFieldName()) != null))) { + ObjectInspector foi = fieldRefs.get(j).getFieldObjectInspector(); + switch (foi.getCategory()) { + case PRIMITIVE: { + PrimitiveObjectInspector poi = (PrimitiveObjectInspector) foi; + // Vectorization currently only supports the following data types: + // BOOLEAN, BYTE, SHORT, INT, LONG, FLOAT, DOUBLE, STRING and TIMESTAMP + switch (poi.getPrimitiveCategory()) { + case BOOLEAN: + case BYTE: + case SHORT: + case INT: + case LONG: + case TIMESTAMP: + result.cols[j] = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + break; + case FLOAT: + case DOUBLE: + result.cols[j] = new DoubleColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + break; + case STRING: + result.cols[j] = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + break; + default: + throw new RuntimeException("Vectorizaton is not supported for datatype:" + + poi.getPrimitiveCategory()); + } + break; + } + case LIST: + case MAP: + case STRUCT: + case UNION: + throw new HiveException("Vectorizaton is not supported for datatype:" + + foi.getCategory()); + default: + throw new HiveException("Unknown ObjectInspector category!"); + + } + } + } + result.numCols = fieldRefs.size(); + this.addScratchColumnsToBatch(result); + return result; + } + + /** + * Adds the row to the batch after deserializing the row + * + * @param rowIndex + * Row index in the batch to which the row is added + * @param rowBlob + * Row blob (serialized version of row) + * @param batch + * Vectorized batch to which the row is added + * @throws HiveException + * @throws SerDeException + */ + public void addRowToBatch(int rowIndex, Writable rowBlob, VectorizedRowBatch batch) + throws HiveException, SerDeException + { + Object row = this.deserializer.deserialize(rowBlob); + VectorizedBatchUtil.AddRowToBatch(row, this.rawRowOI, rowIndex, batch); + } + + /** + * Deserialized set of rows and populates the batch + * + * @param rowBlob + * to deserialize + * @param batch + * Vectorized row batch which contains deserialized data + * @throws SerDeException + */ + public void convertRowBatchBlobToVectorizedBatch(Object rowBlob, int rowsInBlob, + VectorizedRowBatch batch) + throws SerDeException { + + if (deserializer instanceof VectorizedSerde) { + ((VectorizedSerde) deserializer).deserializeVector(rowBlob, rowsInBlob, batch); + } else { + throw new SerDeException( + "Not able to deserialize row batch. Serde does not implement VectorizedSerde"); + } + } + + private int getColIndexBasedOnColName(String colName) throws HiveException + { + List fieldRefs = rowOI.getAllStructFieldRefs(); + for (int i = 0; i < fieldRefs.size(); i++) { + if (fieldRefs.get(i).getFieldName().equals(colName)) { + return i; + } + } + throw new HiveException("Not able to find column name in row object inspector"); + } + + /** + * Add the partition values to the batch + * + * @param batch + * @throws HiveException + */ + public void addPartitionColsToBatch(VectorizedRowBatch batch) throws HiveException + { + int colIndex; + String value; + BytesColumnVector bcv; + if (partitionValues != null) { + for (String key : partitionValues.keySet()) { + colIndex = getColIndexBasedOnColName(key); + value = partitionValues.get(key); + bcv = (BytesColumnVector) batch.cols[colIndex]; + bcv.setRef(0, value.getBytes(), 0, value.length()); + bcv.isRepeating = true; + bcv.isNull[0] = false; + bcv.noNulls = true; + } + } + } + + private void addScratchColumnsToBatch(VectorizedRowBatch vrb) { + if (columnTypeMap != null && !columnTypeMap.isEmpty()) { + int origNumCols = vrb.numCols; + int newNumCols = vrb.cols.length+columnTypeMap.keySet().size(); + vrb.cols = Arrays.copyOf(vrb.cols, newNumCols); + for (int i = origNumCols; i < newNumCols; i++) { + vrb.cols[i] = allocateColumnVector(columnTypeMap.get(i), + VectorizedRowBatch.DEFAULT_SIZE); + } + vrb.numCols = vrb.cols.length; + } + } + + private ColumnVector allocateColumnVector(String type, int defaultSize) { + if (type.equalsIgnoreCase("double")) { + return new DoubleColumnVector(defaultSize); + } else if (type.equalsIgnoreCase("string")) { + return new BytesColumnVector(defaultSize); + } else { + return new LongColumnVector(defaultSize); + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedSerde.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedSerde.java new file mode 100644 index 0000000..bff6200 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizedSerde.java @@ -0,0 +1,35 @@ +/** + * 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.exec.vector; + +import org.apache.hadoop.hive.serde2.SerDeException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.io.Writable; + +/** + * Serdes that support vectorized {@link VectorizedRowBatch} must implement this interface. + */ +public interface VectorizedSerde { + + Writable serializeVector(VectorizedRowBatch vrg, ObjectInspector objInspector) + throws SerDeException; + + void deserializeVector(Object rowBlob, int rowsInBlob, VectorizedRowBatch reuseBatch) + throws SerDeException; +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColAndCol.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColAndCol.java new file mode 100644 index 0000000..a6cde8e --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColAndCol.java @@ -0,0 +1,167 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Evaluate AND of two boolean columns and store result in the output boolean column. + */ +public class ColAndCol extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum1; + private int colNum2; + private int outputColumn; + + public ColAndCol(int colNum1, int colNum2, int outputColumn) { + this(); + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + } + + public ColAndCol() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; + LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector1 = inputColVector1.vector; + long[] vector2 = inputColVector2.vector; + + LongColumnVector outV = (LongColumnVector) batch.cols[outputColumn]; + long[] outputVector = outV.vector; + if (n <= 0) { + // Nothing to do + return; + } + + // Handle null + if (inputColVector1.noNulls && !inputColVector2.noNulls) { + outV.noNulls = false; + if (inputColVector2.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = true; + } else { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inputColVector2.isNull[i]; + } + } else { + for (int i = 0; i != n; i++) { + outV.isNull[i] = inputColVector2.isNull[i]; + } + } + } + } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { + outV.noNulls = false; + if (inputColVector1.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = true; + } else { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inputColVector1.isNull[i]; + } + } else { + for (int i = 0; i != n; i++) { + outV.isNull[i] = inputColVector1.isNull[i]; + } + } + } + } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { + outV.noNulls = false; + if (inputColVector1.isRepeating || inputColVector2.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = true; + } else { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inputColVector1.isNull[i] && inputColVector2.isNull[i]; + } + } else { + for (int i = 0; i != n; i++) { + outV.isNull[i] = inputColVector1.isNull[i] && inputColVector2.isNull[i]; + } + } + } + } + + // Now disregard null in second pass. + if ((inputColVector1.isRepeating) && (inputColVector2.isRepeating)) { + // All must be selected otherwise size would be zero + // Repeating property will not change. + outV.isRepeating = true; + outputVector[0] = vector1[0] & vector2[0]; + } else if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] & vector2[i]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] & vector2[i]; + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColOrCol.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColOrCol.java new file mode 100644 index 0000000..b57a844 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ColOrCol.java @@ -0,0 +1,315 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class performs OR expression on two input columns and stores, + * the boolean output in a separate output column. The boolean values + * are supposed to be represented as 0/1 in a long vector. + */ +public class ColOrCol extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum1; + private int colNum2; + private int outputColumn; + + public ColOrCol(int colNum1, int colNum2, int outputColumn) { + this(); + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + } + + public ColOrCol() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; + LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector1 = inputColVector1.vector; + long[] vector2 = inputColVector2.vector; + + LongColumnVector outV = (LongColumnVector) batch.cols[outputColumn]; + long[] outputVector = outV.vector; + if (n <= 0) { + // Nothing to do + return; + } + + if (inputColVector1.noNulls && inputColVector2.noNulls) { + if ((inputColVector1.isRepeating) && (inputColVector2.isRepeating)) { + // All must be selected otherwise size would be zero + // Repeating property will not change. + outV.isRepeating = true; + outputVector[0] = vector1[0] | vector2[0]; + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] | vector2[i]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[0] | vector2[i]; + } + } + outV.isRepeating = false; + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[0]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[0]; + } + } + outV.isRepeating = false; + } else /* neither side is repeating */{ + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[i]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[i]; + } + } + outV.isRepeating = false; + } + outV.noNulls = true; + } else if (inputColVector1.noNulls && !inputColVector2.noNulls) { + // only input 2 side has nulls + if ((inputColVector1.isRepeating) && (inputColVector2.isRepeating)) { + // All must be selected otherwise size would be zero + // Repeating property will not change. + outV.isRepeating = true; + outputVector[0] = vector1[0] | vector2[0]; + outV.isNull[0] = (vector1[0] == 0) && inputColVector2.isNull[0]; + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = (vector1[0] == 0) && inputColVector2.isNull[i]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = (vector1[0] == 0) && inputColVector2.isNull[i]; + } + } + outV.isRepeating = false; + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = (vector1[i] == 0) && inputColVector2.isNull[0]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = (vector1[i] == 0) && inputColVector2.isNull[0]; + } + } + outV.isRepeating = false; + } else /* neither side is repeating */{ + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = (vector1[i] == 0) && inputColVector2.isNull[i]; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = (vector1[i] == 0) && inputColVector2.isNull[i]; + } + } + outV.isRepeating = false; + } + outV.noNulls = false; + } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { + // only input 1 side has nulls + if ((inputColVector1.isRepeating) && (inputColVector2.isRepeating)) { + // All must be selected otherwise size would be zero + // Repeating property will not change. + outV.isRepeating = true; + outputVector[0] = vector1[0] | vector2[0]; + outV.isNull[0] = inputColVector1.isNull[0] && (vector2[0] == 0); + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = inputColVector1.isNull[0] && (vector2[i] == 0); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = inputColVector1.isNull[0] && (vector2[i] == 0); + } + } + outV.isRepeating = false; + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = inputColVector1.isNull[i] && (vector2[0] == 0); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = inputColVector1.isNull[i] && (vector2[0] == 0); + } + } + outV.isRepeating = false; + } else /* neither side is repeating */{ + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = inputColVector1.isNull[i] && (vector2[i] == 0); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = inputColVector1.isNull[i] && (vector2[i] == 0); + } + } + outV.isRepeating = false; + } + outV.noNulls = false; + } else /* !inputColVector1.noNulls && !inputColVector2.noNulls */{ + // either input 1 or input 2 may have nulls + if ((inputColVector1.isRepeating) && (inputColVector2.isRepeating)) { + // All must be selected otherwise size would be zero + // Repeating property will not change. + outV.isRepeating = true; + outputVector[0] = vector1[0] | vector2[0]; + outV.isNull[0] = ((vector1[0] == 0) && inputColVector2.isNull[0]) + || (inputColVector1.isNull[0] && (vector2[0] == 0)) + || (inputColVector1.isNull[0] && inputColVector2.isNull[0]); + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = ((vector1[0] == 0) && inputColVector2.isNull[i]) + || (inputColVector1.isNull[0] && (vector2[i] == 0)) + || (inputColVector1.isNull[0] && inputColVector2.isNull[i]); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[0] | vector2[i]; + outV.isNull[i] = ((vector1[0] == 0) && inputColVector2.isNull[i]) + || (inputColVector1.isNull[0] && (vector2[i] == 0)) + || (inputColVector1.isNull[0] && inputColVector2.isNull[i]); + } + } + outV.isRepeating = false; + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = ((vector1[i] == 0) && inputColVector2.isNull[0]) + || (inputColVector1.isNull[i] && (vector2[0] == 0)) + || (inputColVector1.isNull[i] && inputColVector2.isNull[0]); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[0]; + outV.isNull[i] = ((vector1[i] == 0) && inputColVector2.isNull[0]) + || (inputColVector1.isNull[i] && (vector2[0] == 0)) + || (inputColVector1.isNull[i] && inputColVector2.isNull[0]); + } + } + outV.isRepeating = false; + } else /* neither side is repeating */{ + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = ((vector1[i] == 0) && inputColVector2.isNull[i]) + || (inputColVector1.isNull[i] && (vector2[i] == 0)) + || (inputColVector1.isNull[i] && inputColVector2.isNull[i]); + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = vector1[i] | vector2[i]; + outV.isNull[i] = ((vector1[i] == 0) && inputColVector2.isNull[i]) + || (inputColVector1.isNull[i] && (vector2[i] == 0)) + || (inputColVector1.isNull[i] && inputColVector2.isNull[i]); + } + } + outV.isRepeating = false; + } + outV.noNulls = false; + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ConstantVectorExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ConstantVectorExpression.java new file mode 100644 index 0000000..f464f04 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/ConstantVectorExpression.java @@ -0,0 +1,162 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Constant is represented as a vector with repeating values. + */ +public class ConstantVectorExpression extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private static enum Type { + LONG, + DOUBLE, + BYTES + } + + private int outputColumn; + protected long longValue = 0; + private double doubleValue = 0; + private byte[] bytesValue = null; + private String typeString; + + private transient Type type; + private transient int bytesValueLength = 0; + + public ConstantVectorExpression() { + super(); + } + + ConstantVectorExpression(int outputColumn, String typeString) { + this(); + this.outputColumn = outputColumn; + setTypeString(typeString); + } + + public ConstantVectorExpression(int outputColumn, long value) { + this(outputColumn, "long"); + this.longValue = value; + } + + public ConstantVectorExpression(int outputColumn, double value) { + this(outputColumn, "double"); + this.doubleValue = value; + } + + public ConstantVectorExpression(int outputColumn, byte[] value) { + this(outputColumn, "string"); + setBytesValue(value); + } + + private void evaluateLong(VectorizedRowBatch vrg) { + LongColumnVector cv = (LongColumnVector) vrg.cols[outputColumn]; + cv.isRepeating = true; + cv.noNulls = true; + cv.vector[0] = longValue; + } + + private void evaluateDouble(VectorizedRowBatch vrg) { + DoubleColumnVector cv = (DoubleColumnVector) vrg.cols[outputColumn]; + cv.isRepeating = true; + cv.noNulls = true; + cv.vector[0] = doubleValue; + } + + private void evaluateBytes(VectorizedRowBatch vrg) { + BytesColumnVector cv = (BytesColumnVector) vrg.cols[outputColumn]; + cv.isRepeating = true; + cv.noNulls = true; + cv.setRef(0, bytesValue, 0, bytesValueLength); + } + + @Override + public void evaluate(VectorizedRowBatch vrg) { + switch (type) { + case LONG: + evaluateLong(vrg); + break; + case DOUBLE: + evaluateDouble(vrg); + break; + case BYTES: + evaluateBytes(vrg); + break; + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return getTypeString(); + } + + public long getLongValue() { + return longValue; + } + + public void setLongValue(long longValue) { + this.longValue = longValue; + } + + public double getDoubleValue() { + return doubleValue; + } + + public void setDoubleValue(double doubleValue) { + this.doubleValue = doubleValue; + } + + public byte[] getBytesValue() { + return bytesValue; + } + + public void setBytesValue(byte[] bytesValue) { + this.bytesValue = bytesValue; + this.bytesValueLength = bytesValue.length; + } + + public String getTypeString() { + return typeString; + } + + public void setTypeString(String typeString) { + this.typeString = typeString; + if ("string".equalsIgnoreCase(typeString)) { + this.type = Type.BYTES; + } else if ("double".equalsIgnoreCase(typeString)) { + this.type = Type.DOUBLE; + } else { + this.type = Type.LONG; + } + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterConstantBooleanVectorExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterConstantBooleanVectorExpression.java new file mode 100644 index 0000000..ddb7a8e --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterConstantBooleanVectorExpression.java @@ -0,0 +1,42 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +public class FilterConstantBooleanVectorExpression extends ConstantVectorExpression { + + private static final long serialVersionUID = 1L; + + public FilterConstantBooleanVectorExpression() { + super(); + } + + public FilterConstantBooleanVectorExpression(long value) { + super(-1, value); + } + + @Override + public void evaluate(VectorizedRowBatch vrg) { + if (longValue == 0) { + // All values are filtered out + vrg.size = 0; + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprAndExpr.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprAndExpr.java new file mode 100644 index 0000000..e6b511d --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprAndExpr.java @@ -0,0 +1,56 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class represents a non leaf binary operator in the expression tree. + */ +public class FilterExprAndExpr extends VectorExpression { + + private static final long serialVersionUID = 1L; + + public FilterExprAndExpr(VectorExpression childExpr1, VectorExpression childExpr2) { + this(); + this.childExpressions = new VectorExpression[2]; + childExpressions[0] = childExpr1; + childExpressions[1] = childExpr2; + } + + public FilterExprAndExpr() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + childExpressions[0].evaluate(batch); + childExpressions[1].evaluate(batch); + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprOrExpr.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprOrExpr.java new file mode 100644 index 0000000..703096c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterExprOrExpr.java @@ -0,0 +1,129 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class represents an Or expression. This applies short circuit optimization. + */ +public class FilterExprOrExpr extends VectorExpression { + private static final long serialVersionUID = 1L; + private transient final int[] initialSelected = new int[VectorizedRowBatch.DEFAULT_SIZE]; + private transient int[] unselected = new int[VectorizedRowBatch.DEFAULT_SIZE]; + private transient final int[] tmp = new int[VectorizedRowBatch.DEFAULT_SIZE]; + + public FilterExprOrExpr(VectorExpression childExpr1, VectorExpression childExpr2) { + this(); + this.childExpressions = new VectorExpression[2]; + childExpressions[0] = childExpr1; + childExpressions[1] = childExpr2; + } + + public FilterExprOrExpr() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + int n = batch.size; + if (n <= 0) { + return; + } + + VectorExpression childExpr1 = this.childExpressions[0]; + VectorExpression childExpr2 = this.childExpressions[1]; + + boolean prevSelectInUse = batch.selectedInUse; + + // Save the original selected vector + int[] sel = batch.selected; + if (batch.selectedInUse) { + System.arraycopy(sel, 0, initialSelected, 0, n); + } else { + for (int i = 0; i < n; i++) { + initialSelected[i] = i; + sel[i] = i; + } + batch.selectedInUse = true; + } + + childExpr1.evaluate(batch); + + // Preserve the selected reference and size values generated + // after the first child is evaluated. + int sizeAfterFirstChild = batch.size; + int[] selectedAfterFirstChild = batch.selected; + + // Calculate unselected ones in last evaluate. + for (int j = 0; j < n; j++) { + tmp[initialSelected[j]] = 0; + } + for (int j = 0; j < batch.size; j++) { + tmp[selectedAfterFirstChild[j]] = 1; + } + int unselectedSize = 0; + for (int j = 0; j < n; j++) { + int i = initialSelected[j]; + if (tmp[i] == 0) { + unselected[unselectedSize++] = i; + } + } + + // Evaluate second child expression over unselected ones only. + batch.selected = unselected; + batch.size = unselectedSize; + + childExpr2.evaluate(batch); + + // Merge the result of last evaluate to previous evaluate. + int newSize = batch.size + sizeAfterFirstChild; + for (int i = 0; i < batch.size; i++) { + tmp[batch.selected[i]] = 1; + } + int k = 0; + for (int j = 0; j < n; j++) { + int i = initialSelected[j]; + if (tmp[i] == 1) { + batch.selected[k++] = i; + } + } + + + batch.size = newSize; + if (newSize == n) { + // Filter didn't do anything + batch.selectedInUse = prevSelectInUse; + } + + // unselected array is taken away by the row batch + // so take the row batch's original one. + unselected = selectedAfterFirstChild; + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterNotExpr.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterNotExpr.java new file mode 100644 index 0000000..cdf404c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterNotExpr.java @@ -0,0 +1,99 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class represents an NOT filter expression. This applies short circuit optimization. + */ +public class FilterNotExpr extends VectorExpression { + private static final long serialVersionUID = 1L; + private transient final int[] initialSelected = new int[VectorizedRowBatch.DEFAULT_SIZE]; + private transient int[] unselected = new int[VectorizedRowBatch.DEFAULT_SIZE]; + private transient final int[] tmp = new int[VectorizedRowBatch.DEFAULT_SIZE]; + + public FilterNotExpr(VectorExpression childExpr1) { + this(); + this.childExpressions = new VectorExpression[] {childExpr1}; + } + + public FilterNotExpr() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + int n = batch.size; + + if (n <= 0) { + return; + } + + // Clone the selected vector + int[] sel = batch.selected; + if (batch.selectedInUse) { + System.arraycopy(sel, 0, initialSelected, 0, n); + } else { + for (int i = 0; i < n; i++) { + initialSelected[i] = i; + sel[i] = i; + } + batch.selectedInUse = true; + } + + VectorExpression childExpr1 = this.childExpressions[0]; + childExpr1.evaluate(batch); + + // Calculate unselected ones in last evaluate. + for (int i = 0; i < n; i++) { + tmp[initialSelected[i]] = 0; + } + + // Need to set sel reference again, because the child expression might + // have invalidated the earlier reference + sel = batch.selected; + for (int j = 0; j < batch.size; j++) { + int i = sel[j]; + tmp[i] = 1; + } + int unselectedSize = 0; + for (int j = 0; j < n; j++) { + int i = initialSelected[j]; + if (tmp[i] == 0) { + unselected[unselectedSize++] = i; + } + } + + // The unselected is the new selected, swap the arrays + batch.selected = unselected; + unselected = sel; + batch.size = unselectedSize; + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterStringColLikeStringScalar.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterStringColLikeStringScalar.java new file mode 100644 index 0000000..f26c211 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/FilterStringColLikeStringScalar.java @@ -0,0 +1,569 @@ +/** + * 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.exec.vector.expressions; + +import static org.apache.hadoop.hive.ql.udf.UDFLike.likePatternToRegExp; + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.CharsetDecoder; +import java.nio.charset.CodingErrorAction; +import java.util.regex.Pattern; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.io.Text; + +/** + * Evaluate LIKE filter on a batch for a vector of strings. + */ +public class FilterStringColLikeStringScalar extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private Pattern compiledPattern; + private PatternType type = PatternType.NONE; + private String simpleStringPattern; + private final Text simplePattern = new Text(); + + private transient ByteBuffer byteBuffer; + private transient CharBuffer charBuffer; + private transient final CharsetDecoder decoder; + + // Doing characters comparison directly instead of regular expression + // matching for simple patterns like "%abc%". + public enum PatternType { + NONE, // "abc" + BEGIN, // "abc%" + END, // "%abc" + MIDDLE, // "%abc%" + COMPLEX, // all other cases, such as "ab%c_de" + } + + public FilterStringColLikeStringScalar(int colNum, Text likePattern) { + this(); + this.colNum = colNum; + String stringLikePattern = likePattern.toString(); + parseSimplePattern(stringLikePattern); + if (type == PatternType.COMPLEX) { + compiledPattern = Pattern.compile(likePatternToRegExp(stringLikePattern)); + } + } + + public FilterStringColLikeStringScalar() { + super(); + decoder = Charset.forName("UTF-8").newDecoder() + .onMalformedInput(CodingErrorAction.REPLACE) + .onUnmappableCharacter(CodingErrorAction.REPLACE); + byteBuffer = ByteBuffer.allocate(4); + charBuffer = CharBuffer.allocate(4); + } + + public PatternType getType() { + return type; + } + + private boolean like(byte[] bytes, int start, int len) { + switch (type) { + case NONE: + return noneLike(bytes, start, len, simplePattern.getBytes()); + case BEGIN: + return beginLike(bytes, start, len, simplePattern.getBytes()); + case END: + return endLike(bytes, start, len, simplePattern.getBytes()); + case MIDDLE: + return midLike(bytes, start, len, simplePattern.getBytes()); + case COMPLEX: + return complexLike(bytes, start, len); + default: + return false; + } + } + + private static boolean noneLike(byte[] byteS, int start, int len, byte[] byteSub) { + int lenSub = byteSub.length; + if (len != lenSub) { + return false; + } + for (int i = start, j = 0; j < len; i++, j++) { + if (byteS[i] != byteSub[j]) { + return false; + } + } + return true; + } + + private static boolean beginLike(byte[] byteS, int start, int len, byte[] byteSub) { + if (len < byteSub.length) { + return false; + } + for (int i = start, j = 0; j < byteSub.length; i++, j++) { + if (byteS[i] != byteSub[j]) { + return false; + } + } + return true; + } + + private static boolean endLike(byte[] byteS, int start, int len, byte[] byteSub) { + int lenSub = byteSub.length; + if (len < lenSub) { + return false; + } + for (int i = start + len - lenSub, j = 0; j < lenSub; i++, j++) { + if (byteS[i] != byteSub[j]) { + return false; + } + } + return true; + } + + private static boolean midLike(byte[] byteS, int start, int len, byte[] byteSub) { + int lenSub = byteSub.length; + if (len < lenSub) { + return false; + } + int end = start + len - lenSub + 1; + boolean match = false; + for (int i = start; (i < end) && (!match); i++) { + match = true; + for (int j = 0; j < lenSub; j++) { + if (byteS[i + j] != byteSub[j]) { + match = false; + break; + } + } + } + return match; + } + + /** + * Matches the byte array against the complex like pattern. This method uses + * {@link #compiledPattern} to match. For decoding performance, it caches + * {@link #compiledPattern}, {@link #byteBuffer} and {@link #charBuffer}. + * When the length to decode is greater than the capacity of + * {@link #byteBuffer}, it creates new {@link #byteBuffer} and + * {@link #charBuffer}. The capacity of the new {@link #byteBuffer} is the + * double of the length, for fewer object creations and higher memory + * utilization. + * + * @param byteS + * A byte array that contains a UTF-8 string. + * @param start + * A position to start decoding. + * @param len + * A length to decode. + * @return + * true if the byte array matches the complex like pattern, + * otherwise false. + */ + private boolean complexLike(byte[] byteS, int start, int len) { + // Prepare buffers + if (byteBuffer.capacity() < len) { + byteBuffer = ByteBuffer.allocate(len * 2); + } + byteBuffer.clear(); + byteBuffer.put(byteS, start, len); + byteBuffer.flip(); + + int maxChars = (int) (byteBuffer.capacity() * decoder.maxCharsPerByte()); + if (charBuffer.capacity() < maxChars) { + charBuffer = CharBuffer.allocate(maxChars); + } + charBuffer.clear(); + + // Decode UTF-8 + decoder.reset(); + decoder.decode(byteBuffer, charBuffer, true); + decoder.flush(charBuffer); + charBuffer.flip(); + + // Match the given bytes with the like pattern + return compiledPattern.matcher(charBuffer).matches(); + } + + /** + * Parses the likePattern. Based on it is a simple pattern or not, the + * function might change two member variables. {@link #type} will be changed + * to the corresponding pattern type; {@link #simplePattern} will record the + * string in it for later pattern matching if it is a simple pattern. + *

    + * Examples:

    + * + *
    +   * parseSimplePattern("%abc%") changes {@link #type} to PatternType.MIDDLE
    +   * and changes {@link #simplePattern} to "abc"
    +   * parseSimplePattern("%ab_c%") changes {@link #type} to PatternType.COMPLEX
    +   * and does not change {@link #simplePattern}
    +   * 
    + * + *
    + * + * @param likePattern + * the input LIKE query pattern + */ + private void parseSimplePattern(String likePattern) { + int length = likePattern.length(); + int beginIndex = 0; + int endIndex = length; + char lastChar = 'a'; + String strPattern = new String(); + type = PatternType.NONE; + + for (int i = 0; i < length; i++) { + char n = likePattern.charAt(i); + if (n == '_') { // such as "a_b" + if (lastChar != '\\') { // such as "a%bc" + type = PatternType.COMPLEX; + return; + } else { // such as "abc\%de%" + strPattern += likePattern.substring(beginIndex, i - 1); + beginIndex = i; + } + } else if (n == '%') { + if (i == 0) { // such as "%abc" + type = PatternType.END; + beginIndex = 1; + } else if (i < length - 1) { + if (lastChar != '\\') { // such as "a%bc" + type = PatternType.COMPLEX; + return; + } else { // such as "abc\%de%" + strPattern += likePattern.substring(beginIndex, i - 1); + beginIndex = i; + } + } else { + if (lastChar != '\\') { + endIndex = length - 1; + if (type == PatternType.END) { // such as "%abc%" + type = PatternType.MIDDLE; + } else { + type = PatternType.BEGIN; // such as "abc%" + } + } else { // such as "abc\%" + strPattern += likePattern.substring(beginIndex, i - 1); + beginIndex = i; + endIndex = length; + } + } + } + lastChar = n; + } + + strPattern += likePattern.substring(beginIndex, endIndex); + simpleStringPattern = strPattern; + simplePattern.set(simpleStringPattern); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int[] length = inputColVector.length; + int[] start = inputColVector.start; + byte[] simplePatternBytes = simplePattern.getBytes(); + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + + // All must be selected otherwise size would be zero Repeating property will not change. + if (!like(vector[0], start[0], length[0])) { + + // Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + + switch (type) { + case NONE: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (noneLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case BEGIN: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (beginLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case END: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (endLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case MIDDLE: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (midLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case COMPLEX: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (complexLike(vector[i], start[i], length[i])) { + sel[newSize++] = i; + } + } + break; + } + + batch.size = newSize; + } else { + int newSize = 0; + + switch (type) { + case NONE: + for (int i = 0; i != n; i++) { + if (noneLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case BEGIN: + for (int i = 0; i != n; i++) { + if (beginLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case END: + for (int i = 0; i != n; i++) { + if (endLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case MIDDLE: + for (int i = 0; i != n; i++) { + if (midLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + break; + case COMPLEX: + for (int i = 0; i != n; i++) { + if (complexLike(vector[i], start[i], length[i])) { + sel[newSize++] = i; + } + } + break; + } + + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector.isRepeating) { + + //All must be selected otherwise size would be zero. Repeating property will not change. + if (!nullPos[0]) { + if (!like(vector[0], start[0], length[0])) { + + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + + switch (type) { + case NONE: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (noneLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case BEGIN: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (beginLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case END: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (endLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case MIDDLE: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (midLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case COMPLEX: + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (complexLike(vector[i], start[i], length[i])) { + sel[newSize++] = i; + } + } + } + break; + } + + //Change the selected vector + batch.size = newSize; + } else { + int newSize = 0; + + switch (type) { + case NONE: + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (noneLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case BEGIN: + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (beginLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case END: + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (endLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case MIDDLE: + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (midLike(vector[i], start[i], length[i], simplePatternBytes)) { + sel[newSize++] = i; + } + } + } + break; + case COMPLEX: + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + if (complexLike(vector[i], start[i], length[i])) { + sel[newSize++] = i; + } + } + } + break; + } + + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + + /* If every row qualified (newSize==n), then we can ignore the sel vector to streamline + * future operations. So selectedInUse will remain false. + */ + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public Pattern getCompiledPattern() { + return compiledPattern; + } + + public void setCompiledPattern(Pattern compiledPattern) { + this.compiledPattern = compiledPattern; + } + + public void setType(PatternType type) { + this.type = type; + } + + public String getSimpleStringPattern() { + return simpleStringPattern; + } + + public void setSimpleStringPattern(String simpleStringPattern) { + this.simpleStringPattern = simpleStringPattern; + simplePattern.set(simpleStringPattern); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IdentityExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IdentityExpression.java new file mode 100644 index 0000000..758cfcb --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IdentityExpression.java @@ -0,0 +1,72 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * An expression representing a column, only children are evaluated. + */ +public class IdentityExpression extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum = -1; + private String type = null; + + public IdentityExpression() { + } + + public IdentityExpression(int colNum, String type) { + this.colNum = colNum; + this.type = type; + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + this.evaluateChildren(batch); + } + } + + @Override + public int getOutputColumn() { + return colNum; + } + + @Override + public String getOutputType() { + return type; + } + + public int getColNum() { + return getOutputColumn(); + } + + public String getType() { + return getOutputType(); + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setType(String type) { + this.type = type; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNotNull.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNotNull.java new file mode 100644 index 0000000..126090c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNotNull.java @@ -0,0 +1,107 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression evaluates to true if the given input columns is not null. + * The boolean output is stored in the specified output column. + */ +public class IsNotNull extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + + public IsNotNull(int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + } + + public IsNotNull() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + ColumnVector inputColVector = batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + long[] outputVector = ((LongColumnVector) batch.cols[outputColumn]).vector; + + if (n <= 0) { + // Nothing to do + return; + } + + // output never has nulls for this operator + batch.cols[outputColumn].noNulls = true; + if (inputColVector.noNulls) { + outputVector[0] = 1; + batch.cols[outputColumn].isRepeating = true; + } else if (inputColVector.isRepeating) { + // All must be selected otherwise size would be zero + // Selection property will not change. + outputVector[0] = nullPos[0] ? 0 : 1; + batch.cols[outputColumn].isRepeating = true; + } else { + batch.cols[outputColumn].isRepeating = false; + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = nullPos[i] ? 0 : 1; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = nullPos[i] ? 0 : 1; + } + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNull.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNull.java new file mode 100644 index 0000000..4a3f368 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/IsNull.java @@ -0,0 +1,105 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression evaluates to true if the given input columns is null. + * The boolean output is stored in the specified output column. + */ +public class IsNull extends VectorExpression { + + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + + public IsNull(int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + } + + public IsNull() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + ColumnVector inputColVector = batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + long[] outputVector = ((LongColumnVector) batch.cols[outputColumn]).vector; + if (n <= 0) { + // Nothing to do, this is EOF + return; + } + + // output never has nulls for this operator + batch.cols[outputColumn].noNulls = true; + if (inputColVector.noNulls) { + outputVector[0] = 0; + batch.cols[outputColumn].isRepeating = true; + } else if (inputColVector.isRepeating) { + outputVector[0] = nullPos[0] ? 1 : 0; + batch.cols[outputColumn].isRepeating = true; + } else { + if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = nullPos[i] ? 1 : 0; + } + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = nullPos[i] ? 1 : 0; + } + } + batch.cols[outputColumn].isRepeating = false; + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongColumn.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongColumn.java new file mode 100644 index 0000000..499b7df --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongColumn.java @@ -0,0 +1,154 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This operation is handled as a special case because Hive + * long/long division returns double. This file is thus not generated + * from a template like the other arithmetic operations are. + */ +public class LongColDivideLongColumn extends VectorExpression { + private static final long serialVersionUID = 1L; + int colNum1; + int colNum2; + int outputColumn; + + public LongColDivideLongColumn(int colNum1, int colNum2, int outputColumn) { + this(); + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + } + + public LongColDivideLongColumn() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; + LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; + DoubleColumnVector outputColVector = (DoubleColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector1 = inputColVector1.vector; + long[] vector2 = inputColVector2.vector; + double[] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + + // Handle nulls first + NullUtil.propagateNullsColCol( + inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse); + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputVector[0] = vector1[0] / (double) vector2[0]; + } else if (inputColVector1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[0] / (double) vector2[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[0] / (double) vector2[i]; + } + } + } else if (inputColVector2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] / (double) vector2[0]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[i] / (double) vector2[0]; + } + } + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector1[i] / (double) vector2[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector1[i] / (double) vector2[i]; + } + } + } + + /* For the case when the output can have null values, follow + * the convention that the data values must be 1 for long and + * NaN for double. This is to prevent possible later zero-divide errors + * in complex arithmetic expressions like col2 / (col1 - 1) + * in the case when some col1 entries are null. + */ + NullUtil.setNullDataEntriesDouble(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "double"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongScalar.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongScalar.java new file mode 100644 index 0000000..461e632 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongColDivideLongScalar.java @@ -0,0 +1,137 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This operation is handled as a special case because Hive + * long/long division returns double. This file is thus not generated + * from a template like the other arithmetic operations are. + */ +public class LongColDivideLongScalar extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private long value; + private int outputColumn; + + public LongColDivideLongScalar(int colNum, long value, int outputColumn) { + this(); + this.colNum = colNum; + this.value = value; + this.outputColumn = outputColumn; + } + + public LongColDivideLongScalar() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector = (LongColumnVector) batch.cols[colNum]; + DoubleColumnVector outputColVector = (DoubleColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector.noNulls; + outputColVector.isRepeating = inputColVector.isRepeating; + int n = batch.size; + long[] vector = inputColVector.vector; + double[] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.isRepeating) { + outputVector[0] = vector[0] / (double) value; + + // Even if there are no nulls, we always copy over entry 0. Simplifies code. + outputIsNull[0] = inputIsNull[0]; + } else if (inputColVector.noNulls) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector[i] / (double) value; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector[i] / (double) value; + } + } + } else /* there are nulls */ { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = vector[i] / (double) value; + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = vector[i] / (double) value; + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + } + + /* Set double data vector array entries for NULL elements to the correct value. + * Unlike other col-scalar operations, this one doesn't benefit from carrying + * over NaN values from the input array. + */ + NullUtil.setNullDataEntriesDouble(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "double"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public long getValue() { + return value; + } + + public void setValue(long value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongScalarDivideLongColumn.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongScalarDivideLongColumn.java new file mode 100644 index 0000000..b37eafd --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/LongScalarDivideLongColumn.java @@ -0,0 +1,137 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This operation is handled as a special case because Hive + * long/long division returns double. This file is thus not generated + * from a template like the other arithmetic operations are. + */ +public class LongScalarDivideLongColumn extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private double value; + private int outputColumn; + + public LongScalarDivideLongColumn(long value, int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.value = (double) value; + this.outputColumn = outputColumn; + } + + public LongScalarDivideLongColumn() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector = (LongColumnVector) batch.cols[colNum]; + DoubleColumnVector outputColVector = (DoubleColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector.noNulls; + outputColVector.isRepeating = inputColVector.isRepeating; + int n = batch.size; + long[] vector = inputColVector.vector; + double[] outputVector = outputColVector.vector; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector.isRepeating) { + outputVector[0] = value / vector[0]; + + // Even if there are no nulls, we always copy over entry 0. Simplifies code. + outputIsNull[0] = inputIsNull[0]; + } else if (inputColVector.noNulls) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = value / vector[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = value / vector[i]; + } + } + } else /* there are nulls */ { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = value / vector[i]; + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputVector[i] = value / vector[i]; + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + } + + /* Set double data vector array entries for NULL elements to the correct value. + * Unlike other col-scalar operations, this one doesn't benefit from carrying + * over NaN values from the input array. + */ + NullUtil.setNullDataEntriesDouble(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "double"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public double getValue() { + return value; + } + + public void setValue(double value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NotCol.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NotCol.java new file mode 100644 index 0000000..16c5805 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NotCol.java @@ -0,0 +1,122 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Evaluates the boolean complement of the input. + */ +public class NotCol extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + + public NotCol(int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + } + + public NotCol() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector = (LongColumnVector) batch.cols[colNum]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector = inputColVector.vector; + LongColumnVector outV = (LongColumnVector) batch.cols[outputColumn]; + long[] outputVector = outV.vector; + + if (n <= 0) { + // Nothing to do, this is EOF + return; + } + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + // mask out all but low order bit with "& 1" so NOT 1 yields 0, NOT 0 yields 1 + outputVector[0] = ~vector[0] & 1; + } else if (batch.selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = ~vector[i] & 1; + } + outV.isRepeating = false; + } else { + for (int i = 0; i != n; i++) { + outputVector[i] = ~vector[i] & 1; + } + outV.isRepeating = false; + } + } else { + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outputVector[0] = ~vector[0] & 1; + outV.isNull[0] = inputColVector.isNull[0]; + } else if (batch.selectedInUse) { + outV.isRepeating = false; + for (int j = 0; j != n; j++) { + int i = sel[j]; + outputVector[i] = ~vector[i] & 1; + outV.isNull[i] = inputColVector.isNull[i]; + } + } else { + outV.isRepeating = false; + for (int i = 0; i != n; i++) { + outputVector[i] = ~vector[i] & 1; + outV.isNull[i] = inputColVector.isNull[i]; + } + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NullUtil.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NullUtil.java new file mode 100644 index 0000000..e1867a2 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/NullUtil.java @@ -0,0 +1,183 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; + + +/** + * Utility functions to handle null propagation. + */ +public class NullUtil { + + /* + * Set the data value for all NULL entries to the designated NULL_VALUE. + */ + public static void setNullDataEntriesLong( + LongColumnVector v, boolean selectedInUse, int[] sel, int n) { + if (v.noNulls) { + return; + } else if (v.isRepeating && v.isNull[0]) { + v.vector[0] = LongColumnVector.NULL_VALUE; + } else if (selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + if(v.isNull[i]) { + v.vector[i] = LongColumnVector.NULL_VALUE; + } + } + } else { + for (int i = 0; i != n; i++) { + if(v.isNull[i]) { + v.vector[i] = LongColumnVector.NULL_VALUE; + } + } + } + } + + // for use by Column-Scalar and Scalar-Column arithmetic for null propagation + public static void setNullOutputEntriesColScalar( + ColumnVector v, boolean selectedInUse, int[] sel, int n) { + if (v instanceof DoubleColumnVector) { + + // No need to set null data entries because the input NaN values + // will automatically propagate to the output. + return; + } + setNullDataEntriesLong((LongColumnVector) v, selectedInUse, sel, n); + } + + /* + * Set the data value for all NULL entries to NaN + */ + public static void setNullDataEntriesDouble( + DoubleColumnVector v, boolean selectedInUse, int[] sel, int n) { + if (v.noNulls) { + return; + } else if (v.isRepeating && v.isNull[0]) { + v.vector[0] = DoubleColumnVector.NULL_VALUE; + } else if (selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + if(v.isNull[i]) { + v.vector[i] = DoubleColumnVector.NULL_VALUE; + } + } + } else { + for (int i = 0; i != n; i++) { + if(v.isNull[i]) { + v.vector[i] = DoubleColumnVector.NULL_VALUE; + } + } + } + } + + /* + * Propagate null values for a two-input operator. + */ + public static void propagateNullsColCol(ColumnVector inputColVector1, + ColumnVector inputColVector2, ColumnVector outputColVector, int[] sel, + int n, boolean selectedInUse) { + + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; + + if (inputColVector1.noNulls && !inputColVector2.noNulls) { + if (inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector2.isNull[0]; + } else { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { + if (inputColVector1.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0]; + } else { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i] || inputColVector2.isNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outputColVector.isNull[i] = inputColVector1.isNull[i] || inputColVector2.isNull[i]; + } + } + } + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsFalse.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsFalse.java new file mode 100644 index 0000000..c92be99 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsFalse.java @@ -0,0 +1,139 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression selects a row if the given boolean column is false. + */ +public class SelectColumnIsFalse extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum1; + + public SelectColumnIsFalse(int colNum1) { + this(); + this.colNum1 = colNum1; + } + + public SelectColumnIsFalse() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector1 = inputColVector1.vector; + boolean[] nullVector = inputColVector1.isNull; + + if (n <= 0) { + // Nothing to do + return; + } + + if (inputColVector1.noNulls) { + if (inputColVector1.isRepeating) { + if (vector1[0] == 1) { + // All are filtered out + batch.size = 0; + return; + } else { + // All are selected; + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (vector1[i] == 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (vector1[i] == 0) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } else { + if (inputColVector1.isRepeating) { + if (nullVector[0] || (vector1[0] == 1)) { + // All are filtered out + batch.size = 0; + } else { + // All are selected; + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (vector1[i] == 0 && !nullVector[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (vector1[i] == 0 && !nullVector[i]) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNotNull.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNotNull.java new file mode 100644 index 0000000..8dd232c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNotNull.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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression selects a row if the given column is null. + */ +public class SelectColumnIsNotNull extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + + public SelectColumnIsNotNull(int colNum) { + this(); + this.colNum = colNum; + } + + public SelectColumnIsNotNull() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + ColumnVector inputColVector = batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + if (n <= 0) { + // Nothing to do + return; + } + + if (inputColVector.noNulls) { + // All selected, do nothing + return; + } else if (inputColVector.isRepeating) { + if (nullPos[0]) { + // All are null so none are selected + batch.size = 0; + return; + } else { + // None are null, so all are selected + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (!nullPos[i]) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNull.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNull.java new file mode 100644 index 0000000..81106ac --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsNull.java @@ -0,0 +1,106 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression selects a row if the given column is null. + */ +public class SelectColumnIsNull extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + + public SelectColumnIsNull(int colNum) { + this(); + this.colNum = colNum; + } + + public SelectColumnIsNull() { + super(); + } + + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + ColumnVector inputColVector = batch.cols[colNum]; + int[] sel = batch.selected; + boolean[] nullPos = inputColVector.isNull; + int n = batch.size; + if (n <= 0) { + // Nothing to do + return; + } + + if (inputColVector.noNulls) { + batch.size = 0; + } else if (inputColVector.isRepeating) { + if (nullPos[0]) { + // All are null, so all must be selected. + return; + } else { + // None are null, so none are selected + batch.size = 0; + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (nullPos[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (nullPos[i]) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsTrue.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsTrue.java new file mode 100644 index 0000000..f1ffc39 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/SelectColumnIsTrue.java @@ -0,0 +1,138 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This expression selects a row if the given boolean column is true. + */ +public class SelectColumnIsTrue extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum1; + + public SelectColumnIsTrue(int colNum1) { + this(); + this.colNum1 = colNum1; + } + + public SelectColumnIsTrue() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; + int[] sel = batch.selected; + int n = batch.size; + long[] vector1 = inputColVector1.vector; + boolean[] nullVector = inputColVector1.isNull; + + if (n <= 0) { + // Nothing to do + return; + } + + if (inputColVector1.noNulls) { + if (inputColVector1.isRepeating) { + if (vector1[0] == 0) { + // All are filtered out + batch.size = 0; + return; + } else { + // All are selected + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (vector1[i] == 1) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (vector1[i] == 1) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } else { + if (inputColVector1.isRepeating) { + if (nullVector[0] || (vector1[0] == 0)) { + // All are filtered + batch.size = 0; + return; + } else { + // All are selected + return; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (vector1[i] == 1 && !nullVector[i]) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for (int i = 0; i != n; i++) { + if (vector1[i] == 1 && !nullVector[i]) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.selectedInUse = true; + batch.size = newSize; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColCol.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColCol.java new file mode 100644 index 0000000..d09febb --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColCol.java @@ -0,0 +1,440 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Vectorized instruction to concatenate two string columns and put + * the output in a third column. + */ +public class StringConcatColCol extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum1; + private int colNum2; + private int outputColumn; + + public StringConcatColCol(int colNum1, int colNum2, int outputColumn) { + this(); + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + } + + public StringConcatColCol() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inV1 = (BytesColumnVector) batch.cols[colNum1]; + BytesColumnVector inV2 = (BytesColumnVector) batch.cols[colNum2]; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector1 = inV1.vector; + byte[][] vector2 = inV2.vector; + int[] len1 = inV1.length; + int[] len2 = inV2.length; + int[] start1 = inV1.start; + int[] start2 = inV2.start; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + // prepare output buffer to accept results + outV.initBuffer(); + + /* Handle default case for isRepeating setting for output. This will be set to true + * later in the special cases where that is necessary. + */ + outV.isRepeating = false; + + if (inV1.noNulls && !inV2.noNulls) { + + // propagate nulls + + /* We'll assume that there *may* be nulls in the input if !noNulls is true + * for an input vector. This is to be more forgiving of errors in loading + * the vectors. A properly-written vectorized iterator will make sure that + * isNull[0] is set if !noNulls and isRepeating are true for the vector. + */ + outV.noNulls = false; + if (inV2.isRepeating) { + if (inV2.isNull[0]) { + + // Output will also be repeating and null + outV.isNull[0] = true; + outV.isRepeating = true; + + //return as no further processing is needed + return; + } + } else { + propagateNulls(batch.selectedInUse, n, sel, inV2, outV); + } + + // perform data operation + if (inV1.isRepeating && inV2.isRepeating) { + + /* All must be selected otherwise size would be zero. + * Repeating property will not change. + */ + if (!inV2.isNull[0]) { + outV.setConcat(0, vector1[0], start1[0], len1[0], vector2[0], start2[0], len2[0]); + } + outV.isRepeating = true; + } else if (inV1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV2.isNull[i]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV2.isNull[0]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } + } else if (inV2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } + } else { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } + } + } else if (!inV1.noNulls && inV2.noNulls) { + + // propagate nulls + outV.noNulls = false; + if (inV1.isRepeating) { + + //Output will also be repeating and null + outV.isRepeating = true; + outV.isNull[0] = true; + + //return as no further processing is needed + return; + } else { + propagateNulls(batch.selectedInUse, n, sel, inV1, outV); + } + + // perform data operation + if (inV1.isRepeating && inV2.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!inV1.isNull[0]) { + outV.setConcat(0, vector1[0], start1[0], len1[0], vector2[0], start2[0], len2[0]); + } + outV.isRepeating = true; + } else if (inV1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[0]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[0]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } + } else if (inV2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } + } else { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } + } + } else if (!inV1.noNulls && !inV2.noNulls) { + + // propagate nulls + outV.noNulls = false; + if (inV1.isRepeating && inV2.isRepeating) { + outV.isNull[0] = inV1.isNull[0] || inV2.isNull[0]; + + //Output will also be repeating + outV.isRepeating = true; + + // return if output is null because no additional work is needed + if (outV.isNull[0]) { + return; + } + } else if (inV1.isRepeating) { + if (inV1.isNull[0]) { // then all output will be null + outV.isRepeating = true; + outV.isNull[0] = true; + return; + } else { + outV.isRepeating = false; + propagateNulls(batch.selectedInUse, n, sel, inV2, outV); + } + } else if (inV2.isRepeating) { + if (inV2.isNull[0]) { + outV.isRepeating = true; + outV.isNull[0] = true; + return; + } else { + outV.isRepeating = false; + propagateNulls(batch.selectedInUse, n, sel, inV1, outV); + } + } else { + propagateNullsCombine(batch.selectedInUse, n, sel, inV1, inV2, outV); + } + + // perform data operation + if (inV1.isRepeating && inV2.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!inV1.isNull[0] && !inV2.isNull[0]) { + outV.setConcat(0, vector1[0], start1[0], len1[0], vector2[0], start2[0], len2[0]); + } + outV.isRepeating = true; + } else if (inV1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[0] && !inV2.isNull[i]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[0] && !inV2.isNull[i]) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } + } else if (inV2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[i] && !inV2.isNull[0]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[i] && !inV2.isNull[0]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } + } else { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!inV1.isNull[i] && !inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } else { + for(int i = 0; i != n; i++) { + if (!inV1.isNull[i] && !inV2.isNull[i]) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } + } + } else { // there are no nulls in either input vector + + // propagate null information + outV.noNulls = true; + + // perform data operation + if (inV1.isRepeating && inV2.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + outV.setConcat(0, vector1[0], start1[0], len1[0], vector2[0], start2[0], len2[0]); + outV.isRepeating = true; + } else if (inV1.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } else { + for(int i = 0; i != n; i++) { + outV.setConcat(i, vector1[0], start1[0], len1[0], vector2[i], start2[i], len2[i]); + } + } + } else if (inV2.isRepeating) { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } else { + for(int i = 0; i != n; i++) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[0], start2[0], len2[0]); + } + } + } else { + if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } else { + for(int i = 0; i != n; i++) { + outV.setConcat(i, vector1[i], start1[i], len1[i], vector2[i], start2[i], len2[i]); + } + } + } + } + } + + /** + * Propagate the logic OR of null vectors from two inputs to output. + * + * @param selectedInUse true/false flag to tell if sel[] is in use + * @param n number of qualifying rows + * @param sel selected value position array + * @param inV1 input vector 1 + * @param inV2 input vector 2 + * @param outV output vector + */ + private static void propagateNullsCombine(boolean selectedInUse, int n, int[] sel, + ColumnVector inV1, ColumnVector inV2, BytesColumnVector outV) { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inV1.isNull[i] || inV2.isNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + outV.isNull[i] = inV1.isNull[i] || inV2.isNull[i]; + } + } + } + + /** + * Propagate nulls from input vector inV to output vector outV. + * + * @param selectedInUse true/false flag to tell if sel[] is in use + * @param sel selected value position array + * @param n number of qualifying rows + * @param inV input vector + * @param outV ouput vector + */ + private static void propagateNulls(boolean selectedInUse, int n, int[] sel, ColumnVector inV, + ColumnVector outV) { + if (selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inV.isNull[i]; + } + } else { + System.arraycopy(inV.isNull, 0, outV.isNull, 0, n); + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "String"; + } + + public int getColNum1() { + return colNum1; + } + + public void setColNum1(int colNum1) { + this.colNum1 = colNum1; + } + + public int getColNum2() { + return colNum2; + } + + public void setColNum2(int colNum2) { + this.colNum2 = colNum2; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColScalar.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColScalar.java new file mode 100644 index 0000000..c7ad347 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatColScalar.java @@ -0,0 +1,144 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Vectorized instruction to concatenate a string column to a scalar and put + * the result in an output column. + */ +public class StringConcatColScalar extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + private byte[] value; + + public StringConcatColScalar(int colNum, int outputColumn, byte[] value) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + this.value = value; + } + + public StringConcatColScalar() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int[] start = inputColVector.start; + int[] length = inputColVector.length; + + if (n == 0) { + + // Nothing to do + return; + } + + // initialize output vector buffer to receive data + outV.initBuffer(); + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.setConcat(0, vector[0], start[0], length[0], value, 0, value.length); + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.setConcat(i, vector[i], start[i], length[i], value, 0, value.length); + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + outV.setConcat(i, vector[i], start[i], length[i], value, 0, value.length); + } + outV.isRepeating = false; + } + } else { + + /* + * Handle case with nulls. Don't do function if the value is null, to save time, + * because calling the function can be expensive. + */ + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = inputColVector.isNull[0]; + if (!inputColVector.isNull[0]) { + outV.setConcat(0, vector[0], start[0], length[0], value, 0, value.length); + } + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inputColVector.isNull[i]) { + outV.setConcat(i, vector[i], start[i], length[i], value, 0, value.length); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + outV.setConcat(i, vector[i], start[i], length[i], value, 0, value.length); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "String"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public byte[] getValue() { + return value; + } + + public void setValue(byte[] value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatScalarCol.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatScalarCol.java new file mode 100644 index 0000000..6e7579e --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringConcatScalarCol.java @@ -0,0 +1,144 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Vectorized instruction to concatenate a scalar to a string column and put + * the result in an output column. + */ +public class StringConcatScalarCol extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + private byte[] value; + + public StringConcatScalarCol(byte[] value, int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + this.value = value; + } + + public StringConcatScalarCol() { + super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int[] start = inputColVector.start; + int[] length = inputColVector.length; + + if (n == 0) { + + // Nothing to do + return; + } + + // initialize output vector buffer to receive data + outV.initBuffer(); + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.setConcat(0, value, 0, value.length, vector[0], start[0], length[0]); + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.setConcat(i, value, 0, value.length, vector[i], start[i], length[i]); + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + outV.setConcat(i, value, 0, value.length, vector[i], start[i], length[i]); + } + outV.isRepeating = false; + } + } else { + + /* + * Handle case with nulls. Don't do function if the value is null, to save time, + * because calling the function can be expensive. + */ + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = inputColVector.isNull[0]; + if (!inputColVector.isNull[0]) { + outV.setConcat(0, value, 0, value.length, vector[0], start[0], length[0]); + } + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inputColVector.isNull[i]) { + outV.setConcat(i, value, 0, value.length, vector[i], start[i], length[i]); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + outV.setConcat(i, value, 0, value.length, vector[i], start[i], length[i]); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "String"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public byte[] getValue() { + return value; + } + + public void setValue(byte[] value) { + this.value = value; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringExpr.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringExpr.java new file mode 100644 index 0000000..92beb93 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringExpr.java @@ -0,0 +1,43 @@ +/** + * 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.exec.vector.expressions; + +/** + * String expression evaluation helper functions. + */ +public class StringExpr { + + /* Compare two strings from two byte arrays each + * with their own start position and length. + * Use lexicographic unsigned byte value order. + * This is what's used for UTF-8 sort order. + * Return negative value if arg1 < arg2, 0 if arg1 = arg2, + * positive if arg1 > arg2. + */ + public static int compare(byte[] arg1, int start1, int len1, byte[] arg2, int start2, int len2) { + for (int i = 0; i < len1 && i < len2; i++) { + int b1 = arg1[i + start1] & 0xff; + int b2 = arg2[i + start2] & 0xff; + if (b1 != b2) { + return b1 - b2; + } + } + return len1 - len2; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLTrim.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLTrim.java new file mode 100644 index 0000000..7e9b36a --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLTrim.java @@ -0,0 +1,49 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; + +public class StringLTrim extends StringUnaryUDFDirect { + private static final long serialVersionUID = 1L; + + public StringLTrim(int inputColumn, int outputColumn) { + super(inputColumn, outputColumn); + } + + public StringLTrim() { + super(); + } + + /** + * LTRIM element i of the vector, and place the result in outV. + * Operate on the data in place, and set the output by reference + * to improve performance. Ignore null handling. That will be handled separately. + */ + protected void func(BytesColumnVector outV, byte[][] vector, int[] start, int[] length, int i) { + int j = start[i]; + + // skip past blank characters + while(j < start[i] + vector[i].length && vector[i][j] == 0x20) { + j++; + } + + outV.setVal(i, vector[i], j, length[i] - (j - start[i])); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLength.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLength.java new file mode 100644 index 0000000..c7acc55 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLength.java @@ -0,0 +1,157 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Calculate the length of the strings in the input column vector, and store + * it in the output column vector. + */ +public class StringLength extends VectorExpression { + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + + public StringLength(int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + } + + public StringLength() { + super(); + } + + // Calculate the length of the UTF-8 strings in input vector and place results in output vector. + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + LongColumnVector outV = (LongColumnVector) batch.cols[outputColumn]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int [] start = inputColVector.start; + int [] length = inputColVector.length; + long[] resultLen = outV.vector; + + if (n == 0) { + //Nothing to do + return; + } + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + resultLen[0] = utf8StringLength(vector[0], start[0], length[0]); + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + resultLen[i] = utf8StringLength(vector[i], start[i], length[i]); + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + resultLen[i] = utf8StringLength(vector[i], start[i], length[i]); + } + outV.isRepeating = false; + } + } else { + + /* + * Handle case with nulls. Don't do function if the value is null, to save time, + * because calling the function can be expensive. + */ + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = inputColVector.isNull[0]; + if (!inputColVector.isNull[0]) { + resultLen[0] = utf8StringLength(vector[0], start[0], length[0]); + } + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!inputColVector.isNull[i]) { + resultLen[i] = utf8StringLength(vector[i], start[i], length[i]); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + resultLen[i] = utf8StringLength(vector[i], start[i], length[i]); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } + } + } + + /* + * Return length in characters of UTF8 string in byte array + * beginning at start that is len bytes long. + */ + static long utf8StringLength(byte[] s, int start, int len) { + long resultLength = 0; + for (int i = start; i < start + len; i++) { + + /* Byte bit patterns of the form 10xxxxxx are continuation + * bytes. All other bit patterns are the first byte of + * a character. + */ + if ((s[i] & 0xc0) != 0x80) { + resultLength++; + } + } + return resultLength; + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "Long"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLower.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLower.java new file mode 100644 index 0000000..ee0182b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringLower.java @@ -0,0 +1,49 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.io.Text; + +/** + * Expression to convert a string to lower case. + * Extends {@link StringUnaryUDF}. + */ +public class StringLower extends StringUnaryUDF { + private static final long serialVersionUID = 1L; + + public StringLower(int colNum, int outputColumn) { + super(colNum, outputColumn, new IUDFUnaryString() { + + private final Text t = new Text(); + + @Override + public Text evaluate(Text s) { + if (s == null) { + return null; + } + t.set(s.toString().toLowerCase()); + return t; + } + }); + } + + public StringLower() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringRTrim.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringRTrim.java new file mode 100644 index 0000000..94821a1 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringRTrim.java @@ -0,0 +1,50 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; + +public class StringRTrim extends StringUnaryUDFDirect { + private static final long serialVersionUID = 1L; + + public StringRTrim(int inputColumn, int outputColumn) { + super(inputColumn, outputColumn); + } + + public StringRTrim() { + super(); + } + + /** + * RTRIM element i of the vector, and place the result in outV. + * Operate on the data in place, and set the output by reference + * to improve performance. Ignore null handling. That will be handled separately. + */ + protected void func(BytesColumnVector outV, byte[][] vector, int[] start, int[] length, int i) { + int j = start[i] + length[i] - 1; + + // skip trailing blank characters + while(j >= start[i] && vector[i][j] == 0x20) { + j--; + } + + // set output vector + outV.setVal(i, vector[i], start[i], (j - start[i]) + 1); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStart.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStart.java new file mode 100644 index 0000000..7a30534 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStart.java @@ -0,0 +1,245 @@ +/** + * 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.exec.vector.expressions; + +import java.io.UnsupportedEncodingException; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class provides the implementation of vectorized substring, with a single start index + * parameter. If the start index is invalid (outside of the string boundaries) then an empty + * string will be in the output. + */ +public class StringSubstrColStart extends VectorExpression { + private static final long serialVersionUID = 1L; + private int startIdx; + private int colNum; + private int outputColumn; + private transient static byte[] EMPTY_STRING; + + // Populating the Empty string bytes. Putting it as static since it should be immutable and can + // be shared. + static { + try { + EMPTY_STRING = "".getBytes("UTF-8"); + } catch(UnsupportedEncodingException e) { + e.printStackTrace(); + } + } + + public StringSubstrColStart(int colNum, int startIdx, int outputColumn) { + this(); + this.colNum = colNum; + + /* Switch from a 1-based start offset (the Hive end user convention) to a 0-based start offset + * (the internal convention). + */ + if (startIdx >= 1) { + this.startIdx = startIdx - 1; + } else if (startIdx == 0) { + + // If start index is 0 in query, that is equivalent to using 1 in query. + // So internal offset is 0. + this.startIdx = 0; + } else { + + // start index of -n means give the last n characters of the string + this.startIdx = startIdx; + } + this.outputColumn = outputColumn; + } + + public StringSubstrColStart() { + super(); + } + + /** + * Given the substring start index param it finds the starting offset of the passed in utf8 + * string byte array that matches the index. + * @param utf8String byte array that holds the utf8 string + * @param start start offset of the byte array the string starts at + * @param len length of the bytes the string holds in the byte array + * @param substrStart the Start index for the substring operation + */ + static int getSubstrStartOffset(byte[] utf8String, int start, int len, int substrStart) { + int end = start + len; + + if (substrStart < 0) { + int length = 0; + for (int i = start; i != end; ++i) { + if ((utf8String[i] & 0xc0) != 0x80) { + ++length; + } + } + if (-substrStart > length) { + + /* The result is empty string if a negative start is provided + * whose absolute value is greater than the string length. + */ + return -1; + } + + substrStart = length + substrStart; + } + + int curIdx = -1; + for (int i = start; i != end; ++i) { + if ((utf8String[i] & 0xc0) != 0x80) { + ++curIdx; + if (curIdx == substrStart) { + return i; + } + } + } + return -1; + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inV = (BytesColumnVector) batch.cols[colNum]; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + + int n = batch.size; + + if (n == 0) { + return; + } + + byte[][] vector = inV.vector; + int[] sel = batch.selected; + int[] len = inV.length; + int[] start = inV.start; + outV.initBuffer(); + + if (inV.isRepeating) { + outV.isRepeating = true; + if (!inV.noNulls && inV.isNull[0]) { + outV.isNull[0] = true; + outV.noNulls = false; + outV.setVal(0, EMPTY_STRING, 0, EMPTY_STRING.length); + return; + } else { + outV.noNulls = true; + int offset = getSubstrStartOffset(vector[0], start[0], len[0], startIdx); + if (offset != -1) { + outV.setVal(0, vector[0], offset, len[0] - (offset - start[0])); + } else { + outV.setVal(0, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } else { + outV.isRepeating = false; + if (batch.selectedInUse) { + if (!inV.noNulls) { + outV.noNulls = false; + for (int i = 0; i != n; ++i) { + int selected = sel[i]; + if (!inV.isNull[selected]) { + int offset = getSubstrStartOffset(vector[selected], start[selected], len[selected], + startIdx); + outV.isNull[selected] = false; + if (offset != -1) { + outV.setVal(selected, vector[selected], offset, + len[selected] - (offset - start[selected])); + } else { + outV.setVal(selected, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } else { + outV.isNull[selected] = true; + } + } + } else { + outV.noNulls = true; + for (int i = 0; i != n; ++i) { + int selected = sel[i]; + int offset = getSubstrStartOffset(vector[selected], start[selected], len[selected], + startIdx); + if (offset != -1) { + outV.setVal(selected, vector[selected], offset, + len[selected] - (offset - start[selected])); + } else { + outV.setVal(selected, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } else { + if (!inV.noNulls) { + outV.noNulls = false; + System.arraycopy(inV.isNull, 0, outV.isNull, 0, n); + for (int i = 0; i != n; ++i) { + if (!inV.isNull[i]) { + int offset = getSubstrStartOffset(vector[i], start[i], len[i], startIdx); + if (offset != -1) { + outV.setVal(i, vector[i], offset, len[i] - (offset - start[i])); + } else { + outV.setVal(i, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } else { + outV.noNulls = true; + for (int i = 0; i != n; ++i) { + int offset = getSubstrStartOffset(vector[i], start[i], len[i], startIdx); + if (offset != -1) { + outV.setVal(i, vector[i], offset, len[i] - (offset - start[i])); + } else { + outV.setVal(i, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "string"; + } + + public int getStartIdx() { + return startIdx; + } + + public void setStartIdx(int startIdx) { + this.startIdx = startIdx; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStartLen.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStartLen.java new file mode 100644 index 0000000..c396030 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringSubstrColStartLen.java @@ -0,0 +1,269 @@ +/** + * 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.exec.vector.expressions; + +import java.io.UnsupportedEncodingException; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This class provides the implementation of vectorized substring, with a start index and length + * parameters. If the start index is invalid (outside of the string boundaries) then an empty + * string will be in the output. + * If the length provided is longer then the string boundary, then it will replace it with the + * ending index. + */ +public class StringSubstrColStartLen extends VectorExpression { + private static final long serialVersionUID = 1L; + private int startIdx; + private int colNum; + private int length; + private int outputColumn; + private transient final int[] offsetArray; + private transient static byte[] EMPTY_STRING; + + // Populating the Empty string bytes. Putting it as static since it should be immutable and can be + // shared + static { + try { + EMPTY_STRING = "".getBytes("UTF-8"); + } catch(UnsupportedEncodingException e) { + e.printStackTrace(); + } + } + + public StringSubstrColStartLen(int colNum, int startIdx, int length, int outputColumn) { + this(); + this.colNum = colNum; + + /* Switch from a 1-based start offset (the Hive end user convention) to a 0-based start offset + * (the internal convention). + */ + if (startIdx >= 1) { + this.startIdx = startIdx - 1; + } else if (startIdx == 0) { + + // If start index is 0 in query, that is equivalent to using 1 in query. + // So internal offset is 0. + this.startIdx = 0; + } else { + + // start index of -n means give the last n characters of the string + this.startIdx = startIdx; + } + + this.length = length; + this.outputColumn = outputColumn; + } + + public StringSubstrColStartLen() { + super(); + offsetArray = new int[2]; + } + + /** + * Populates the substring start and end offsets based on the substring start and length params. + * + * @param utf8String byte array that holds the utf8 string + * @param start start offset of the byte array the string starts at + * @param len length of the bytes the string holds in the byte array + * @param substrStart the Start index for the substring operation + * @param substrLen the length of the substring + * @param offsetArray the array that indexes are populated to. Assume its length >= 2. + */ + static void populateSubstrOffsets(byte[] utf8String, int start, int len, int substrStart, + int substrLength, int[] offsetArray) { + int curIdx = -1; + offsetArray[0] = -1; + offsetArray[1] = -1; + int end = start + len; + + if (substrStart < 0) { + int length = 0; + for (int i = start; i != end; ++i) { + if ((utf8String[i] & 0xc0) != 0x80) { + ++length; + } + } + + if (-substrStart > length) { + return; + } + + substrStart = length + substrStart; + } + + int endIdx = substrStart + substrLength - 1; + for (int i = start; i != end; ++i) { + if ((utf8String[i] & 0xc0) != 0x80) { + ++curIdx; + if (curIdx == substrStart) { + offsetArray[0] = i; + } else if (curIdx - 1 == endIdx) { + offsetArray[1] = i - offsetArray[0]; + } + } + } + + if (offsetArray[1] == -1) { + offsetArray[1] = end - offsetArray[0]; + } + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inV = (BytesColumnVector) batch.cols[colNum]; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + + int n = batch.size; + + if (n == 0) { + return; + } + + byte[][] vector = inV.vector; + int[] sel = batch.selected; + int[] len = inV.length; + int[] start = inV.start; + outV.initBuffer(); + + if (inV.isRepeating) { + outV.isRepeating = true; + if (!inV.noNulls && inV.isNull[0]) { + outV.isNull[0] = true; + outV.noNulls = false; + outV.setVal(0, EMPTY_STRING, 0, EMPTY_STRING.length); + return; + } else { + outV.noNulls = true; + populateSubstrOffsets(vector[0], start[0], len[0], startIdx, length, offsetArray); + if (offsetArray[0] != -1) { + outV.setVal(0, vector[0], offsetArray[0], offsetArray[1]); + } else { + outV.setVal(0, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } else { + outV.isRepeating = false; + if (batch.selectedInUse) { + if (!inV.noNulls) { + outV.noNulls = false; + for (int i = 0; i != n; ++i) { + int selected = sel[i]; + if (!inV.isNull[selected]) { + outV.isNull[selected] = false; + populateSubstrOffsets(vector[selected], start[selected], len[selected], startIdx, + length, offsetArray); + if (offsetArray[0] != -1) { + outV.setVal(selected, vector[selected], offsetArray[0], offsetArray[1]); + } else { + outV.setVal(selected, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } else { + outV.isNull[selected] = true; + } + } + } else { + outV.noNulls = true; + for (int i = 0; i != n; ++i) { + int selected = sel[i]; + outV.isNull[selected] = false; + populateSubstrOffsets(vector[selected], start[selected], len[selected], startIdx, + length, offsetArray); + if (offsetArray[0] != -1) { + outV.setVal(selected, vector[selected], offsetArray[0], offsetArray[1]); + } else { + outV.setVal(selected, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } else { + if (!inV.noNulls) { + System.arraycopy(inV.isNull, 0, outV.isNull, 0, n); + outV.noNulls = false; + for (int i = 0; i != n; ++i) { + if (!inV.isNull[i]) { + populateSubstrOffsets(vector[i], start[i], len[i], startIdx, length, offsetArray); + if (offsetArray[0] != -1) { + outV.setVal(i, vector[i], offsetArray[0], offsetArray[1]); + } else { + outV.setVal(i, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } else { + outV.noNulls = true; + for (int i = 0; i != n; ++i) { + outV.isNull[i] = false; + populateSubstrOffsets(vector[i], start[i], len[i], startIdx, length, offsetArray); + if (offsetArray[0] != -1) { + outV.setVal(i, vector[i], offsetArray[0], offsetArray[1]); + } else { + outV.setVal(i, EMPTY_STRING, 0, EMPTY_STRING.length); + } + } + } + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "string"; + } + + public int getStartIdx() { + return startIdx; + } + + public void setStartIdx(int startIdx) { + this.startIdx = startIdx; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public int getLength() { + return length; + } + + public void setLength(int length) { + this.length = length; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringTrim.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringTrim.java new file mode 100644 index 0000000..88504f8 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringTrim.java @@ -0,0 +1,56 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; + +public class StringTrim extends StringUnaryUDFDirect { + private static final long serialVersionUID = 1L; + + public StringTrim(int inputColumn, int outputColumn) { + super(inputColumn, outputColumn); + } + + public StringTrim() { + super(); + } + + /** + * TRIM element i of the vector, eliminating blanks from the left + * and right sides of the string, and place the result in outV. + * Operate on the data in place, and set the output by reference + * to improve performance. Ignore null handling. That will be handled separately. + */ + protected void func(BytesColumnVector outV, byte[][] vector, int[] start, int[] length, int i) { + int l = start[i]; + int r = start[i] + length[i] - 1; + + // skip blank character on left + while(l <= r && vector[i][l] == 0x20) { + l++; + } + + // skip blank characters on right + while(l <= r && vector[i][r] == 0x20) { + r--; + } + + outV.setVal(i, vector[i], l, (r - l) + 1); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDF.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDF.java new file mode 100644 index 0000000..7dab821 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDF.java @@ -0,0 +1,170 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.io.Text; + +/** + * Expression for vectorized evaluation of unary UDFs on strings. + * An object of {@link IUDFUnaryString} is applied to every element of + * the vector. + */ +public class StringUnaryUDF extends VectorExpression { + + public interface IUDFUnaryString { + Text evaluate(Text s); + } + + private static final long serialVersionUID = 1L; + private int colNum; + private int outputColumn; + private IUDFUnaryString func; + private transient final Text s; + + StringUnaryUDF(int colNum, int outputColumn, IUDFUnaryString func) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + this.func = func; + } + + public StringUnaryUDF() { + super(); + s = new Text(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int [] start = inputColVector.start; + int [] length = inputColVector.length; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + Text t; + + if (n == 0) { + //Nothing to do + return; + } + + // Design Note: In the future, if this function can be implemented + // directly to translate input to output without creating new + // objects, performance can probably be improved significantly. + // It's implemented in the simplest way now, just calling the + // existing built-in function. + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + s.set(vector[0], start[0], length[0]); + t = func.evaluate(s); + outV.setRef(0, t.getBytes(), 0, t.getLength()); + } else if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + s.set(vector[i], start[i], length[i]); + t = func.evaluate(s); + outV.setRef(i, t.getBytes(), 0, t.getLength()); + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + s.set(vector[i], start[i], length[i]); + t = func.evaluate(s); + outV.setRef(i, t.getBytes(), 0, t.getLength()); + } + outV.isRepeating = false; + } + } else { + // Handle case with nulls. Don't do function if the value is null, to save time, + // because calling the function can be expensive. + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = inputColVector.isNull[0]; + if (!inputColVector.isNull[0]) { + s.set(vector[0], start[0], length[0]); + t = func.evaluate(s); + outV.setRef(0, t.getBytes(), 0, t.getLength()); + } + } else if (batch.selectedInUse) { + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!inputColVector.isNull[i]) { + s.set(vector[i], start[i], length[i]); + t = func.evaluate(s); + outV.setRef(i, t.getBytes(), 0, t.getLength()); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + s.set(vector[i], start[i], length[i]); + t = func.evaluate(s); + outV.setRef(i, t.getBytes(), 0, t.getLength()); + } + outV.isNull[i] = inputColVector.isNull[i]; + } + outV.isRepeating = false; + } + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "String"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public IUDFUnaryString getFunc() { + return func; + } + + public void setFunc(IUDFUnaryString func) { + this.func = func; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDFDirect.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDFDirect.java new file mode 100644 index 0000000..bf65110 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUnaryUDFDirect.java @@ -0,0 +1,138 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * This is a superclass for unary string functions that operate directly on the + * input and set the output. It is suitable for direct, in-place operations on + * strings, such as for fast implementations of TRIM(), LTRIM(), and RTRIM(). + */ +abstract public class StringUnaryUDFDirect extends VectorExpression { + private static final long serialVersionUID = 1L; + int inputColumn; + int outputColumn; + + public StringUnaryUDFDirect(int inputColumn, int outputColumn) { + this.inputColumn = inputColumn; + this.outputColumn = outputColumn; + } + + public StringUnaryUDFDirect() { + super(); + } + + abstract protected void func(BytesColumnVector outV, byte[][] vector, int[] start, int[] length, int i); + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[inputColumn]; + int[] sel = batch.selected; + int n = batch.size; + byte[][] vector = inputColVector.vector; + int start[] = inputColVector.start; + int length[] = inputColVector.length; + BytesColumnVector outV = (BytesColumnVector) batch.cols[outputColumn]; + outV.initBuffer(); + + if (n == 0) { + //Nothing to do + return; + } + + if (inputColVector.noNulls) { + outV.noNulls = true; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + func(outV, vector, start, length, 0); + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + func(outV, vector, start, length, i); + } + outV.isRepeating = false; + } else { + for(int i = 0; i != n; i++) { + func(outV, vector, start, length, i); + } + outV.isRepeating = false; + } + } else { + + // Handle case with nulls. Don't do function if the value is null, + // because the data may be undefined for a null value. + outV.noNulls = false; + if (inputColVector.isRepeating) { + outV.isRepeating = true; + outV.isNull[0] = inputColVector.isNull[0]; + if (!inputColVector.isNull[0]) { + func(outV, vector, start, length, 0); + } + } else if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outV.isNull[i] = inputColVector.isNull[i]; + if (!inputColVector.isNull[i]) { + func(outV, vector, start, length, i); + } + } + outV.isRepeating = false; + } else { + System.arraycopy(inputColVector.isNull, 0, outV.isNull, 0, n); + for(int i = 0; i != n; i++) { + if (!inputColVector.isNull[i]) { + func(outV, vector, start, length, i); + } + } + outV.isRepeating = false; + } + } + } + + + @Override + public int getOutputColumn() { + return outputColumn; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } + + public int getInputColumn() { + return inputColumn; + } + + public void setInputColumn(int inputColumn) { + this.inputColumn = inputColumn; + } + + @Override + public String getOutputType() { + return "String"; + } + +} \ No newline at end of file diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUpper.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUpper.java new file mode 100644 index 0000000..9ceae4d --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/StringUpper.java @@ -0,0 +1,49 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.io.Text; + +/** + * Expression to convert a string to lower case. + * Extends {@link StringUnaryUDF}. + */ +public class StringUpper extends StringUnaryUDF { + private static final long serialVersionUID = 1L; + + public StringUpper(int colNum, int outputColumn) { + super(colNum, outputColumn, new IUDFUnaryString() { + + Text t = new Text(); + + @Override + public Text evaluate(Text s) { + if (s == null) { + return null; + } + t.set(s.toString().toUpperCase()); + return t; + } + }); + } + + public StringUpper() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpression.java new file mode 100644 index 0000000..4239ec8 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpression.java @@ -0,0 +1,96 @@ +/** + * 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.exec.vector.expressions; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Base class for expressions. + */ +public abstract class VectorExpression implements Serializable { + + private static final long serialVersionUID = 1L; + /** + * Child expressions are evaluated post order. + */ + protected VectorExpression [] childExpressions = null; + + /** + * This is the primary method to implement expression logic. + * @param vrg + */ + public abstract void evaluate(VectorizedRowBatch batch); + + /** + * Returns the index of the output column in the array + * of column vectors. If not applicable, -1 is returned. + * @return Index of the output column + */ + public abstract int getOutputColumn(); + + /** + * Returns type of the output column. + */ + public abstract String getOutputType(); + + /** + * Initialize the child expressions. + */ + public void setChildExpressions(VectorExpression [] ve) { + childExpressions = ve; + } + + public VectorExpression[] getChildExpressions() { + return childExpressions; + } + + /** + * Evaluate the child expressions on the given input batch. + * @param vrg {@link VectorizedRowBatch} + */ + final protected void evaluateChildren(VectorizedRowBatch vrg) { + if (childExpressions != null) { + for (VectorExpression ve : childExpressions) { + ve.evaluate(vrg); + } + } + } + + @Override + public String toString() { + StringBuilder b = new StringBuilder(); + b.append(this.getClass().getSimpleName()); + b.append("["); + b.append(this.getOutputColumn()); + b.append("]"); + if (childExpressions != null) { + b.append("("); + for (int i = 0; i < childExpressions.length; i++) { + b.append(childExpressions[i].toString()); + if (i < childExpressions.length-1) { + b.append(" "); + } + } + b.append(")"); + } + return b.toString(); + } +} \ No newline at end of file diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriter.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriter.java new file mode 100644 index 0000000..890cf4c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriter.java @@ -0,0 +1,36 @@ +/** + * 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.exec.vector.expressions; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.io.Writable; + +/** + * Interface used to create Writable objects from vector expression primitives. + * + */ +public interface VectorExpressionWriter { + ObjectInspector getObjectInspector(); + Object writeValue(ColumnVector column, int row) throws HiveException; + Object writeValue(long value) throws HiveException; + Object writeValue(double value) throws HiveException; + Object writeValue(byte[] value, int start, int length) throws HiveException; +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriterFactory.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriterFactory.java new file mode 100644 index 0000000..9e189c9 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorExpressionWriterFactory.java @@ -0,0 +1,436 @@ +/** + * 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.exec.vector.expressions; + +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TimestampUtils; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.serde2.io.ByteWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.io.ShortWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.StructField; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.FloatWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.Text; + +/** + * VectorExpressionWritableFactory helper class for generating VectorExpressionWritable objects. + */ +public final class VectorExpressionWriterFactory { + + /** + * VectorExpressionWriter base implementation, to be specialized for Long/Double/Bytes columns + */ + private static abstract class VectorExpressionWriterBase implements VectorExpressionWriter { + + protected ObjectInspector objectInspector; + + /** + * The object inspector associated with this expression. This is created from the expression + * NodeDesc (compile metadata) not from the VectorColumn info and thus preserves the type info + * lost by the vectorization process. + */ + public ObjectInspector getObjectInspector() { + return objectInspector; + } + + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + objectInspector = nodeDesc.getWritableObjectInspector(); + if (null == objectInspector) { + objectInspector = TypeInfoUtils + .getStandardWritableObjectInspectorFromTypeInfo(nodeDesc.getTypeInfo()); + } + if (null == objectInspector) { + throw new HiveException(String.format( + "Failed to initialize VectorExpressionWriter for expr: %s", + nodeDesc.getExprString())); + } + return this; + } + + /** + * The base implementation must be overridden by the Long specialization + */ + @Override + public Object writeValue(long value) throws HiveException { + throw new HiveException("Internal error: should not reach here"); + } + + /** + * The base implementation must be overridden by the Double specialization + */ + @Override + public Object writeValue(double value) throws HiveException { + throw new HiveException("Internal error: should not reach here"); + } + + /** + * The base implementation must be overridden by the Bytes specialization + */ + @Override + public Object writeValue(byte[] value, int start, int length) throws HiveException { + throw new HiveException("Internal error: should not reach here"); + } + } + + /** + * Specialized writer for LongVectorColumn expressions. Will throw cast exception + * if the wrong vector column is used. + */ + private static abstract class VectorExpressionWriterLong + extends VectorExpressionWriterBase { + @Override + public Object writeValue(ColumnVector column, int row) throws HiveException { + LongColumnVector lcv = (LongColumnVector) column; + if (lcv.noNulls && !lcv.isRepeating) { + return writeValue(lcv.vector[row]); + } else if (lcv.noNulls && lcv.isRepeating) { + return writeValue(lcv.vector[0]); + } else if (!lcv.noNulls && !lcv.isRepeating && !lcv.isNull[row]) { + return writeValue(lcv.vector[row]); + } else if (!lcv.noNulls && !lcv.isRepeating && lcv.isNull[row]) { + return null; + } else if (!lcv.noNulls && lcv.isRepeating && !lcv.isNull[0]) { + return writeValue(lcv.vector[0]); + } else if (!lcv.noNulls && lcv.isRepeating && lcv.isNull[0]) { + return null; + } + throw new HiveException( + String.format( + "Incorrect null/repeating: row:%d noNulls:%b isRepeating:%b isNull[row]:%b isNull[0]:%b", + row, lcv.noNulls, lcv.isRepeating, lcv.isNull[row], lcv.isNull[0])); + } + } + + /** + * Specialized writer for DoubleColumnVector. Will throw cast exception + * if the wrong vector column is used. + */ + private static abstract class VectorExpressionWriterDouble extends VectorExpressionWriterBase { + @Override + public Object writeValue(ColumnVector column, int row) throws HiveException { + DoubleColumnVector dcv = (DoubleColumnVector) column; + if (dcv.noNulls && !dcv.isRepeating) { + return writeValue(dcv.vector[row]); + } else if (dcv.noNulls && dcv.isRepeating) { + return writeValue(dcv.vector[0]); + } else if (!dcv.noNulls && !dcv.isRepeating && !dcv.isNull[row]) { + return writeValue(dcv.vector[row]); + } else if (!dcv.noNulls && !dcv.isRepeating && dcv.isNull[row]) { + return null; + } else if (!dcv.noNulls && dcv.isRepeating && !dcv.isNull[0]) { + return writeValue(dcv.vector[0]); + } else if (!dcv.noNulls && dcv.isRepeating && dcv.isNull[0]) { + return null; + } + throw new HiveException( + String.format( + "Incorrect null/repeating: row:%d noNulls:%b isRepeating:%b isNull[row]:%b isNull[0]:%b", + row, dcv.noNulls, dcv.isRepeating, dcv.isNull[row], dcv.isNull[0])); + } + } + + /** + * Specialized writer for BytesColumnVector. Will throw cast exception + * if the wrong vector column is used. + */ + private static abstract class VectorExpressionWriterBytes extends VectorExpressionWriterBase { + @Override + public Object writeValue(ColumnVector column, int row) throws HiveException { + BytesColumnVector bcv = (BytesColumnVector) column; + if (bcv.noNulls && !bcv.isRepeating) { + return writeValue(bcv.vector[row], bcv.start[row], bcv.length[row]); + } else if (bcv.noNulls && bcv.isRepeating) { + return writeValue(bcv.vector[0], bcv.start[0], bcv.length[0]); + } else if (!bcv.noNulls && !bcv.isRepeating && !bcv.isNull[row]) { + return writeValue(bcv.vector[row], bcv.start[row], bcv.length[row]); + } else if (!bcv.noNulls && !bcv.isRepeating && bcv.isNull[row]) { + return null; + } else if (!bcv.noNulls && bcv.isRepeating && !bcv.isNull[0]) { + return writeValue(bcv.vector[0], bcv.start[0], bcv.length[0]); + } else if (!bcv.noNulls && bcv.isRepeating && bcv.isNull[0]) { + return null; + } + throw new HiveException( + String.format( + "Incorrect null/repeating: row:%d noNulls:%b isRepeating:%b isNull[row]:%b isNull[0]:%b", + row, bcv.noNulls, bcv.isRepeating, bcv.isNull[row], bcv.isNull[0])); + } + } + + /** + * Compiles the appropriate vector expression writer based on an expression info (ExprNodeDesc) + */ + public static VectorExpressionWriter genVectorExpressionWritable(ExprNodeDesc nodeDesc) + throws HiveException { + String nodeType = nodeDesc.getTypeString(); + if (nodeType.equalsIgnoreCase("tinyint")) { + return new VectorExpressionWriterLong() + { + private ByteWritable writable; + + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new ByteWritable(); + return this; + } + + @Override + public Object writeValue(long value) { + writable.set((byte) value); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("smallint")) { + return new VectorExpressionWriterLong() + { + private ShortWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new ShortWritable(); + return this; + } + + @Override + public Object writeValue(long value) { + writable.set((short) value); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("int")) { + return new VectorExpressionWriterLong() + { + private IntWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new IntWritable(); + return this; + } + + @Override + public Object writeValue(long value) { + writable.set((int) value); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("bigint")) { + return new VectorExpressionWriterLong() + { + private LongWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new LongWritable(); + return this; + } + + @Override + public Object writeValue(long value) { + writable.set(value); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("boolean")) { + return new VectorExpressionWriterLong() + { + private BooleanWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new BooleanWritable(); + return this; + } + + @Override + public Object writeValue(long value) { + writable.set(value != 0 ? true : false); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("timestamp")) { + return new VectorExpressionWriterLong() + { + private TimestampWritable writable; + private Timestamp timestamp; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new TimestampWritable(); + timestamp = new Timestamp(0); + return this; + } + + @Override + public Object writeValue(long value) { + TimestampUtils.assignTimeInNanoSec(value, timestamp); + writable.set(timestamp); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("string")) { + return new VectorExpressionWriterBytes() + { + private Text writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new Text(); + return this; + } + + @Override + public Object writeValue(byte[] value, int start, int length) throws HiveException { + writable.set(value, start, length); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("float")) { + return new VectorExpressionWriterDouble() + { + private FloatWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new FloatWritable(); + return this; + } + + @Override + public Object writeValue(double value) { + writable.set((float)value); + return writable; + } + }.init(nodeDesc); + } else if (nodeType.equalsIgnoreCase("double")) { + return new VectorExpressionWriterDouble() + { + private DoubleWritable writable; + @Override + public VectorExpressionWriter init(ExprNodeDesc nodeDesc) throws HiveException { + super.init(nodeDesc); + writable = new DoubleWritable(); + return this; + } + + @Override + public Object writeValue(double value) { + writable.set(value); + return writable; + } + }.init(nodeDesc); + } + + throw new HiveException(String.format( + "Unimplemented genVectorExpressionWritable type: %s for expression: %s", + nodeType, nodeDesc)); + } + + /** + * Helper function to create an array of writers from a list of expression descriptors. + */ + public static VectorExpressionWriter[] getExpressionWriters(List nodesDesc) + throws HiveException { + VectorExpressionWriter[] writers = new VectorExpressionWriter[nodesDesc.size()]; + for(int i=0; i nodesDesc, + List outputColumnNames, + Closure closure) + throws HiveException { + VectorExpressionWriter[] writers = getExpressionWriters(nodesDesc); + List oids = new ArrayList(writers.length); + for(int i=0; i outputNodeDescs = new ArrayList(); + for (StructField fieldRef : (objInspector) + .getAllStructFieldRefs()) { + String typeName = fieldRef.getFieldObjectInspector().getTypeName(); + TypeInfo ti = TypeInfoFactory.getPrimitiveTypeInfo(typeName); + outputNodeDescs.add(new ExprNodeDesc(ti) { + private static final long serialVersionUID = 1L; + + @Override + public ExprNodeDesc clone() { /* Not needed */ + return null; + } + + @Override + public boolean isSame(Object o) { /* Not needed */ + return false; + } + }); + } + return VectorExpressionWriterFactory.getExpressionWriters(outputNodeDescs); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFDayOfMonthLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFDayOfMonthLong.java new file mode 100644 index 0000000..bbd734c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFDayOfMonthLong.java @@ -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. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Expression to get day of month. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFDayOfMonthLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFDayOfMonthLong(int colNum, int outputColumn) { + super(Calendar.DAY_OF_MONTH, colNum, outputColumn); + } + + public VectorUDFDayOfMonthLong() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFHourLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFHourLong.java new file mode 100644 index 0000000..1d4d572 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFHourLong.java @@ -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. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Returns hour of day. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFHourLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFHourLong(int colNum, int outputColumn) { + super(Calendar.HOUR_OF_DAY, colNum, outputColumn); + } + + public VectorUDFHourLong() { + super(); + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMinuteLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMinuteLong.java new file mode 100644 index 0000000..4e3eede --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMinuteLong.java @@ -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. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Returns minute value. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFMinuteLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFMinuteLong(int colNum, int outputColumn) { + super(Calendar.MINUTE, colNum, outputColumn); + } + + public VectorUDFMinuteLong() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMonthLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMonthLong.java new file mode 100644 index 0000000..21552e1 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFMonthLong.java @@ -0,0 +1,45 @@ +/** + * 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.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Returns month value. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFMonthLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFMonthLong(int colNum, int outputColumn) { + super(Calendar.MONTH, colNum, outputColumn); + } + + public VectorUDFMonthLong() { + super(); + } + + @Override + protected long getField(long time) { + /* january is 0 */ + return 1 + super.getField(time); + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFSecondLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFSecondLong.java new file mode 100644 index 0000000..41655ec --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFSecondLong.java @@ -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. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Expression to get seconds. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFSecondLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFSecondLong(int colNum, int outputColumn) { + super(Calendar.SECOND, colNum, outputColumn); + } + + public VectorUDFSecondLong() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFTimestampFieldLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFTimestampFieldLong.java new file mode 100644 index 0000000..c19fd2a --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFTimestampFieldLong.java @@ -0,0 +1,163 @@ +/** + * 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.exec.vector.expressions; + +import java.sql.Timestamp; +import java.util.Calendar; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Abstract class to return various fields from a Timestamp. + */ +public abstract class VectorUDFTimestampFieldLong extends VectorExpression { + + private static final long serialVersionUID = 1L; + + protected int colNum; + protected int outputColumn; + protected int field; + protected transient final Calendar calendar = Calendar.getInstance(); + protected transient final Timestamp ts = new Timestamp(0); + + public VectorUDFTimestampFieldLong(int field, int colNum, int outputColumn) { + this(); + this.colNum = colNum; + this.outputColumn = outputColumn; + this.field = field; + } + + public VectorUDFTimestampFieldLong() { + super(); + } + + protected final Timestamp getTimestamp(long nanos) { + /* + * new Timestamp() stores the millisecond precision values in the nanos field. + * If you wanted to store 200ms it will result in nanos being set to 200*1000*1000. + * When you call setNanos(0), because there are no sub-ms times, it will set it to 0, + * ending up with a Timestamp which refers to 0ms by accident. + * CAVEAT: never use a sub-second value in new Timestamp() args, just use setNanos to set it. + */ + long ms = (nanos / (1000 * 1000 * 1000)) * 1000; + /* the milliseconds should be kept in nanos */ + long ns = nanos % (1000*1000*1000); + if (ns < 0) { + /* + * Due to the way java.sql.Timestamp stores sub-second values, it throws an exception + * if nano seconds are negative. The timestamp implementation handles this by using + * negative milliseconds and adjusting the nano seconds up by the same to be positive. + * Read Timestamp.java:setTime() implementation for this code. + */ + ms -= 1000; + ns += 1000*1000*1000; + } + ts.setTime(ms); + ts.setNanos((int) ns); + return ts; + } + + protected long getField(long time) { + calendar.setTime(getTimestamp(time)); + return calendar.get(field); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + LongColumnVector outV = (LongColumnVector) batch.cols[outputColumn]; + LongColumnVector inputCol = (LongColumnVector)batch.cols[this.colNum]; + /* every line below this is identical for evaluateLong & evaluateString */ + final int n = inputCol.isRepeating ? 1 : batch.size; + int[] sel = batch.selected; + + if(batch.size == 0) { + /* n != batch.size when isRepeating */ + return; + } + + /* true for all algebraic UDFs with no state */ + outV.isRepeating = inputCol.isRepeating; + + if (inputCol.noNulls) { + outV.noNulls = true; + if (batch.selectedInUse) { + for(int j=0; j < n; j++) { + int i = sel[j]; + outV.vector[i] = getField(inputCol.vector[i]); + } + } else { + for(int i = 0; i < n; i++) { + outV.vector[i] = getField(inputCol.vector[i]); + } + } + } else { + // Handle case with nulls. Don't do function if the value is null, to save time, + // because calling the function can be expensive. + outV.noNulls = false; + if (batch.selectedInUse) { + for(int j=0; j < n; j++) { + int i = sel[j]; + outV.isNull[i] = inputCol.isNull[i]; + if (!inputCol.isNull[i]) { + outV.vector[i] = getField(inputCol.vector[i]); + } + } + } else { + for(int i = 0; i < n; i++) { + outV.isNull[i] = inputCol.isNull[i]; + if (!inputCol.isNull[i]) { + outV.vector[i] = getField(inputCol.vector[i]); + } + } + } + } + } + + @Override + public int getOutputColumn() { + return this.outputColumn; + } + + @Override + public String getOutputType() { + return "long"; + } + + public int getColNum() { + return colNum; + } + + public void setColNum(int colNum) { + this.colNum = colNum; + } + + public int getField() { + return field; + } + + public void setField(int field) { + this.field = field; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFUnixTimeStampLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFUnixTimeStampLong.java new file mode 100644 index 0000000..0feed95 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFUnixTimeStampLong.java @@ -0,0 +1,49 @@ +/** + * 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.exec.vector.expressions; + +/** + * Return Unix Timestamp. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFUnixTimeStampLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + @Override + protected long getField(long time) { + long ms = (time / (1000*1000*1000)) * 1000; + long remainder = time % (1000*1000*1000); + /* negative timestamps need to be adjusted */ + if(remainder < 0) { + ms -= 1000; + } + return ms/1000; + } + + public VectorUDFUnixTimeStampLong(int colNum, int outputColumn) { + /* not a real field */ + super(-1, colNum, outputColumn); + } + + public VectorUDFUnixTimeStampLong() { + super(); + } + +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFWeekOfYearLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFWeekOfYearLong.java new file mode 100644 index 0000000..1ebadda --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFWeekOfYearLong.java @@ -0,0 +1,46 @@ +/** + * 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.exec.vector.expressions; + +import java.util.Calendar; + +/** + * Expression to get week of year. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFWeekOfYearLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + + public VectorUDFWeekOfYearLong(int colNum, int outputColumn) { + super(Calendar.WEEK_OF_YEAR, colNum, outputColumn); + initCalendar(); + } + + public VectorUDFWeekOfYearLong() { + super(); + initCalendar(); + } + + private void initCalendar() { + /* code copied over from UDFWeekOfYear implementation */ + calendar.setFirstDayOfWeek(Calendar.MONDAY); + calendar.setMinimalDaysInFirstWeek(4); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFYearLong.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFYearLong.java new file mode 100644 index 0000000..abd87fe --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/VectorUDFYearLong.java @@ -0,0 +1,67 @@ +/** + * 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.exec.vector.expressions; + +import java.util.Arrays; +import java.util.Calendar; + +/** + * Expression to get year as a long. + * Extends {@link VectorUDFTimestampFieldLong} + */ +public final class VectorUDFYearLong extends VectorUDFTimestampFieldLong { + + private static final long serialVersionUID = 1L; + /* year boundaries in nanoseconds */ + static transient final long[] YEAR_BOUNDARIES; + static transient final int MIN_YEAR = 1901; + static transient final int MAX_YEAR = 2038; + + static { + YEAR_BOUNDARIES = new long[MAX_YEAR-MIN_YEAR]; + Calendar c = Calendar.getInstance(); + c.setTimeInMillis(0); // c.set doesn't reset millis + /* 1901 Jan is not with in range */ + for(int year=MIN_YEAR+1; year <= 2038; year++) { + c.set(year, Calendar.JANUARY, 1, 0, 0, 0); + YEAR_BOUNDARIES[year-MIN_YEAR-1] = c.getTimeInMillis()*1000*1000; + } + } + + @Override + protected long getField(long time) { + /* binarySearch is faster than a loop doing a[i] (no array out of bounds checks) */ + int year = Arrays.binarySearch(YEAR_BOUNDARIES, time); + if(year >= 0) { + /* 0 == 1902 etc */ + return MIN_YEAR + 1 + year; + } else { + /* -1 == 1901, -2 == 1902 */ + return MIN_YEAR - 1 - year; + } + } + + public VectorUDFYearLong(int colNum, int outputColumn) { + super(Calendar.YEAR, colNum, outputColumn); + } + + public VectorUDFYearLong() { + super(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java new file mode 100644 index 0000000..1836169 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java @@ -0,0 +1,59 @@ +/** + * 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.exec.vector.expressions.aggregates; + +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; + +/** + * Base class for aggregation expressions. + */ +public abstract class VectorAggregateExpression implements Serializable { + + private static final long serialVersionUID = 1L; + + /** + * Buffer interface to store aggregates. + */ + public static interface AggregationBuffer extends Serializable { + int getVariableSize(); + }; + + public abstract AggregationBuffer getNewAggregationBuffer() throws HiveException; + public abstract void aggregateInput(AggregationBuffer agg, VectorizedRowBatch unit) + throws HiveException; + public abstract void aggregateInputSelection(VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, VectorizedRowBatch vrg) throws HiveException; + public abstract void reset(AggregationBuffer agg) throws HiveException; + public abstract Object evaluateOutput(AggregationBuffer agg) throws HiveException; + + public abstract ObjectInspector getOutputObjectInspector(); + public abstract int getAggregationBufferFixedSize(); + public boolean hasVariableSize() { + return false; + } + + public abstract void init(AggregationDesc desc) throws HiveException; +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCount.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCount.java new file mode 100644 index 0000000..086f91f --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCount.java @@ -0,0 +1,286 @@ +/** + * 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.exec.vector.expressions.aggregates; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.LongWritable; + + +/** + * VectorUDAFCountLong. Vectorized implementation for COUNT aggregates. + */ +@Description(name = "count", value = "_FUNC_(expr) - Returns the count (vectorized)") +public class VectorUDAFCount extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + * class for storing the current aggregate value. + */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private long value; + transient private boolean isNull; + + public void initIfNull() { + if (isNull) { + isNull = false; + value = 0; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + private VectorExpression inputExpression = null; + transient private final LongWritable result; + + public VectorUDAFCount(VectorExpression inputExpression) { + this(); + this.inputExpression = inputExpression; + } + + public VectorUDAFCount() { + super(); + result = new LongWritable(0); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregateIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + ColumnVector inputVector = batch.cols[this.inputExpression.getOutputColumn()]; + + if (inputVector.noNulls) { + // if there are no nulls then the iteration is the same on all cases + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, batchSize); + } else if (!batch.selectedInUse) { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + batchSize, inputVector.isNull); + } else if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, aggregateIndex, + batchSize, batch.selected, inputVector.isNull); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.initIfNull(); + myagg.value++; + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + i); + myagg.initIfNull(); + myagg.value++; + } + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + aggregateIndex, + j); + myagg.initIfNull(); + myagg.value++; + } + } + } + + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + ColumnVector inputVector = batch.cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + myagg.initIfNull(); + + if (inputVector.isRepeating) { + if (inputVector.noNulls || !inputVector.isNull[0]) { + myagg.value += batchSize; + } + return; + } + + if (inputVector.noNulls) { + myagg.value += batchSize; + return; + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, batchSize, inputVector.isNull); + } + else { + iterateSelectionHasNulls(myagg, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + myagg.value += 1; + } + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + int batchSize, + boolean[] isNull) { + + for (int i=0; i< batchSize; ++i) { + if (!isNull[i]) { + myagg.value += 1; + } + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput(AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + result.set (myagg.value); + return result; + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return PrimitiveObjectInspectorFactory.writableLongObjectInspector; + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.primitive2() + + model.primitive1(), + model.memoryAlign()); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + // No-op + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCountStar.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCountStar.java new file mode 100644 index 0000000..4926f6c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFCountStar.java @@ -0,0 +1,155 @@ +/** + * 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.exec.vector.expressions.aggregates; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.io.LongWritable; + +/** + * VectorUDAFCountStar. Vectorized implementation for COUNT(*) aggregates. + */ +@Description(name = "count", value = "_FUNC_(expr) - Returns count(*) (vectorized)") +public class VectorUDAFCountStar extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** + * class for storing the current aggregate value. + */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private long value; + transient private boolean isNull; + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + } + + transient private final LongWritable result; + + public VectorUDAFCountStar(VectorExpression inputExpression) { + this(); + } + + public VectorUDAFCountStar() { + super(); + result = new LongWritable(0); + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(aggregateIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int aggregateIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + // count(*) cares not about NULLs nor selection + for (int i=0; i < batchSize; ++i) { + Aggregation myAgg = getCurrentAggregationBuffer( + aggregationBufferSets, aggregateIndex, i); + myAgg.isNull = false; + ++myAgg.value; + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + myagg.isNull = false; + myagg.value += batchSize; + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.isNull = true; + } + + @Override + public Object evaluateOutput(AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + if (myagg.isNull) { + return null; + } + else { + result.set (myagg.value); + return result; + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { + return PrimitiveObjectInspectorFactory.writableLongObjectInspector; + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.primitive2() + + model.primitive1(), + model.memoryAlign()); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + // No-op + } +} + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFAdaptor.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFAdaptor.java new file mode 100644 index 0000000..9716f88 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFAdaptor.java @@ -0,0 +1,346 @@ +/** + * 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.exec.vector.udf; + +import org.apache.hadoop.hive.ql.exec.ExprNodeEvaluator; +import org.apache.hadoop.hive.ql.exec.ExprNodeGenericFuncEvaluator; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriterFactory; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF.DeferredObject; +import org.apache.hadoop.hive.serde2.objectinspector.ConstantObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.LongObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableBooleanObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableByteObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableDoubleObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableFloatObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableIntObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableLongObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableShortObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableStringObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.WritableTimestampObjectInspector; +import org.apache.hadoop.io.Text; + +import java.io.IOException; +import java.io.Serializable; +import java.sql.Timestamp; +import java.util.ArrayList; + +/** + * A VectorUDFAdaptor is a vectorized expression for invoking a custom + * UDF on zero or more input vectors or constants which are the function arguments. + */ +public class VectorUDFAdaptor extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int outputColumn; + private String resultType; + private VectorUDFArgDesc[] argDescs; + private ExprNodeGenericFuncDesc expr; + + private transient GenericUDF genericUDF; + private transient GenericUDF.DeferredObject[] deferredChildren; + private transient ObjectInspector outputOI; + private transient ObjectInspector[] childrenOIs; + private transient VectorExpressionWriter[] writers; + + public VectorUDFAdaptor() { + super(); + } + + public VectorUDFAdaptor ( + ExprNodeGenericFuncDesc expr, + int outputColumn, + String resultType, + VectorUDFArgDesc[] argDescs) throws HiveException { + + this(); + this.expr = expr; + this.outputColumn = outputColumn; + this.resultType = resultType; + this.argDescs = argDescs; + } + + // Initialize transient fields. To be called after deserialization of other fields. + public void init() throws HiveException, UDFArgumentException { + genericUDF = expr.getGenericUDF(); + deferredChildren = new GenericUDF.DeferredObject[expr.getChildExprs().size()]; + childrenOIs = new ObjectInspector[expr.getChildExprs().size()]; + writers = VectorExpressionWriterFactory.getExpressionWriters(expr.getChildExprs()); + for (int i = 0; i < childrenOIs.length; i++) { + childrenOIs[i] = writers[i].getObjectInspector(); + } + outputOI = VectorExpressionWriterFactory.genVectorExpressionWritable(expr) + .getObjectInspector(); + + genericUDF.initialize(childrenOIs); + + // Initialize constant arguments + for (int i = 0; i < argDescs.length; i++) { + if (argDescs[i].isConstant()) { + argDescs[i].prepareConstant(); + } + } + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (genericUDF == null) { + try { + init(); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + int[] sel = batch.selected; + int n = batch.size; + ColumnVector outV = batch.cols[outputColumn]; + + // If the output column is of type string, initialize the buffer to receive data. + if (outV instanceof BytesColumnVector) { + ((BytesColumnVector) outV).initBuffer(); + } + + if (n == 0) { + //Nothing to do + return; + } + + batch.cols[outputColumn].noNulls = true; + + /* If all input columns are repeating, just evaluate function + * for row 0 in the batch and set output repeating. + */ + if (allInputColsRepeating(batch)) { + setResult(0, batch); + batch.cols[outputColumn].isRepeating = true; + return; + } else { + batch.cols[outputColumn].isRepeating = false; + } + + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + setResult(i, batch); + } + } else { + for (int i = 0; i != n; i++) { + setResult(i, batch); + } + } + } + + /* Return false if any input column is non-repeating, otherwise true. + * This returns false if all the arguments are constant or there + * are zero arguments. + * + * A possible future optimization is to set the output to isRepeating + * for cases of all-constant arguments for deterministic functions. + */ + private boolean allInputColsRepeating(VectorizedRowBatch batch) { + int varArgCount = 0; + for (int i = 0; i < argDescs.length; i++) { + if (argDescs[i].isVariable() && !batch.cols[argDescs[i].getColumnNum()].isRepeating) { + return false; + } + varArgCount += 1; + } + if (varArgCount > 0) { + return true; + } else { + return false; + } + } + + /* Calculate the function result for row i of the batch and + * set the output column vector entry i to the result. + */ + private void setResult(int i, VectorizedRowBatch b) { + + // get arguments + for (int j = 0; j < argDescs.length; j++) { + deferredChildren[j] = argDescs[j].getDeferredJavaObject(i, b, j, writers); + } + + // call function + Object result; + try { + result = genericUDF.evaluate(deferredChildren); + } catch (HiveException e) { + + /* For UDFs that expect primitive types (like int instead of Integer or IntWritable), + * this will catch the the exception that happens if they are passed a NULL value. + * Then the default NULL handling logic will apply, and the result will be NULL. + */ + result = null; + } + + // set output column vector entry + if (result == null) { + b.cols[outputColumn].noNulls = false; + b.cols[outputColumn].isNull[i] = true; + } else { + b.cols[outputColumn].isNull[i] = false; + setOutputCol(b.cols[outputColumn], i, result); + } + } + + private void setOutputCol(ColumnVector colVec, int i, Object value) { + + /* Depending on the output type, get the value, cast the result to the + * correct type if needed, and assign the result into the output vector. + */ + if (outputOI instanceof WritableStringObjectInspector) { + BytesColumnVector bv = (BytesColumnVector) colVec; + Text t; + if (value instanceof String) { + t = new Text((String) value); + } else { + t = ((WritableStringObjectInspector) outputOI).getPrimitiveWritableObject(value); + } + bv.setVal(i, t.getBytes(), 0, t.getLength()); + } else if (outputOI instanceof WritableIntObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + if (value instanceof Integer) { + lv.vector[i] = (Integer) value; + } else { + lv.vector[i] = ((WritableIntObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableLongObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + if (value instanceof Long) { + lv.vector[i] = (Long) value; + } else { + lv.vector[i] = ((WritableLongObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableDoubleObjectInspector) { + DoubleColumnVector dv = (DoubleColumnVector) colVec; + if (value instanceof Double) { + dv.vector[i] = (Double) value; + } else { + dv.vector[i] = ((WritableDoubleObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableFloatObjectInspector) { + DoubleColumnVector dv = (DoubleColumnVector) colVec; + if (value instanceof Float) { + dv.vector[i] = (Float) value; + } else { + dv.vector[i] = ((WritableFloatObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableShortObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + if (value instanceof Short) { + lv.vector[i] = (Short) value; + } else { + lv.vector[i] = ((WritableShortObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableByteObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + if (value instanceof Byte) { + lv.vector[i] = (Byte) value; + } else { + lv.vector[i] = ((WritableByteObjectInspector) outputOI).get(value); + } + } else if (outputOI instanceof WritableTimestampObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + Timestamp ts; + if (value instanceof Timestamp) { + ts = (Timestamp) value; + } else { + ts = ((WritableTimestampObjectInspector) outputOI).getPrimitiveJavaObject(value); + } + /* Calculate the number of nanoseconds since the epoch as a long integer. By convention + * that is how Timestamp values are operated on in a vector. + */ + long l = ts.getTime() * 1000000 // Shift the milliseconds value over by 6 digits + // to scale for nanosecond precision. + // The milliseconds digits will by convention be all 0s. + + ts.getNanos() % 1000000; // Add on the remaining nanos. + // The % 1000000 operation removes the ms values + // so that the milliseconds are not counted twice. + lv.vector[i] = l; + } else if (outputOI instanceof WritableBooleanObjectInspector) { + LongColumnVector lv = (LongColumnVector) colVec; + if (value instanceof Boolean) { + lv.vector[i] = (Boolean) value ? 1 : 0; + } else { + lv.vector[i] = ((WritableBooleanObjectInspector) outputOI).get(value) ? 1 : 0; + } + } else { + throw new RuntimeException("Unhandled object type " + outputOI.getTypeName()); + } + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + public void setOutputColumn(int outputColumn) { + this.outputColumn = outputColumn; + } + + @Override + public String getOutputType() { + return resultType; + } + + public String getResultType() { + return resultType; + } + + public void setResultType(String resultType) { + this.resultType = resultType; + } + + public VectorUDFArgDesc[] getArgDescs() { + return argDescs; + } + + public void setArgDescs(VectorUDFArgDesc[] argDescs) { + this.argDescs = argDescs; + } + + public ExprNodeGenericFuncDesc getExpr() { + return expr; + } + + public void setExpr(ExprNodeGenericFuncDesc expr) { + this.expr = expr; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFArgDesc.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFArgDesc.java new file mode 100644 index 0000000..e3c5b7f --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/udf/VectorUDFArgDesc.java @@ -0,0 +1,138 @@ +/** + * 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.exec.vector.udf; + +import java.io.IOException; +import java.io.Serializable; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF.DeferredObject; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector.PrimitiveCategory; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo; + +/** + * Descriptor for function argument. + */ +public class VectorUDFArgDesc implements Serializable { + + private static final long serialVersionUID = 1L; + + private boolean isConstant; + private int columnNum; + private transient GenericUDF.DeferredJavaObject constObjVal; + private ExprNodeConstantDesc constExpr; + + public VectorUDFArgDesc() { + } + + /** + * Set this argument to a constant value extracted from the + * expression tree. + */ + public void setConstant(ExprNodeConstantDesc expr) { + isConstant = true; + constExpr = expr; + } + + /* Prepare the constant for use when the function is called. To be used + * during initialization. + */ + public void prepareConstant() { + PrimitiveCategory pc = ((PrimitiveTypeInfo) constExpr.getTypeInfo()) + .getPrimitiveCategory(); + + // Convert from Java to Writable + Object writableValue = PrimitiveObjectInspectorFactory + .getPrimitiveJavaObjectInspector(pc).getPrimitiveWritableObject( + constExpr.getValue()); + + constObjVal = new GenericUDF.DeferredJavaObject(writableValue); + } + + /** + * Set this argument to be a "variable" one which is to be taken from + * a specified column vector number i. + */ + public void setVariable(int i) { + columnNum = i; + } + + public boolean isConstant() { + return isConstant; + } + + public boolean isVariable() { + return !isConstant; + } + + public int getColumn() { + return columnNum; + } + + public DeferredObject getDeferredJavaObject(int row, VectorizedRowBatch b, int argPosition, + VectorExpressionWriter[] writers) { + + if (isConstant()) { + return this.constObjVal; + } else { + + // get column + ColumnVector cv = b.cols[columnNum]; + + // write value to object that can be inspected + Object o; + try { + o = writers[argPosition].writeValue(cv, row); + return new GenericUDF.DeferredJavaObject(o); + } catch (HiveException e) { + throw new RuntimeException("Unable to get Java object from VectorizedRowBatch"); + } + } + } + + public boolean getIsConstant() { + return isConstant; + } + + public void setIsConstant(boolean isConstant) { + this.isConstant = isConstant; + } + + public int getColumnNum() { + return columnNum; + } + + public void setColumnNum(int columnNum) { + this.columnNum = columnNum; + } + + public ExprNodeConstantDesc getConstExpr() { + return constExpr; + } + + public void setConstExpr(ExprNodeConstantDesc constExpr) { + this.constExpr = constExpr; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/io/CommonRCFileInputFormat.java ql/src/java/org/apache/hadoop/hive/ql/io/CommonRCFileInputFormat.java new file mode 100644 index 0000000..4bfeb20 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/io/CommonRCFileInputFormat.java @@ -0,0 +1,145 @@ +/** + * 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.io; + +import java.io.IOException; +import java.util.ArrayList; + +import org.apache.hadoop.fs.FileStatus; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedInputFormatInterface; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.serde2.columnar.BytesRefArrayWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Writable; +import org.apache.hadoop.mapred.FileInputFormat; +import org.apache.hadoop.mapred.InputSplit; +import org.apache.hadoop.mapred.JobConf; +import org.apache.hadoop.mapred.RecordReader; +import org.apache.hadoop.mapred.Reporter; + +/** + * CommonRCFileInputFormat. + * Wrapper class that calls the correct input format for RC file base on + * HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED parameter + */ +public class CommonRCFileInputFormat extends FileInputFormat + implements InputFormatChecker, VectorizedInputFormatInterface{ + + RCFileInputFormat rcif = + new RCFileInputFormat(); + VectorizedRCFileInputFormat vrcif = new VectorizedRCFileInputFormat(); + + private static class CommonOrcRecordReader + implements RecordReader { + + final RecordReader vrcrr; + final RecordReader rcrr; + + public CommonOrcRecordReader(RecordReader vrcrr, + RecordReader rcrr) { + this.vrcrr = vrcrr; + this.rcrr = rcrr; + } + + @Override + public void close() throws IOException { + if (vrcrr != null) { + vrcrr.close(); + } else { + rcrr.close(); + } + + } + + @Override + public Writable createKey() { + if (vrcrr != null) { + return vrcrr.createKey(); + } else { + return rcrr.createKey(); + } + } + + @Override + public Writable createValue() { + if (vrcrr != null) { + return vrcrr.createValue(); + } else { + return rcrr.createValue(); + } + } + + @Override + public long getPos() throws IOException { + if (vrcrr != null) { + return vrcrr.getPos(); + } else { + return rcrr.getPos(); + } + } + + @Override + public float getProgress() throws IOException { + if (vrcrr != null) { + return vrcrr.getProgress(); + } else { + return rcrr.getProgress(); + } + } + + @Override + public boolean next(Writable arg0, Writable arg1) throws IOException { + if (vrcrr != null) { + return vrcrr.next(NullWritable.get(), (VectorizedRowBatch) arg1); + } else { + LongWritable d = new LongWritable(); + return rcrr.next(d, (BytesRefArrayWritable) arg1); + } + } + + } + + @Override + public boolean validateInput(FileSystem fs, HiveConf conf, ArrayList files) + throws IOException { + boolean vectorPath = + conf.getBoolean(HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED.toString(), true); + if (vectorPath) { + return vrcif.validateInput(fs, conf, files); + } else { + return rcif.validateInput(fs, conf, files); + } + } + + @Override + public RecordReader getRecordReader(InputSplit split, JobConf conf, + Reporter reporter) throws IOException { + boolean vectorPath = conf.getBoolean(HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED.toString(), true); + if (vectorPath) { + RecordReader vrcrr = vrcif.getRecordReader(split, conf, reporter); + return new CommonOrcRecordReader(vrcrr, null); + } else { + RecordReader rcrr = rcif.getRecordReader(split, conf, reporter); + return new CommonOrcRecordReader(null, rcrr); + } + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileInputFormat.java ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileInputFormat.java new file mode 100644 index 0000000..faad5f2 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileInputFormat.java @@ -0,0 +1,80 @@ +/** + * 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.io; + +import java.io.IOException; +import java.util.ArrayList; + +import org.apache.hadoop.fs.FileStatus; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.SequenceFile; +import org.apache.hadoop.mapred.FileInputFormat; +import org.apache.hadoop.mapred.FileSplit; +import org.apache.hadoop.mapred.InputSplit; +import org.apache.hadoop.mapred.JobConf; +import org.apache.hadoop.mapred.RecordReader; +import org.apache.hadoop.mapred.Reporter; + +/** + * A MapReduce/Hive Vectorized input format for RC files. + */ +public class VectorizedRCFileInputFormat extends FileInputFormat + implements InputFormatChecker { + + public VectorizedRCFileInputFormat() { + setMinSplitSize(SequenceFile.SYNC_INTERVAL); + } + + @Override + @SuppressWarnings("unchecked") + public RecordReader getRecordReader(InputSplit split, JobConf job, + Reporter reporter) throws IOException { + + reporter.setStatus(split.toString()); + + return new VectorizedRCFileRecordReader(job, (FileSplit) split); + } + + @Override + public boolean validateInput(FileSystem fs, HiveConf conf, + ArrayList files) throws IOException { + if (files.size() <= 0) { + return false; + } + for (int fileId = 0; fileId < files.size(); fileId++) { + RCFile.Reader reader = null; + try { + reader = new RCFile.Reader(fs, files.get(fileId) + .getPath(), conf); + reader.close(); + reader = null; + } catch (IOException e) { + return false; + } finally { + if (null != reader) { + reader.close(); + } + } + } + return true; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileRecordReader.java ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileRecordReader.java new file mode 100644 index 0000000..bc19fb4 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/io/VectorizedRCFileRecordReader.java @@ -0,0 +1,261 @@ +/** + * 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.io; + +import java.io.IOException; +import java.util.Collections; +import java.util.Map; +import java.util.WeakHashMap; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedBatchUtil; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatchCtx; +import org.apache.hadoop.hive.ql.io.RCFile.KeyBuffer; +import org.apache.hadoop.hive.ql.io.RCFile.Reader; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.columnar.BytesRefArrayWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.io.Writable; +import org.apache.hadoop.mapred.FileSplit; +import org.apache.hadoop.mapred.RecordReader; + +/** + * RCFileRecordReader. + * + * @param + * @param + */ +public class VectorizedRCFileRecordReader implements RecordReader { + + private final Reader in; + private final long start; + private final long end; + private boolean more = true; + protected Configuration conf; + private final FileSplit split; + private final boolean useCache; + private VectorizedRowBatchCtx rbCtx; + private final LongWritable keyCache = new LongWritable(); + private final BytesRefArrayWritable colsCache = new BytesRefArrayWritable(); + private boolean addPartitionCols = true; + + private static RCFileSyncCache syncCache = new RCFileSyncCache(); + + private static final class RCFileSyncEntry { + long end; + long endSync; + } + + private static final class RCFileSyncCache { + + private final Map cache; + + public RCFileSyncCache() { + cache = Collections.synchronizedMap(new WeakHashMap()); + } + + public void put(FileSplit split, long endSync) { + Path path = split.getPath(); + long end = split.getStart() + split.getLength(); + String key = path.toString() + "+" + String.format("%d", end); + + RCFileSyncEntry entry = new RCFileSyncEntry(); + entry.end = end; + entry.endSync = endSync; + if (entry.endSync >= entry.end) { + cache.put(key, entry); + } + } + + public long get(FileSplit split) { + Path path = split.getPath(); + long start = split.getStart(); + String key = path.toString() + "+" + String.format("%d", start); + RCFileSyncEntry entry = cache.get(key); + if (entry != null) { + return entry.endSync; + } + return -1; + } + } + + public VectorizedRCFileRecordReader(Configuration conf, FileSplit split) + throws IOException { + + Path path = split.getPath(); + FileSystem fs = path.getFileSystem(conf); + this.in = new RCFile.Reader(fs, path, conf); + this.end = split.getStart() + split.getLength(); + this.conf = conf; + this.split = split; + + useCache = HiveConf.getBoolVar(conf, HiveConf.ConfVars.HIVEUSERCFILESYNCCACHE); + + if (split.getStart() > in.getPosition()) { + long oldSync = useCache ? syncCache.get(split) : -1; + if (oldSync == -1) { + in.sync(split.getStart()); // sync to start + } else { + in.seek(oldSync); + } + } + + this.start = in.getPosition(); + + more = start < end; + try { + rbCtx = new VectorizedRowBatchCtx(); + rbCtx.init(conf, split); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + public Class getKeyClass() { + return LongWritable.class; + } + + public Class getValueClass() { + return BytesRefArrayWritable.class; + } + + @Override + public NullWritable createKey() { + return NullWritable.get(); + } + + @Override + public VectorizedRowBatch createValue() { + VectorizedRowBatch result = null; + try { + result = rbCtx.createVectorizedRowBatch(); + } catch (HiveException e) { + new RuntimeException("Error creating a batch", e); + } + return result; + } + + public boolean nextBlock() throws IOException { + return in.nextBlock(); + } + + @Override + public boolean next(NullWritable key, VectorizedRowBatch value) throws IOException { + + // Reset column fields noNull values to true + VectorizedBatchUtil.SetNoNullFields(true, value); + value.selectedInUse = false; + for (int i = 0; i < value.numCols; i++) { + value.cols[i].isRepeating = false; + } + + int i = 0; + try { + + for (; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + more = next(keyCache); + if (more) { + // Check and update partition cols if necessary. Ideally this should be done + // in CreateValue() as the partition is constant per split. But since Hive uses + // CombineHiveRecordReader and as this does not call CreateValue() for + // each new RecordReader it creates, this check is required in next() + if (addPartitionCols) { + rbCtx.addPartitionColsToBatch(value); + addPartitionCols = false; + } + in.getCurrentRow(colsCache); + // Currently RCFile reader does not support reading vectorized + // data. Populating the batch by adding one row at a time. + rbCtx.addRowToBatch(i, (Writable) colsCache, value); + } else { + break; + } + } + } catch (Exception e) { + new RuntimeException("Error while getting next row", e); + } + value.size = i; + return more; + } + + protected boolean next(LongWritable key) throws IOException { + if (!more) { + return false; + } + + more = in.next(key); + + long lastSeenSyncPos = in.lastSeenSyncPos(); + + if (lastSeenSyncPos >= end) { + if (useCache) { + syncCache.put(split, lastSeenSyncPos); + } + more = false; + return more; + } + return more; + } + + /** + * Return the progress within the input split. + * + * @return 0.0 to 1.0 of the input byte range + */ + public float getProgress() throws IOException { + if (end == start) { + return 0.0f; + } else { + return Math.min(1.0f, (in.getPosition() - start) / (float) (end - start)); + } + } + + public long getPos() throws IOException { + return in.getPosition(); + } + + public KeyBuffer getKeyBuffer() { + return in.getCurrentKeyBufferObj(); + } + + protected void seek(long pos) throws IOException { + in.seek(pos); + } + + public void sync(long pos) throws IOException { + in.sync(pos); + } + + public void resetBuffer() { + in.resetBuffer(); + } + + public long getStart() { + return start; + } + + public void close() throws IOException { + in.close(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/BitFieldReader.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/BitFieldReader.java index f0be6df..f90f43c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/BitFieldReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/BitFieldReader.java @@ -20,8 +20,10 @@ import java.io.EOFException; import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; + class BitFieldReader { - private RunLengthByteReader input; + private final RunLengthByteReader input; private final int bitSize; private int current; private int bitsLeft; @@ -60,6 +62,30 @@ int next() throws IOException { return result & mask; } + void nextVector(LongColumnVector previous, long previousLen) + throws IOException { + + previous.isRepeating = true; + for (int i = 0; i < previousLen; i++) { + if (!previous.isNull[i]) { + previous.vector[i] = next(); + } else { + // The default value of null for int types in vectorized + // processing is 1, so set that if the value is null + previous.vector[i] = 1; + } + + // The default value for nulls in Vectorization for int types is 1 + // and given that non null value can also be 1, we need to check for isNull also + // when determining the isRepeating flag. + if (previous.isRepeating + && i > 0 + && ((previous.vector[i - 1] != previous.vector[i]) || (previous.isNull[i - 1] != previous.isNull[i]))) { + previous.isRepeating = false; + } + } + } + void seek(PositionProvider index) throws IOException { input.seek(index); int consumed = (int) index.getNext(); diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/DynamicByteArray.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/DynamicByteArray.java index 248cea9..f0c1b73 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/DynamicByteArray.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/DynamicByteArray.java @@ -17,13 +17,13 @@ */ package org.apache.hadoop.hive.ql.io.orc; -import org.apache.hadoop.io.Text; - import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; +import org.apache.hadoop.io.Text; + /** * A class that is a growable array of bytes. Growth is managed in terms of * chunks that are allocated when needed. @@ -237,6 +237,7 @@ public void write(OutputStream out, int offset, } } + @Override public String toString() { int i; StringBuilder sb = new StringBuilder(length * 3); @@ -268,10 +269,35 @@ public void setByteBuffer(ByteBuffer result, int offset, int length) { } /** + * Gets all the bytes of the array. + * + * @return Bytes of the array + */ + public byte[] get() { + byte[] result = null; + if (length > 0) { + int currentChunk = 0; + int currentOffset = 0; + int currentLength = Math.min(length, chunkSize); + int destOffset = 0; + result = new byte[length]; + int totalLength = length; + while (totalLength > 0) { + System.arraycopy(data[currentChunk], currentOffset, result, destOffset, currentLength); + destOffset += currentLength; + totalLength -= currentLength; + currentChunk += 1; + currentOffset = 0; + currentLength = Math.min(totalLength, chunkSize - currentOffset); + } + } + return result; + } + + /** * Get the size of the buffers. */ public long getSizeInBytes() { return initializedChunks * chunkSize; } } - diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/IntegerReader.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/IntegerReader.java index 04cfa58..f3a8c19 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/IntegerReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/IntegerReader.java @@ -19,6 +19,7 @@ package org.apache.hadoop.hive.ql.io.orc; import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; /** * Interface for reading integers. @@ -52,4 +53,12 @@ * @throws IOException */ long next() throws IOException; + + /** + * Return the next available vector for values. + * @return + * @throws IOException + */ + void nextVector(LongColumnVector previous, long previousLen) + throws IOException; } diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcInputFormat.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcInputFormat.java index 51863fc..810170a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcInputFormat.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcInputFormat.java @@ -27,7 +27,6 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; - import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; @@ -38,6 +37,8 @@ import org.apache.hadoop.fs.PathFilter; import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.ql.exec.Utilities; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedInputFormatInterface; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.io.InputFormatChecker; import org.apache.hadoop.hive.ql.io.sarg.SearchArgument; import org.apache.hadoop.hive.ql.plan.TableScanDesc; @@ -54,12 +55,13 @@ import org.apache.hadoop.mapred.RecordReader; import org.apache.hadoop.mapred.Reporter; import org.apache.hadoop.util.StringUtils; - /** * A MapReduce/Hive input format for ORC files. */ -public class OrcInputFormat implements InputFormat, - InputFormatChecker { +public class OrcInputFormat implements InputFormat, + InputFormatChecker, VectorizedInputFormatInterface { + + VectorizedOrcInputFormat voif = new VectorizedOrcInputFormat(); private static final Log LOG = LogFactory.getLog(OrcInputFormat.class); static final String MIN_SPLIT_SIZE = "mapred.min.split.size"; @@ -85,6 +87,7 @@ private final int numColumns; private float progress = 0.0f; + OrcRecordReader(Reader file, Configuration conf, long offset, long length) throws IOException { String serializedPushdown = conf.get(TableScanDesc.FILTER_EXPR_CONF_STR); @@ -219,6 +222,12 @@ static void includeColumnRecursive(List types, public RecordReader getRecordReader(InputSplit inputSplit, JobConf conf, Reporter reporter) throws IOException { + if (isVectorMode(conf)) { + RecordReader vorr = voif.getRecordReader(inputSplit, conf, + reporter); + return (RecordReader) vorr; + } + FileSplit fileSplit = (FileSplit) inputSplit; Path path = fileSplit.getPath(); FileSystem fs = path.getFileSystem(conf); @@ -231,6 +240,11 @@ static void includeColumnRecursive(List types, public boolean validateInput(FileSystem fs, HiveConf conf, ArrayList files ) throws IOException { + + if (isVectorMode(conf)) { + return voif.validateInput(fs, conf, files); + } + if (files.size() <= 0) { return false; } @@ -244,6 +258,14 @@ public boolean validateInput(FileSystem fs, HiveConf conf, return true; } + private boolean isVectorMode(Configuration conf) { + if (Utilities.getPlanPath(conf) != null && Utilities + .getMapRedWork(conf).getMapWork().getVectorMode()) { + return true; + } + return false; + } + /** * Get the list of input {@link Path}s for the map-reduce job. * diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcSerde.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcSerde.java index 8b46370..d765353 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcSerde.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/OrcSerde.java @@ -17,9 +17,16 @@ */ package org.apache.hadoop.hive.ql.io.orc; +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Properties; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedSerde; import org.apache.hadoop.hive.serde2.SerDe; import org.apache.hadoop.hive.serde2.SerDeException; import org.apache.hadoop.hive.serde2.SerDeStats; @@ -29,26 +36,22 @@ import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoUtils; import org.apache.hadoop.io.Writable; -import java.io.DataInput; -import java.io.DataOutput; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Properties; - /** * A serde class for ORC. * It transparently passes the object to/from the ORC file reader/writer. */ -public class OrcSerde implements SerDe { +public class OrcSerde implements SerDe, VectorizedSerde { private static final Log LOG = LogFactory.getLog(OrcSerde.class); private final OrcSerdeRow row = new OrcSerdeRow(); private ObjectInspector inspector = null; + private VectorizedOrcSerde vos = null; + final class OrcSerdeRow implements Writable { - private Object realRow; - private ObjectInspector inspector; + Object realRow; + ObjectInspector inspector; @Override public void write(DataOutput dataOutput) throws IOException { @@ -79,7 +82,7 @@ public void initialize(Configuration conf, Properties table) { // Parse the configuration parameters ArrayList columnNames = new ArrayList(); if (columnNameProperty != null && columnNameProperty.length() > 0) { - for(String name: columnNameProperty.split(",")) { + for (String name : columnNameProperty.split(",")) { columnNames.add(name); } } @@ -96,7 +99,7 @@ public void initialize(Configuration conf, Properties table) { } ArrayList fieldTypes = - TypeInfoUtils.getTypeInfosFromTypeString(columnTypeProperty); + TypeInfoUtils.getTypeInfosFromTypeString(columnTypeProperty); StructTypeInfo rootType = new StructTypeInfo(); rootType.setAllStructFieldNames(columnNames); rootType.setAllStructFieldTypeInfos(fieldTypes); @@ -128,6 +131,7 @@ public ObjectInspector getObjectInspector() throws SerDeException { /** * Always returns null, since serialized size doesn't make sense in the * context of ORC files. + * * @return null */ @Override @@ -135,4 +139,18 @@ public SerDeStats getSerDeStats() { return null; } + @Override + public Writable serializeVector(VectorizedRowBatch vrg, ObjectInspector objInspector) + throws SerDeException { + if (vos == null) { + vos = new VectorizedOrcSerde(objInspector); + } + return vos.serialize(vrg, objInspector); + } + + @Override + public void deserializeVector(Object rowBlob, int rowsInBatch, VectorizedRowBatch reuseBatch) + throws SerDeException { + // nothing to do here + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReader.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReader.java index 05240ce..dba9071 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReader.java @@ -19,6 +19,8 @@ import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + /** * A row-by-row iterator for ORC files. */ @@ -39,6 +41,16 @@ Object next(Object previous) throws IOException; /** + * Read the next row batch. The size of the batch to read cannot be controlled + * by the callers. Caller need to look at VectorizedRowBatch.size of the retunred + * object to know the batch size read. + * @param previousBatch a row batch object that can be reused by the reader + * @return the row batch that was read + * @throws java.io.IOException + */ + VectorizedRowBatch nextBatch(VectorizedRowBatch previousBatch) throws IOException; + + /** * Get the row number of the row that will be returned by the following * call to next(). * @return the row number from 0 to the number of rows in the file diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReaderImpl.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReaderImpl.java index 81c914c..f18d36b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReaderImpl.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/RecordReaderImpl.java @@ -27,15 +27,17 @@ import java.util.List; import java.util.Map; - import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hive.common.type.HiveDecimal; -import org.apache.hadoop.hive.ql.io.orc.RunLengthIntegerWriterV2.EncodingType; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.io.sarg.PredicateLeaf; import org.apache.hadoop.hive.ql.io.sarg.SearchArgument; import org.apache.hadoop.hive.ql.io.sarg.SearchArgument.TruthValue; @@ -234,6 +236,38 @@ Object next(Object previous) throws IOException { } return previous; } + /** + * Populates the isNull vector array in the previousVector object based on + * the present stream values. This function is called from all the child + * readers, and they all set the values based on isNull field value. + * @param previousVector The columnVector object whose isNull value is populated + * @param batchSize Size of the column vector + * @return + * @throws IOException + */ + Object nextVector(Object previousVector, long batchSize) throws IOException { + + ColumnVector result = (ColumnVector) previousVector; + if (present != null) { + // Set noNulls and isNull vector of the ColumnVector based on + // present stream + result.noNulls = true; + for (int i = 0; i < batchSize; i++) { + result.isNull[i] = (present.next() != 1); + if (result.noNulls && result.isNull[i]) { + result.noNulls = false; + } + } + } else { + // There is not present stream, this means that all the values are + // present. + result.noNulls = true; + for (int i = 0; i < batchSize; i++) { + result.isNull[i] = false; + } + } + return previousVector; + } } private static class BooleanTreeReader extends TreeReader{ @@ -277,6 +311,23 @@ Object next(Object previous) throws IOException { } return result; } + + @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + reader.nextVector(result, batchSize); + return result; + } } private static class ByteTreeReader extends TreeReader{ @@ -317,6 +368,23 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + reader.nextVector(result, batchSize); + return result; + } + + @Override void skipRows(long items) throws IOException { reader.skip(countNonNulls(items)); } @@ -370,6 +438,23 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + reader.nextVector(result, batchSize); + return result; + } + + @Override void skipRows(long items) throws IOException { reader.skip(countNonNulls(items)); } @@ -423,6 +508,23 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + reader.nextVector(result, batchSize); + return result; + } + + @Override void skipRows(long items) throws IOException { reader.skip(countNonNulls(items)); } @@ -476,6 +578,23 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + reader.nextVector(result, batchSize); + return result; + } + + @Override void skipRows(long items) throws IOException { reader.skip(countNonNulls(items)); } @@ -520,6 +639,39 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + DoubleColumnVector result = null; + if (previousVector == null) { + result = new DoubleColumnVector(); + } else { + result = (DoubleColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + for (int i = 0; i < batchSize; i++) { + if (!result.isNull[i]) { + result.vector[i] = SerializationUtils.readFloat(stream); + } else { + + // If the value is not present then set NaN + result.vector[i] = Double.NaN; + } + } + + // Set isRepeating flag + result.isRepeating = true; + for (int i = 0; (i < batchSize - 1 && result.isRepeating); i++) { + if (result.vector[i] != result.vector[i + 1]) { + result.isRepeating = false; + } + } + return result; + } + + @Override void skipRows(long items) throws IOException { items = countNonNulls(items); for(int i=0; i < items; ++i) { @@ -568,6 +720,38 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + DoubleColumnVector result = null; + if (previousVector == null) { + result = new DoubleColumnVector(); + } else { + result = (DoubleColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read value entries based on isNull entries + for (int i = 0; i < batchSize; i++) { + if (!result.isNull[i]) { + result.vector[i] = SerializationUtils.readDouble(stream); + } else { + // If the value is not present then set NaN + result.vector[i] = Double.NaN; + } + } + + // Set isRepeating flag + result.isRepeating = true; + for (int i = 0; (i < batchSize - 1 && result.isRepeating); i++) { + if (result.vector[i] != result.vector[i + 1]) { + result.isRepeating = false; + } + } + return result; + } + + @Override void skipRows(long items) throws IOException { items = countNonNulls(items); stream.skip(items * 8); @@ -636,6 +820,12 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + throw new UnsupportedOperationException( + "NextBatch is not supported operation for Binary type"); + } + + @Override void skipRows(long items) throws IOException { items = countNonNulls(items); long lengthToSkip = 0; @@ -649,6 +839,7 @@ void skipRows(long items) throws IOException { private static class TimestampTreeReader extends TreeReader{ private IntegerReader data = null; private IntegerReader nanos = null; + private final LongColumnVector nanoVector = new LongColumnVector(); TimestampTreeReader(Path path, int columnId) { super(path, columnId); @@ -708,6 +899,53 @@ Object next(Object previous) throws IOException { return result; } + @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + LongColumnVector result = null; + if (previousVector == null) { + result = new LongColumnVector(); + } else { + result = (LongColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + data.nextVector(result, batchSize); + nanoVector.isNull = result.isNull; + nanos.nextVector(nanoVector, batchSize); + + if(result.isRepeating && nanoVector.isRepeating) { + batchSize = 1; + } + + // Non repeating values preset in the vector. Iterate thru the vector and populate the time + for (int i = 0; i < batchSize; i++) { + if (!result.isNull[i]) { + long ms = (result.vector[result.isRepeating ? 0 : i] + WriterImpl.BASE_TIMESTAMP) + * WriterImpl.MILLIS_PER_SECOND; + long ns = parseNanos(nanoVector.vector[nanoVector.isRepeating ? 0 : i]); + // the rounding error exists because java always rounds up when dividing integers + // -42001/1000 = -42; and -42001 % 1000 = -1 (+ 1000) + // to get the correct value we need + // (-42 - 1)*1000 + 999 = -42001 + // (42)*1000 + 1 = 42001 + if(ms < 0 && ns != 0) { + ms -= 1000; + } + // Convert millis into nanos and add the nano vector value to it + result.vector[i] = (ms * 1000000) + ns; + } + } + + if(!(result.isRepeating && nanoVector.isRepeating)) { + // both have to repeat for the result to be repeating + result.isRepeating = false; + } + + return result; + } + private static int parseNanos(long serialized) { int zeros = 7 & (int) serialized; int result = (int) serialized >>> 3; @@ -826,6 +1064,12 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + throw new UnsupportedOperationException( + "NextVector is not supported operation for Decimal type"); + } + + @Override void skipRows(long items) throws IOException { items = countNonNulls(items); for(int i=0; i < items; i++) { @@ -885,6 +1129,11 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + return reader.nextVector(previousVector, batchSize); + } + + @Override void skipRows(long items) throws IOException { reader.skipRows(items); } @@ -898,8 +1147,11 @@ void skipRows(long items) throws IOException { private InStream stream; private IntegerReader lengths; + private final LongColumnVector scratchlcv; + StringDirectTreeReader(Path path, int columnId) { super(path, columnId); + scratchlcv = new LongColumnVector(); } @Override @@ -958,6 +1210,72 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + BytesColumnVector result = null; + if (previousVector == null) { + result = new BytesColumnVector(); + } else { + result = (BytesColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + // Read lengths + scratchlcv.isNull = result.isNull; + lengths.nextVector(scratchlcv, batchSize); + int totalLength = 0; + if (!scratchlcv.isRepeating) { + for (int i = 0; i < batchSize; i++) { + if (!scratchlcv.isNull[i]) { + totalLength += (int) scratchlcv.vector[i]; + } + } + } else { + if (!scratchlcv.isNull[0]) { + totalLength = (int) (batchSize * scratchlcv.vector[0]); + } + } + + //Read all the strings for this batch + byte[] allBytes = new byte[totalLength]; + int offset = 0; + int len = totalLength; + while (len > 0) { + int bytesRead = stream.read(allBytes, offset, len); + if (bytesRead < 0) { + throw new EOFException("Can't finish byte read from " + stream); + } + len -= bytesRead; + offset += bytesRead; + } + + // Too expensive to figure out 'repeating' by comparisons. + result.isRepeating = false; + offset = 0; + if (!scratchlcv.isRepeating) { + for (int i = 0; i < batchSize; i++) { + if (!scratchlcv.isNull[i]) { + result.setRef(i, allBytes, offset, (int) scratchlcv.vector[i]); + offset += scratchlcv.vector[i]; + } else { + result.setRef(i, allBytes, 0, 0); + } + } + } else { + for (int i = 0; i < batchSize; i++) { + if (!scratchlcv.isNull[i]) { + result.setRef(i, allBytes, offset, (int) scratchlcv.vector[0]); + offset += scratchlcv.vector[0]; + } else { + result.setRef(i, allBytes, 0, 0); + } + } + } + return result; + } + + @Override void skipRows(long items) throws IOException { items = countNonNulls(items); long lengthToSkip = 0; @@ -977,8 +1295,12 @@ void skipRows(long items) throws IOException { private int[] dictionaryOffsets; private IntegerReader reader; + private byte[] dictionaryBufferInBytesCache = null; + private final LongColumnVector scratchlcv; + StringDictionaryTreeReader(Path path, int columnId) { super(path, columnId); + scratchlcv = new LongColumnVector(); } @Override @@ -1004,6 +1326,8 @@ void startStripe(Map streams, if (in.available() > 0) { dictionaryBuffer = new DynamicByteArray(64, in.available()); dictionaryBuffer.readAll(in); + // Since its start of strip invalidate the cache. + dictionaryBufferInBytesCache = null; } else { dictionaryBuffer = null; } @@ -1050,14 +1374,7 @@ Object next(Object previous) throws IOException { result = (Text) previous; } int offset = dictionaryOffsets[entry]; - int length; - // if it isn't the last entry, subtract the offsets otherwise use - // the buffer length. - if (entry < dictionaryOffsets.length - 1) { - length = dictionaryOffsets[entry + 1] - offset; - } else { - length = dictionaryBuffer.size() - offset; - } + int length = getDictionaryEntryLength(entry, offset); // If the column is just empty strings, the size will be zero, // so the buffer will be null, in that case just return result // as it will default to empty @@ -1071,6 +1388,74 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + BytesColumnVector result = null; + int offset = 0, length = 0; + if (previousVector == null) { + result = new BytesColumnVector(); + } else { + result = (BytesColumnVector) previousVector; + } + + // Read present/isNull stream + super.nextVector(result, batchSize); + + if (dictionaryBuffer != null) { + + // Load dictionaryBuffer into cache. + if (dictionaryBufferInBytesCache == null) { + dictionaryBufferInBytesCache = dictionaryBuffer.get(); + } + + // Read string offsets + scratchlcv.isNull = result.isNull; + reader.nextVector(scratchlcv, batchSize); + if (!scratchlcv.isRepeating) { + + // The vector has non-repeating strings. Iterate thru the batch + // and set strings one by one + for (int i = 0; i < batchSize; i++) { + if (!scratchlcv.isNull[i]) { + offset = dictionaryOffsets[(int) scratchlcv.vector[i]]; + length = getDictionaryEntryLength((int) scratchlcv.vector[i], offset); + result.setRef(i, dictionaryBufferInBytesCache, offset, length); + } else { + // If the value is null then set offset and length to zero (null string) + result.setRef(i, dictionaryBufferInBytesCache, 0, 0); + } + } + } else { + // If the value is repeating then just set the first value in the + // vector and set the isRepeating flag to true. No need to iterate thru and + // set all the elements to the same value + offset = dictionaryOffsets[(int) scratchlcv.vector[0]]; + length = getDictionaryEntryLength((int) scratchlcv.vector[0], offset); + result.setRef(0, dictionaryBufferInBytesCache, offset, length); + } + result.isRepeating = scratchlcv.isRepeating; + } else { + // Entire stripe contains null strings. + result.isRepeating = true; + result.noNulls = false; + result.isNull[0] = true; + result.setRef(0, "".getBytes(), 0, 0); + } + return result; + } + + int getDictionaryEntryLength(int entry, int offset) { + int length = 0; + // if it isn't the last entry, subtract the offsets otherwise use + // the buffer length. + if (entry < dictionaryOffsets.length - 1) { + length = dictionaryOffsets[entry + 1] - offset; + } else { + length = dictionaryBuffer.size() - offset; + } + return length; + } + + @Override void skipRows(long items) throws IOException { reader.skip(countNonNulls(items)); } @@ -1162,6 +1547,28 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + ColumnVector[] result = null; + if (previousVector == null) { + result = new ColumnVector[fields.length]; + } else { + result = (ColumnVector[]) previousVector; + } + + // Read all the members of struct as column vectors + for (int i = 0; i < fields.length; i++) { + if (fields[i] != null) { + if (result[i] == null) { + result[i] = (ColumnVector) fields[i].nextVector(null, batchSize); + } else { + fields[i].nextVector(result[i], batchSize); + } + } + } + return result; + } + + @Override void startStripe(Map streams, List encodings ) throws IOException { @@ -1231,6 +1638,12 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previousVector, long batchSize) throws IOException { + throw new UnsupportedOperationException( + "NextVector is not supported operation for Union type"); + } + + @Override void startStripe(Map streams, List encodings ) throws IOException { @@ -1308,6 +1721,11 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previous, long batchSize) throws IOException { + throw new UnsupportedOperationException( + "NextVector is not supported operation for List type"); + } + void checkEncoding(OrcProto.ColumnEncoding encoding) throws IOException { if ((encoding.getKind() != OrcProto.ColumnEncoding.Kind.DIRECT) && (encoding.getKind() != OrcProto.ColumnEncoding.Kind.DIRECT_V2)) { @@ -1396,6 +1814,11 @@ Object next(Object previous) throws IOException { } @Override + Object nextVector(Object previous, long batchSize) throws IOException { + throw new UnsupportedOperationException( + "NextVector is not supported operation for Map type"); + } + void checkEncoding(OrcProto.ColumnEncoding encoding) throws IOException { if ((encoding.getKind() != OrcProto.ColumnEncoding.Kind.DIRECT) && (encoding.getKind() != OrcProto.ColumnEncoding.Kind.DIRECT_V2)) { @@ -2196,6 +2619,31 @@ public Object next(Object previous) throws IOException { } @Override + public VectorizedRowBatch nextBatch(VectorizedRowBatch previous) throws IOException { + VectorizedRowBatch result = null; + if (rowInStripe >= rowCountInStripe) { + currentStripe += 1; + readStripe(); + } + + long batchSize = Math.min(VectorizedRowBatch.DEFAULT_SIZE, (rowCountInStripe - rowInStripe)); + rowInStripe += batchSize; + if (previous == null) { + ColumnVector[] cols = (ColumnVector[]) reader.nextVector(null, (int) batchSize); + result = new VectorizedRowBatch(cols.length); + result.cols = cols; + } else { + result = (VectorizedRowBatch) previous; + result.selectedInUse = false; + reader.nextVector(result.cols, (int) batchSize); + } + + result.size = (int) batchSize; + advanceToNextRow(rowInStripe + rowBaseInStripe); + return result; + } + + @Override public void close() throws IOException { file.close(); } diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthByteReader.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthByteReader.java index 2fdd498..a6d3ece 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthByteReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthByteReader.java @@ -20,6 +20,8 @@ import java.io.EOFException; import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; + /** * A reader that reads a sequence of bytes. A control byte is read before * each run with positive values 0 to 127 meaning 3 to 130 repetitions. If the @@ -82,6 +84,29 @@ byte next() throws IOException { return result; } + void nextVector(LongColumnVector previous, long previousLen) + throws IOException { + previous.isRepeating = true; + for (int i = 0; i < previousLen; i++) { + if (!previous.isNull[i]) { + previous.vector[i] = next(); + } else { + // The default value of null for int types in vectorized + // processing is 1, so set that if the value is null + previous.vector[i] = 1; + } + + // The default value for nulls in Vectorization for int types is 1 + // and given that non null value can also be 1, we need to check for isNull also + // when determining the isRepeating flag. + if (previous.isRepeating + && i > 0 + && ((previous.vector[i - 1] != previous.vector[i]) || (previous.isNull[i - 1] != previous.isNull[i]))) { + previous.isRepeating = false; + } + } + } + void seek(PositionProvider index) throws IOException { input.seek(index); int consumed = (int) index.getNext(); diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReader.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReader.java index b737b0f..1756c3c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReader.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReader.java @@ -20,6 +20,8 @@ import java.io.EOFException; import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; + /** * A reader that reads a sequence of integers. * */ @@ -91,6 +93,30 @@ public long next() throws IOException { } @Override + public void nextVector(LongColumnVector previous, long previousLen) + throws IOException { + previous.isRepeating = true; + for (int i = 0; i < previousLen; i++) { + if (!previous.isNull[i]) { + previous.vector[i] = next(); + } else { + // The default value of null for int type in vectorized + // processing is 1, so set that if the value is null + previous.vector[i] = 1; + } + + // The default value for nulls in Vectorization for int types is 1 + // and given that non null value can also be 1, we need to check for isNull also + // when determining the isRepeating flag. + if (previous.isRepeating + && i > 0 + && (previous.vector[i - 1] != previous.vector[i] || previous.isNull[i - 1] != previous.isNull[i])) { + previous.isRepeating = false; + } + } + } + + @Override public void seek(PositionProvider index) throws IOException { input.seek(index); int consumed = (int) index.getNext(); diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReaderV2.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReaderV2.java index 4a4165f..5305e00 100644 --- ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReaderV2.java +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/RunLengthIntegerReaderV2.java @@ -20,6 +20,7 @@ import java.io.EOFException; import java.io.IOException; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; import org.apache.hadoop.hive.ql.io.orc.RunLengthIntegerWriterV2.EncodingType; /** @@ -322,4 +323,28 @@ public void skip(long numValues) throws IOException { numValues -= consume; } } + + @Override + public void nextVector(LongColumnVector previous, long previousLen) throws IOException { + previous.isRepeating = true; + for (int i = 0; i < previousLen; i++) { + if (!previous.isNull[i]) { + previous.vector[i] = next(); + } else { + // The default value of null for int type in vectorized + // processing is 1, so set that if the value is null + previous.vector[i] = 1; + } + + // The default value for nulls in Vectorization for int types is 1 + // and given that non null value can also be 1, we need to check for isNull also + // when determining the isRepeating flag. + if (previous.isRepeating + && i > 0 + && (previous.vector[i - 1] != previous.vector[i] || + previous.isNull[i - 1] != previous.isNull[i])) { + previous.isRepeating = false; + } + } + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcInputFormat.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcInputFormat.java new file mode 100644 index 0000000..5684e77 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcInputFormat.java @@ -0,0 +1,221 @@ +/** + * 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.io.orc; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileStatus; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedInputFormatInterface; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatchCtx; +import org.apache.hadoop.hive.ql.io.InputFormatChecker; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.ColumnProjectionUtils; +import org.apache.hadoop.io.NullWritable; +import org.apache.hadoop.mapred.FileInputFormat; +import org.apache.hadoop.mapred.FileSplit; +import org.apache.hadoop.mapred.InputSplit; +import org.apache.hadoop.mapred.JobConf; +import org.apache.hadoop.mapred.RecordReader; +import org.apache.hadoop.mapred.Reporter; + +/** + * A MapReduce/Hive input format for ORC files. + */ +public class VectorizedOrcInputFormat extends FileInputFormat + implements InputFormatChecker, VectorizedInputFormatInterface { + + private static class VectorizedOrcRecordReader + implements RecordReader { + private final org.apache.hadoop.hive.ql.io.orc.RecordReader reader; + private final long offset; + private final long length; + private float progress = 0.0f; + private VectorizedRowBatchCtx rbCtx; + private boolean addPartitionCols = true; + + VectorizedOrcRecordReader(Reader file, Configuration conf, + FileSplit fileSplit) throws IOException { + + this.offset = fileSplit.getStart(); + this.length = fileSplit.getLength(); + this.reader = file.rows(offset, length, + findIncludedColumns(file.getTypes(), conf)); + + try { + rbCtx = new VectorizedRowBatchCtx(); + rbCtx.init(conf, fileSplit); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + @Override + public boolean next(NullWritable key, VectorizedRowBatch value) throws IOException { + + if (!reader.hasNext()) { + return false; + } + try { + // Check and update partition cols if necessary. Ideally, this should be done + // in CreateValue as the partition is constant per split. But since Hive uses + // CombineHiveRecordReader and + // as this does not call CreateValue for each new RecordReader it creates, this check is + // required in next() + if (addPartitionCols) { + rbCtx.addPartitionColsToBatch(value); + addPartitionCols = false; + } + reader.nextBatch(value); + rbCtx.convertRowBatchBlobToVectorizedBatch((Object) value, value.size, value); + } catch (Exception e) { + throw new RuntimeException(e); + } + progress = reader.getProgress(); + return true; + } + + @Override + public NullWritable createKey() { + return NullWritable.get(); + } + + @Override + public VectorizedRowBatch createValue() { + VectorizedRowBatch result = null; + try { + result = rbCtx.createVectorizedRowBatch(); + } catch (HiveException e) { + throw new RuntimeException("Error creating a batch", e); + } + return result; + } + + @Override + public long getPos() throws IOException { + return offset + (long) (progress * length); + } + + @Override + public void close() throws IOException { + reader.close(); + } + + @Override + public float getProgress() throws IOException { + return progress; + } + } + + public VectorizedOrcInputFormat() { + // just set a really small lower bound + setMinSplitSize(16 * 1024); + } + + /** + * Recurse down into a type subtree turning on all of the sub-columns. + * + * @param types + * the types of the file + * @param result + * the global view of columns that should be included + * @param typeId + * the root of tree to enable + */ + private static void includeColumnRecursive(List types, + boolean[] result, + int typeId) { + result[typeId] = true; + OrcProto.Type type = types.get(typeId); + int children = type.getSubtypesCount(); + for (int i = 0; i < children; ++i) { + includeColumnRecursive(types, result, type.getSubtypes(i)); + } + } + + /** + * Take the configuration and figure out which columns we need to include. + * + * @param types + * the types of the file + * @param conf + * the configuration + * @return true for each column that should be included + */ + private static boolean[] findIncludedColumns(List types, + Configuration conf) { + String includedStr = + conf.get(ColumnProjectionUtils.READ_COLUMN_IDS_CONF_STR); + if (includedStr == null || includedStr.trim().length() == 0) { + return null; + } else { + int numColumns = types.size(); + boolean[] result = new boolean[numColumns]; + result[0] = true; + OrcProto.Type root = types.get(0); + List included = ColumnProjectionUtils.getReadColumnIDs(conf); + for (int i = 0; i < root.getSubtypesCount(); ++i) { + if (included.contains(i)) { + includeColumnRecursive(types, result, root.getSubtypes(i)); + } + } + // if we are filtering at least one column, return the boolean array + for (boolean include : result) { + if (!include) { + return result; + } + } + return null; + } + } + + @Override + public RecordReader + getRecordReader(InputSplit inputSplit, JobConf conf, + Reporter reporter) throws IOException { + FileSplit fileSplit = (FileSplit) inputSplit; + Path path = fileSplit.getPath(); + FileSystem fs = path.getFileSystem(conf); + reporter.setStatus(fileSplit.toString()); + return new VectorizedOrcRecordReader(OrcFile.createReader(fs, path), conf, fileSplit); + } + + @Override + public boolean validateInput(FileSystem fs, HiveConf conf, + ArrayList files + ) throws IOException { + if (files.size() <= 0) { + return false; + } + for (FileStatus file : files) { + try { + OrcFile.createReader(fs, file.getPath()); + } catch (IOException e) { + return false; + } + } + return true; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcSerde.java ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcSerde.java new file mode 100644 index 0000000..3c28efc --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/io/orc/VectorizedOrcSerde.java @@ -0,0 +1,90 @@ +/** + * 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.io.orc; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriter; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpressionWriterFactory; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.io.ObjectWritable; +import org.apache.hadoop.io.Writable; + +/** + * A serde class for ORC. + * It transparently passes the object to/from the ORC file reader/writer. + */ +public class VectorizedOrcSerde extends OrcSerde { + private final OrcStruct [] orcStructArray = new OrcStruct [VectorizedRowBatch.DEFAULT_SIZE]; + private final Writable [] orcRowArray = new Writable [VectorizedRowBatch.DEFAULT_SIZE]; + private final ObjectWritable ow = new ObjectWritable(); + private final ObjectInspector inspector = null; + private final VectorExpressionWriter [] valueWriters; + + public VectorizedOrcSerde(ObjectInspector objInspector) { + super(); + for (int i = 0; i < orcStructArray.length; i++) { + orcRowArray[i] = new OrcSerdeRow(); + } + try { + valueWriters = VectorExpressionWriterFactory + .getExpressionWriters((StructObjectInspector) objInspector); + } catch (HiveException e) { + throw new RuntimeException(e); + } + } + + + @Override + public Writable serialize(Object obj, ObjectInspector inspector) { + VectorizedRowBatch batch = (VectorizedRowBatch) obj; + try { + for (int i = 0; i < batch.size; i++) { + OrcStruct ost = orcStructArray[i]; + if (ost == null) { + ost = new OrcStruct(batch.numCols); + orcStructArray[i] = ost; + } + int index = 0; + if (batch.selectedInUse) { + index = batch.selected[i]; + } else { + index = i; + } + for (int p = 0; p < batch.projectionSize; p++) { + int k = batch.projectedColumns[p]; + Writable w; + if (batch.cols[k].isRepeating) { + w = (Writable) valueWriters[p].writeValue(batch.cols[k], 0); + } else { + w = (Writable) valueWriters[p].writeValue(batch.cols[k], index); + } + ost.setFieldValue(k, w); + } + OrcSerdeRow row = (OrcSerdeRow) orcRowArray[i]; + row.realRow = ost; + row.inspector = inspector; + } + } catch (HiveException ex) { + throw new RuntimeException(ex); + } + ow.set(orcRowArray); + return ow; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/PhysicalOptimizer.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/PhysicalOptimizer.java index 3038a98..9ae371e 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/PhysicalOptimizer.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/PhysicalOptimizer.java @@ -77,6 +77,13 @@ private void initialize(HiveConf hiveConf) { if (hiveConf.getBoolVar(HiveConf.ConfVars.HIVE_INFER_BUCKET_SORT)) { resolvers.add(new BucketingSortingInferenceOptimizer()); } + + // Vectorization should be the last optimization, because it doesn't modify the plan + // or any operators. It makes a very low level transformation to the expressions to + // run in the vectorized mode. + if (hiveConf.getBoolVar(HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED)) { + resolvers.add(new Vectorizer()); + } } /** diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java new file mode 100644 index 0000000..62374ad --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java @@ -0,0 +1,557 @@ +/** + * 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.optimizer.physical; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Stack; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.ql.exec.ColumnInfo; +import org.apache.hadoop.hive.ql.exec.FileSinkOperator; +import org.apache.hadoop.hive.ql.exec.FilterOperator; +import org.apache.hadoop.hive.ql.exec.GroupByOperator; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.OperatorFactory; +import org.apache.hadoop.hive.ql.exec.ReduceSinkOperator; +import org.apache.hadoop.hive.ql.exec.SelectOperator; +import org.apache.hadoop.hive.ql.exec.TableScanOperator; +import org.apache.hadoop.hive.ql.exec.Task; +import org.apache.hadoop.hive.ql.exec.UDF; +import org.apache.hadoop.hive.ql.exec.mr.MapRedTask; +import org.apache.hadoop.hive.ql.exec.vector.VectorizationContext; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedInputFormatInterface; +import org.apache.hadoop.hive.ql.lib.DefaultGraphWalker; +import org.apache.hadoop.hive.ql.lib.DefaultRuleDispatcher; +import org.apache.hadoop.hive.ql.lib.Dispatcher; +import org.apache.hadoop.hive.ql.lib.GraphWalker; +import org.apache.hadoop.hive.ql.lib.Node; +import org.apache.hadoop.hive.ql.lib.NodeProcessor; +import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; +import org.apache.hadoop.hive.ql.lib.PreOrderWalker; +import org.apache.hadoop.hive.ql.lib.Rule; +import org.apache.hadoop.hive.ql.lib.RuleRegExp; +import org.apache.hadoop.hive.ql.lib.TaskGraphWalker; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.parse.RowResolver; +import org.apache.hadoop.hive.ql.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.AbstractOperatorDesc; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.plan.MapWork; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.PartitionDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.ql.udf.UDFDayOfMonth; +import org.apache.hadoop.hive.ql.udf.UDFHour; +import org.apache.hadoop.hive.ql.udf.UDFLTrim; +import org.apache.hadoop.hive.ql.udf.UDFLength; +import org.apache.hadoop.hive.ql.udf.UDFLike; +import org.apache.hadoop.hive.ql.udf.UDFMinute; +import org.apache.hadoop.hive.ql.udf.UDFOPDivide; +import org.apache.hadoop.hive.ql.udf.UDFOPMinus; +import org.apache.hadoop.hive.ql.udf.UDFOPMod; +import org.apache.hadoop.hive.ql.udf.UDFOPMultiply; +import org.apache.hadoop.hive.ql.udf.UDFOPNegative; +import org.apache.hadoop.hive.ql.udf.UDFOPPlus; +import org.apache.hadoop.hive.ql.udf.UDFOPPositive; +import org.apache.hadoop.hive.ql.udf.UDFRTrim; +import org.apache.hadoop.hive.ql.udf.UDFSecond; +import org.apache.hadoop.hive.ql.udf.UDFSubstr; +import org.apache.hadoop.hive.ql.udf.UDFTrim; +import org.apache.hadoop.hive.ql.udf.UDFWeekOfYear; +import org.apache.hadoop.hive.ql.udf.UDFYear; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFConcat; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFLower; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPAnd; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPEqualOrLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNot; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotEqual; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNotNull; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPNull; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPOr; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFToUnixTimeStamp; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFUpper; + +public class Vectorizer implements PhysicalPlanResolver { + + protected static transient final Log LOG = LogFactory.getLog(Vectorizer.class); + + Set supportedDataTypes = new HashSet(); + List> vectorizableTasks = + new ArrayList>(); + Set> supportedGenericUDFs = new HashSet>(); + + Set supportedAggregationUdfs = new HashSet(); + + private PhysicalContext physicalContext = null;; + + public Vectorizer() { + supportedDataTypes.add("int"); + supportedDataTypes.add("smallint"); + supportedDataTypes.add("tinyint"); + supportedDataTypes.add("bigint"); + supportedDataTypes.add("integer"); + supportedDataTypes.add("long"); + supportedDataTypes.add("short"); + supportedDataTypes.add("timestamp"); + supportedDataTypes.add("boolean"); + supportedDataTypes.add("string"); + supportedDataTypes.add("byte"); + supportedDataTypes.add("float"); + supportedDataTypes.add("double"); + + supportedGenericUDFs.add(UDFOPNegative.class); + supportedGenericUDFs.add(UDFOPPositive.class); + supportedGenericUDFs.add(UDFOPPlus.class); + supportedGenericUDFs.add(UDFOPMinus.class); + supportedGenericUDFs.add(UDFOPMultiply.class); + supportedGenericUDFs.add(UDFOPDivide.class); + supportedGenericUDFs.add(UDFOPMod.class); + + supportedGenericUDFs.add(GenericUDFOPEqualOrLessThan.class); + supportedGenericUDFs.add(GenericUDFOPEqualOrGreaterThan.class); + supportedGenericUDFs.add(GenericUDFOPGreaterThan.class); + supportedGenericUDFs.add(GenericUDFOPLessThan.class); + supportedGenericUDFs.add(GenericUDFOPNot.class); + supportedGenericUDFs.add(GenericUDFOPNotEqual.class); + supportedGenericUDFs.add(GenericUDFOPNotNull.class); + supportedGenericUDFs.add(GenericUDFOPNull.class); + supportedGenericUDFs.add(GenericUDFOPOr.class); + supportedGenericUDFs.add(GenericUDFOPAnd.class); + supportedGenericUDFs.add(GenericUDFOPEqual.class); + supportedGenericUDFs.add(GenericUDFToUnixTimeStamp.class); + + supportedGenericUDFs.add(UDFHour.class); + supportedGenericUDFs.add(UDFLength.class); + supportedGenericUDFs.add(UDFMinute.class); + supportedGenericUDFs.add(UDFSecond.class); + supportedGenericUDFs.add(UDFYear.class); + supportedGenericUDFs.add(UDFWeekOfYear.class); + supportedGenericUDFs.add(UDFDayOfMonth.class); + + supportedGenericUDFs.add(UDFLike.class); + supportedGenericUDFs.add(UDFSubstr.class); + supportedGenericUDFs.add(UDFLTrim.class); + supportedGenericUDFs.add(UDFRTrim.class); + supportedGenericUDFs.add(UDFTrim.class); + + supportedGenericUDFs.add(GenericUDFLower.class); + supportedGenericUDFs.add(GenericUDFUpper.class); + supportedGenericUDFs.add(GenericUDFConcat.class); + + supportedAggregationUdfs.add("min"); + supportedAggregationUdfs.add("max"); + supportedAggregationUdfs.add("count"); + supportedAggregationUdfs.add("sum"); + supportedAggregationUdfs.add("avg"); + supportedAggregationUdfs.add("variance"); + supportedAggregationUdfs.add("var_pop"); + supportedAggregationUdfs.add("var_samp"); + supportedAggregationUdfs.add("std"); + supportedAggregationUdfs.add("stddev"); + supportedAggregationUdfs.add("stddev_pop"); + supportedAggregationUdfs.add("stddev_samp"); + } + + class VectorizationDispatcher implements Dispatcher { + + public VectorizationDispatcher(PhysicalContext pctx) { + } + + @Override + public Object dispatch(Node nd, Stack stack, Object... nodeOutputs) + throws SemanticException { + Task currTask = (Task) nd; + if (currTask instanceof MapRedTask) { + boolean ret = validateMRTask((MapRedTask) currTask); + if (ret) { + vectorizeMRTask((MapRedTask) currTask); + } + } + return null; + } + + private boolean validateMRTask(MapRedTask mrTask) throws SemanticException { + MapWork mapWork = mrTask.getWork().getMapWork(); + + // Validate the input format + for (String path : mapWork.getPathToPartitionInfo().keySet()) { + PartitionDesc pd = mapWork.getPathToPartitionInfo().get(path); + List> interfaceList = + Arrays.asList(pd.getInputFileFormatClass().getInterfaces()); + if (!interfaceList.contains(VectorizedInputFormatInterface.class)) { + LOG.debug("Input format: " + pd.getInputFileFormatClassName() + + ", doesn't provide vectorized input"); + System.err.println("Input format: " + pd.getInputFileFormatClassName() + + ", doesn't provide vectorized input"); + return false; + } + } + Map opRules = new LinkedHashMap(); + ValidationNodeProcessor vnp = new ValidationNodeProcessor(); + opRules.put(new RuleRegExp("R1", TableScanOperator.getOperatorName() + ".*" + + FileSinkOperator.getOperatorName()), vnp); + opRules.put(new RuleRegExp("R2", TableScanOperator.getOperatorName() + ".*" + + ReduceSinkOperator.getOperatorName()), vnp); + Dispatcher disp = new DefaultRuleDispatcher(vnp, opRules, null); + GraphWalker ogw = new DefaultGraphWalker(disp); + // iterator the mapper operator tree + ArrayList topNodes = new ArrayList(); + topNodes.addAll(mapWork.getAliasToWork().values()); + HashMap nodeOutput = new HashMap(); + ogw.startWalking(topNodes, nodeOutput); + for (Node n : nodeOutput.keySet()) { + if (nodeOutput.get(n) != null) { + if (!((Boolean)nodeOutput.get(n)).booleanValue()) { + return false; + } + } + } + return true; + } + + private void vectorizeMRTask(MapRedTask mrTask) throws SemanticException { + System.err.println("Going down the vectorized path"); + MapWork mapWork = mrTask.getWork().getMapWork(); + mapWork.setVectorMode(true); + Map opRules = new LinkedHashMap(); + VectorizationNodeProcessor vnp = new VectorizationNodeProcessor(mrTask); + opRules.put(new RuleRegExp("R1", TableScanOperator.getOperatorName() + ".*" + + ReduceSinkOperator.getOperatorName()), vnp); + opRules.put(new RuleRegExp("R2", TableScanOperator.getOperatorName() + ".*" + + FileSinkOperator.getOperatorName()), vnp); + Dispatcher disp = new DefaultRuleDispatcher(vnp, opRules, null); + GraphWalker ogw = new PreOrderWalker(disp); + // iterator the mapper operator tree + ArrayList topNodes = new ArrayList(); + topNodes.addAll(mapWork.getAliasToWork().values()); + HashMap nodeOutput = new HashMap(); + ogw.startWalking(topNodes, nodeOutput); + mapWork.setScratchColumnVectorTypes(vnp.getScratchColumnVectorTypes()); + return; + } + } + + class ValidationNodeProcessor implements NodeProcessor { + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + for (Node n : stack) { + Operator op = (Operator) n; + if (op.getType().equals(OperatorType.REDUCESINK) && + op.getParentOperators().get(0).getType().equals(OperatorType.GROUPBY)) { + return new Boolean(true); + } + boolean ret = validateOperator(op); + if (!ret) { + System.err.println("Operator: "+op.getName()+", could not be vectorized"); + return new Boolean(false); + } + } + return new Boolean(true); + } + } + + class VectorizationNodeProcessor implements NodeProcessor { + + private final MapWork mWork; + private final Map vectorizationContexts = + new HashMap(); + + private final Map, VectorizationContext> vContextsByTSOp = + new HashMap, VectorizationContext>(); + + private final Set> opsDone = + new HashSet>(); + + public VectorizationNodeProcessor(MapRedTask mrTask) { + this.mWork = mrTask.getWork().getMapWork(); + } + + public Map> getScratchColumnVectorTypes() { + Map> scratchColumnVectorTypes = + new HashMap>(); + for (String onefile : vectorizationContexts.keySet()) { + VectorizationContext vc = vectorizationContexts.get(onefile); + Map cmap = vc.getOutputColumnTypeMap(); + scratchColumnVectorTypes.put(onefile, cmap); + } + return scratchColumnVectorTypes; + } + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + + Node firstOp = stack.firstElement(); + TableScanOperator tsOp = null; + + tsOp = (TableScanOperator) firstOp; + + VectorizationContext vContext = vContextsByTSOp.get(tsOp); + if (vContext == null) { + String fileKey = ""; + for (String onefile : mWork.getPathToAliases().keySet()) { + List aliases = mWork.getPathToAliases().get(onefile); + for (String alias : aliases) { + Operator op = mWork.getAliasToWork().get(alias); + if (op == tsOp) { + fileKey = onefile; + break; + } + } + } + vContext = getVectorizationContext(tsOp, physicalContext); + vectorizationContexts.put(fileKey, vContext); + vContextsByTSOp.put(tsOp, vContext); + } + + Operator op = (Operator) nd; + if (op.getType().equals(OperatorType.REDUCESINK) && + op.getParentOperators().get(0).getType().equals(OperatorType.GROUPBY)) { + // No need to vectorize + if (!opsDone.contains(op)) { + opsDone.add(op); + } + } else { + try { + if (!opsDone.contains(op)) { + Operator vectorOp = + vectorizeOperator(op, vContext); + opsDone.add(op); + if (vectorOp != op) { + opsDone.add(vectorOp); + } + } + } catch (HiveException e) { + throw new SemanticException(e); + } + } + return null; + } + } + + @Override + public PhysicalContext resolve(PhysicalContext pctx) throws SemanticException { + this.physicalContext = pctx; + boolean vectorPath = HiveConf.getBoolVar(pctx.getConf(), + HiveConf.ConfVars.HIVE_VECTORIZATION_ENABLED); + if (!vectorPath) { + LOG.info("Vectorization is disabled"); + return pctx; + } + // create dispatcher and graph walker + Dispatcher disp = new VectorizationDispatcher(pctx); + TaskGraphWalker ogw = new TaskGraphWalker(disp); + + // get all the tasks nodes from root task + ArrayList topNodes = new ArrayList(); + topNodes.addAll(pctx.getRootTasks()); + + // begin to walk through the task tree. + ogw.startWalking(topNodes, null); + return pctx; + } + + private boolean validateOperator(Operator op) { + boolean ret = false; + switch (op.getType()) { + case GROUPBY: + ret = validateGroupByOperator((GroupByOperator) op); + break; + case FILTER: + ret = validateFilterOperator((FilterOperator) op); + break; + case SELECT: + ret = validateSelectOperator((SelectOperator) op); + break; + case REDUCESINK: + ret = validateReduceSinkOperator((ReduceSinkOperator) op); + break; + case FILESINK: + case TABLESCAN: + ret = true; + break; + default: + ret = false; + break; + } + return ret; + } + + private boolean validateReduceSinkOperator(ReduceSinkOperator op) { + List keyDescs = op.getConf().getKeyCols(); + List partitionDescs = op.getConf().getPartitionCols(); + List valueDesc = op.getConf().getValueCols(); + return validateExprNodeDesc(keyDescs) && validateExprNodeDesc(partitionDescs) && + validateExprNodeDesc(valueDesc); + } + + private boolean validateSelectOperator(SelectOperator op) { + List descList = op.getConf().getColList(); + for (ExprNodeDesc desc : descList) { + boolean ret = validateExprNodeDesc(desc); + if (!ret) { + return false; + } + } + return true; + } + + private boolean validateFilterOperator(FilterOperator op) { + ExprNodeDesc desc = op.getConf().getPredicate(); + return validateExprNodeDesc(desc); + } + + private boolean validateGroupByOperator(GroupByOperator op) { + boolean ret = validateExprNodeDesc(op.getConf().getKeys()); + if (!ret) { + return false; + } + return validateAggregationDesc(op.getConf().getAggregators()); + } + + private boolean validateExprNodeDesc(List descs) { + for (ExprNodeDesc d : descs) { + boolean ret = validateExprNodeDesc(d); + if (!ret) { + return false; + } + } + return true; + } + + private boolean validateAggregationDesc(List descs) { + for (AggregationDesc d : descs) { + boolean ret = validateAggregationDesc(d); + if (!ret) { + return false; + } + } + return true; + } + + private boolean validateExprNodeDesc(ExprNodeDesc desc) { + boolean ret = validateDataType(desc.getTypeInfo().getTypeName()); + if (!ret) { + return false; + } + if (desc instanceof ExprNodeGenericFuncDesc) { + ExprNodeGenericFuncDesc d = (ExprNodeGenericFuncDesc) desc; + boolean r = validateGenericUdf(d); + if (!r) { + return false; + } + } + if (desc.getChildren() != null) { + for (ExprNodeDesc d: desc.getChildren()) { + validateExprNodeDesc(d); + } + } + return true; + } + + private boolean validateGenericUdf(ExprNodeGenericFuncDesc genericUDFExpr) { + if (VectorizationContext.isCustomUDF(genericUDFExpr)) { + return true; + } + GenericUDF genericUDF = genericUDFExpr.getGenericUDF(); + if (genericUDF instanceof GenericUDFBridge) { + Class udf = ((GenericUDFBridge) genericUDF).getUdfClass(); + return supportedGenericUDFs.contains(udf); + } else { + return supportedGenericUDFs.contains(genericUDF.getClass()); + } + } + + private boolean validateAggregationDesc(AggregationDesc aggDesc) { + return supportedAggregationUdfs.contains(aggDesc.getGenericUDAFName().toLowerCase()); + } + + private boolean validateDataType(String type) { + return supportedDataTypes.contains(type.toLowerCase()); + } + + private VectorizationContext getVectorizationContext(Operator op, + PhysicalContext pctx) { + RowResolver rr = pctx.getParseContext().getOpParseCtx().get(op).getRowResolver(); + + Map cmap = new HashMap(); + int columnCount = 0; + for (ColumnInfo c : rr.getColumnInfos()) { + if (!c.getIsVirtualCol()) { + cmap.put(c.getInternalName(), columnCount++); + } + } + return new VectorizationContext(cmap, columnCount); + } + + private Operator vectorizeOperator(Operator op, + VectorizationContext vContext) throws HiveException { + Operator vectorOp = null; + + switch (op.getType()) { + case GROUPBY: + case FILTER: + case SELECT: + case FILESINK: + case REDUCESINK: + vectorOp = OperatorFactory.getVectorOperator(op.getConf(), vContext); + break; + default: + vectorOp = op; + break; + } + + if (vectorOp != op) { + if (op.getParentOperators() != null) { + vectorOp.setParentOperators(op.getParentOperators()); + for (Operator p : op.getParentOperators()) { + p.replaceChild(op, vectorOp); + } + } + if (op.getChildOperators() != null) { + vectorOp.setChildOperators(op.getChildOperators()); + for (Operator c : op.getChildOperators()) { + c.replaceParent(op, vectorOp); + } + } + ((AbstractOperatorDesc) vectorOp.getConf()).setVectorMode(true); + } + return vectorOp; + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/TypeCheckProcFactory.java ql/src/java/org/apache/hadoop/hive/ql/parse/TypeCheckProcFactory.java index 767f545..940c89a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/TypeCheckProcFactory.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/TypeCheckProcFactory.java @@ -898,7 +898,7 @@ static ExprNodeDesc getXpathOrFuncExprNodeDesc(ASTNode expr, } } - desc = ExprNodeGenericFuncDesc.newInstance(genericUDF, children); + desc = ExprNodeGenericFuncDesc.newInstance(genericUDF, funcText, children); } // UDFOPPositive is a no-op. // However, we still create it, and then remove it here, to make sure we diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/AbstractOperatorDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/AbstractOperatorDesc.java index 4bb28b5..c096a65 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/AbstractOperatorDesc.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/AbstractOperatorDesc.java @@ -19,8 +19,20 @@ package org.apache.hadoop.hive.ql.plan; public class AbstractOperatorDesc implements OperatorDesc { + + private boolean vectorMode = false; + @Override public Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException("clone not supported"); } + + @Explain(displayName = "Vectorized execution", displayOnlyOnTrue = true) + public boolean getVectorModeOn() { + return vectorMode; + } + + public void setVectorMode(boolean vm) { + this.vectorMode = vm; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java index 52fe47b..e3fcaf6 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/ExprNodeGenericFuncDesc.java @@ -62,6 +62,7 @@ */ private GenericUDF genericUDF; private List childExprs; + private transient String funcText; /** * This class uses a writableObjectInspector rather than a TypeInfo to store * the canonical type information for this NodeDesc. @@ -73,13 +74,19 @@ public ExprNodeGenericFuncDesc() { } + /* If the function has an explicit name like func(args) then call a + * constructor that explicitly provides the function name in the + * funcText argument. + */ public ExprNodeGenericFuncDesc(TypeInfo typeInfo, GenericUDF genericUDF, + String funcText, List children) { this(TypeInfoUtils.getStandardWritableObjectInspectorFromTypeInfo(typeInfo), - genericUDF, children); + genericUDF, funcText, children); } public ExprNodeGenericFuncDesc(ObjectInspector oi, GenericUDF genericUDF, + String funcText, List children) { super(TypeInfoUtils.getTypeInfoFromObjectInspector(oi)); this.writableObjectInspector = @@ -87,6 +94,18 @@ public ExprNodeGenericFuncDesc(ObjectInspector oi, GenericUDF genericUDF, assert (genericUDF != null); this.genericUDF = genericUDF; this.childExprs = children; + this.funcText = funcText; + } + + // Backward-compatibility interfaces for functions without a user-visible name. + public ExprNodeGenericFuncDesc(TypeInfo typeInfo, GenericUDF genericUDF, + List children) { + this(typeInfo, genericUDF, null, children); + } + + public ExprNodeGenericFuncDesc(ObjectInspector oi, GenericUDF genericUDF, + List children) { + this(oi, genericUDF, null, children); } @Override @@ -165,17 +184,20 @@ public ExprNodeDesc clone() { cloneCh.add(ch.clone()); } ExprNodeGenericFuncDesc clone = new ExprNodeGenericFuncDesc(typeInfo, - FunctionRegistry.cloneGenericUDF(genericUDF), cloneCh); + FunctionRegistry.cloneGenericUDF(genericUDF), funcText, cloneCh); return clone; } /** - * Create a exprNodeGenericFuncDesc based on the genericUDFClass and the - * children parameters. + * Create a ExprNodeGenericFuncDesc based on the genericUDFClass and the + * children parameters. If the function has an explicit name, the + * newInstance method should be passed the function name in the funcText + * argument. * * @throws UDFArgumentException */ public static ExprNodeGenericFuncDesc newInstance(GenericUDF genericUDF, + String funcText, List children) throws UDFArgumentException { ObjectInspector[] childrenOIs = new ObjectInspector[children.size()]; for (int i = 0; i < childrenOIs.length; i++) { @@ -232,7 +254,15 @@ public static ExprNodeGenericFuncDesc newInstance(GenericUDF genericUDF, } } - return new ExprNodeGenericFuncDesc(oi, genericUDF, children); + return new ExprNodeGenericFuncDesc(oi, genericUDF, funcText, children); + } + + /* Backward-compatibility interface for the case where there is no explicit + * name for the function. + */ + public static ExprNodeGenericFuncDesc newInstance(GenericUDF genericUDF, + List children) throws UDFArgumentException { + return newInstance(genericUDF, null, children); } @Override @@ -285,4 +315,8 @@ public boolean isSortedExpr() { public void setSortedExpr(boolean isSortedExpr) { this.isSortedExpr = isSortedExpr; } + + public String getFuncText() { + return this.funcText; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/plan/MapWork.java ql/src/java/org/apache/hadoop/hive/ql/plan/MapWork.java index 75d2ec9..a72ec8b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/plan/MapWork.java +++ ql/src/java/org/apache/hadoop/hive/ql/plan/MapWork.java @@ -112,6 +112,9 @@ private boolean useBucketizedHiveInputFormat; + private Map> scratchColumnVectorTypes = null; + private boolean vectorMode = false; + public MapWork() { } @@ -479,4 +482,21 @@ public void configureJobConf(JobConf job) { PlanUtils.configureJobConf(fs.getConf().getTableInfo(), job); } } + + public Map> getScratchColumnVectorTypes() { + return scratchColumnVectorTypes; + } + + public void setScratchColumnVectorTypes( + Map> scratchColumnVectorTypes) { + this.scratchColumnVectorTypes = scratchColumnVectorTypes; + } + + public boolean getVectorMode() { + return vectorMode; + } + + public void setVectorMode(boolean vectorMode) { + this.vectorMode = vectorMode; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/util/JavaDataModel.java ql/src/java/org/apache/hadoop/hive/ql/util/JavaDataModel.java index e3eec02..7a4812b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/util/JavaDataModel.java +++ ql/src/java/org/apache/hadoop/hive/ql/util/JavaDataModel.java @@ -27,95 +27,133 @@ public enum JavaDataModel { JAVA32 { + @Override public int object() { return JAVA32_OBJECT; } + @Override public int array() { return JAVA32_ARRAY; } + @Override public int ref() { return JAVA32_REF; } + @Override public int hashMap(int entry) { // base = JAVA32_OBJECT + PRIMITIVES1 * 4 + JAVA32_FIELDREF * 3 + JAVA32_ARRAY; // entry = JAVA32_OBJECT + JAVA32_FIELDREF + PRIMITIVES1 return 64 + 24 * entry; } + @Override + public int hashMapEntry() { + return 24; + } + + @Override public int hashSet(int entry) { // hashMap += JAVA32_OBJECT return 80 + 24 * entry; } + @Override public int linkedHashMap(int entry) { // hashMap += JAVA32_FIELDREF + PRIMITIVES1 // hashMap.entry += JAVA32_FIELDREF * 2 return 72 + 32 * entry; } + @Override public int linkedList(int entry) { // base = JAVA32_OBJECT + PRIMITIVES1 * 2 + JAVA32_FIELDREF; // entry = JAVA32_OBJECT + JAVA32_FIELDREF * 2 return 28 + 24 * entry; } + @Override public int arrayList() { // JAVA32_OBJECT + PRIMITIVES1 * 2 + JAVA32_ARRAY; return 44; } + + @Override + public int memoryAlign() { + return 8; + } }, JAVA64 { + @Override public int object() { return JAVA64_OBJECT; } + @Override public int array() { return JAVA64_ARRAY; } + @Override public int ref() { return JAVA64_REF; } + @Override public int hashMap(int entry) { // base = JAVA64_OBJECT + PRIMITIVES1 * 4 + JAVA64_FIELDREF * 3 + JAVA64_ARRAY; // entry = JAVA64_OBJECT + JAVA64_FIELDREF + PRIMITIVES1 return 112 + 44 * entry; } + @Override + public int hashMapEntry() { + return 44; + } + + @Override public int hashSet(int entry) { // hashMap += JAVA64_OBJECT return 144 + 44 * entry; } + @Override public int linkedHashMap(int entry) { // hashMap += JAVA64_FIELDREF + PRIMITIVES1 // hashMap.entry += JAVA64_FIELDREF * 2 return 128 + 60 * entry; } + @Override public int linkedList(int entry) { // base = JAVA64_OBJECT + PRIMITIVES1 * 2 + JAVA64_FIELDREF; // entry = JAVA64_OBJECT + JAVA64_FIELDREF * 2 return 48 + 48 * entry; } + @Override public int arrayList() { // JAVA64_OBJECT + PRIMITIVES1 * 2 + JAVA64_ARRAY; return 80; } + + @Override + public int memoryAlign() { + return 8; + } }; public abstract int object(); public abstract int array(); public abstract int ref(); public abstract int hashMap(int entry); + public abstract int hashMapEntry(); public abstract int hashSet(int entry); public abstract int linkedHashMap(int entry); public abstract int linkedList(int entry); public abstract int arrayList(); + public abstract int memoryAlign(); // ascii string public int lengthFor(String string) { @@ -161,6 +199,10 @@ public int primitive2() { return PRIMITIVES2; } + public static int alignUp(int value, int align) { + return (value + align - 1) & ~(align - 1); + } + public static final int JAVA32_META = 12; public static final int JAVA32_ARRAY_META = 16; public static final int JAVA32_REF = 4; @@ -176,6 +218,8 @@ public int primitive2() { public static final int PRIMITIVES1 = 4; // void, boolean, byte, short, int, float public static final int PRIMITIVES2 = 8; // long, double + public static final int PRIMITIVE_BYTE = 1; // byte + private static JavaDataModel current; public static JavaDataModel get() { @@ -200,4 +244,27 @@ public static int round(int size) { } return ((size + 8) >> 3) << 3; } + + private int lengthForPrimitiveArrayOfSize(int primitiveSize, int length) { + return alignUp(array() + primitiveSize*length, memoryAlign()); + } + + public int lengthForByteArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(PRIMITIVE_BYTE, length); + } + public int lengthForObjectArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(ref(), length); + } + public int lengthForLongArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(primitive2(), length); + } + public int lengthForDoubleArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(primitive2(), length); + } + public int lengthForIntArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(primitive1(), length); + } + public int lengthForBooleanArrayOfSize(int length) { + return lengthForPrimitiveArrayOfSize(PRIMITIVE_BYTE, length); + } } diff --git ql/src/test/org/apache/hadoop/hive/ql/QTestUtil.java ql/src/test/org/apache/hadoop/hive/ql/QTestUtil.java index 75b8a5f..bf84961 100644 --- ql/src/test/org/apache/hadoop/hive/ql/QTestUtil.java +++ ql/src/test/org/apache/hadoop/hive/ql/QTestUtil.java @@ -56,12 +56,15 @@ import org.apache.hadoop.hive.cli.CliSessionState; import org.apache.hadoop.hive.common.io.CachingPrintStream; import org.apache.hadoop.hive.conf.HiveConf; +import org.apache.hadoop.hive.conf.HiveConf.ConfVars; import org.apache.hadoop.hive.metastore.MetaStoreUtils; import org.apache.hadoop.hive.metastore.api.Index; import org.apache.hadoop.hive.ql.exec.FunctionRegistry; import org.apache.hadoop.hive.ql.exec.Task; import org.apache.hadoop.hive.ql.exec.Utilities; import org.apache.hadoop.hive.ql.exec.Utilities.StreamPrinter; +import org.apache.hadoop.hive.ql.exec.vector.util.AllVectorTypesRecord; +import org.apache.hadoop.hive.ql.exec.vector.util.OrcFileGenerator; import org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat; import org.apache.hadoop.hive.ql.lockmgr.zookeeper.ZooKeeperHiveLockManager; import org.apache.hadoop.hive.ql.metadata.Hive; @@ -104,7 +107,7 @@ public static final HashSet srcTables = new HashSet (Arrays.asList(new String [] { "src", "src1", "srcbucket", "srcbucket2", "src_json", "src_thrift", - "src_sequencefile", "srcpart" + "src_sequencefile", "srcpart", "alltypesorc" })); private ParseDriver pd; @@ -217,6 +220,11 @@ public void initConf() throws Exception { convertPathsFromWindowsToHdfs(); } + String vectorizationEnabled = System.getProperty("test.vectorization.enabled"); + if(vectorizationEnabled != null && vectorizationEnabled.equalsIgnoreCase("true")) { + conf.setBoolVar(ConfVars.HIVE_VECTORIZATION_ENABLED, true); + } + // Plug verifying metastore in for testing. conf.setVar(HiveConf.ConfVars.METASTORE_RAW_STORE_IMPL, "org.apache.hadoop.hive.metastore.VerifyingObjectStore"); @@ -513,7 +521,8 @@ public void cleanUp() throws Exception { for (String s : new String[] {"src", "src1", "src_json", "src_thrift", "src_sequencefile", "srcpart", "srcbucket", "srcbucket2", "dest1", "dest2", "dest3", "dest4", "dest4_sequencefile", "dest_j1", "dest_j2", - "dest_g1", "dest_g2", "fetchtask_ioexception"}) { + "dest_g1", "dest_g2", "fetchtask_ioexception", + AllVectorTypesRecord.TABLE_NAME}) { db.dropTable(MetaStoreUtils.DEFAULT_DATABASE_NAME, s); } @@ -655,7 +664,17 @@ public void createSources() throws Exception { fpath = new Path(testFiles, "json.txt"); runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toUri().getPath() + "' INTO TABLE src_json"); + + FileSystem localFs = FileSystem.getLocal(conf); + // create and load data into orc table + fpath = new Path(testFiles, AllVectorTypesRecord.TABLE_NAME); + + runCreateTableCmd(AllVectorTypesRecord.TABLE_CREATE_COMMAND); + runLoadCmd("LOAD DATA LOCAL INPATH '" + fpath.toUri().getPath() + + "' INTO TABLE "+AllVectorTypesRecord.TABLE_NAME); + conf.setBoolean("hive.test.init.phase", false); + } public void init() throws Exception { diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorFilterOperator.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorFilterOperator.java new file mode 100644 index 0000000..c877cef --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorFilterOperator.java @@ -0,0 +1,162 @@ +/** + * 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.exec.vector; + +import java.util.HashMap; +import java.util.Map; + +import junit.framework.Assert; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterExprAndExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColEqualDoubleScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongColumn; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.FilterDesc; +import org.junit.Test; + +/** + * Test cases for vectorized filter operator. + */ +public class TestVectorFilterOperator { + + /** + * Fundamental logic and performance tests for vector filters belong here. + * + * For tests about filters to cover specific operator and data type combinations, + * see also the other filter tests under org.apache.hadoop.hive.ql.exec.vector.expressions + */ + public static class FakeDataReader { + private final int size; + private final VectorizedRowBatch vrg; + private int currentSize = 0; + private final int numCols; + private final int len = 1024; + + public FakeDataReader(int size, int numCols) { + this.size = size; + this.numCols = numCols; + vrg = new VectorizedRowBatch(numCols, len); + for (int i = 0; i < numCols; i++) { + try { + Thread.sleep(2); + } catch (InterruptedException ignore) {} + vrg.cols[i] = getLongVector(len); + } + } + + public VectorizedRowBatch getNext() { + if (currentSize >= size) { + vrg.size = 0; + return vrg; + } else { + vrg.size = len; + currentSize += vrg.size; + vrg.selectedInUse = false; + return vrg; + } + } + + private LongColumnVector getLongVector(int len) { + LongColumnVector lcv = new LongColumnVector(len); + TestVectorizedRowBatch.setRandomLongCol(lcv); + return lcv; + } + } + + private VectorFilterOperator getAVectorFilterOperator() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Long.class, "col1", "table", false); + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + VectorizationContext vc = new VectorizationContext(columnMap, 1); + FilterDesc fdesc = new FilterDesc(); + fdesc.setPredicate(col1Expr); + return new VectorFilterOperator(vc, fdesc); + } + + @Test + public void testBasicFilterOperator() throws HiveException { + VectorFilterOperator vfo = getAVectorFilterOperator(); + VectorExpression ve1 = new FilterLongColGreaterLongColumn(0,1); + VectorExpression ve2 = new FilterLongColEqualDoubleScalar(2, 0); + VectorExpression ve3 = new FilterExprAndExpr(ve1,ve2); + vfo.setFilterCondition(ve3); + + FakeDataReader fdr = new FakeDataReader(1024*1, 3); + + VectorizedRowBatch vrg = fdr.getNext(); + + vfo.processOp(vrg, 0); + + //Verify + int rows = 0; + for (int i =0; i < 1024; i++){ + LongColumnVector l1 = (LongColumnVector) vrg.cols[0]; + LongColumnVector l2 = (LongColumnVector) vrg.cols[1]; + LongColumnVector l3 = (LongColumnVector) vrg.cols[2]; + if ((l1.vector[i] > l2.vector[i]) && (l3.vector[i] == 0)) { + rows ++; + } + } + Assert.assertEquals(rows, vrg.size); + } + + @Test + public void testBasicFilterLargeData() throws HiveException { + VectorFilterOperator vfo = getAVectorFilterOperator(); + VectorExpression ve1 = new FilterLongColGreaterLongColumn(0,1); + VectorExpression ve2 = new FilterLongColEqualDoubleScalar(2, 0); + VectorExpression ve3 = new FilterExprAndExpr(ve1,ve2); + vfo.setFilterCondition(ve3); + + FakeDataReader fdr = new FakeDataReader(16*1024*1024, 3); + + long startTime = System.currentTimeMillis(); + VectorizedRowBatch vrg = fdr.getNext(); + + while (vrg.size > 0) { + vfo.processOp(vrg, 0); + vrg = fdr.getNext(); + } + long endTime = System.currentTimeMillis(); + System.out.println("testBaseFilterOperator Op Time = "+(endTime-startTime)); + + //Base time + + fdr = new FakeDataReader(16*1024*1024, 3); + + long startTime1 = System.currentTimeMillis(); + vrg = fdr.getNext(); + LongColumnVector l1 = (LongColumnVector) vrg.cols[0]; + LongColumnVector l2 = (LongColumnVector) vrg.cols[1]; + LongColumnVector l3 = (LongColumnVector) vrg.cols[2]; + int rows = 0; + for (int j =0; j < 16 *1024; j++) { + for (int i = 0; i < l1.vector.length && i < l2.vector.length && i < l3.vector.length; i++) { + if ((l1.vector[i] > l2.vector[i]) && (l3.vector[i] == 0)) { + rows++; + } + } + } + long endTime1 = System.currentTimeMillis(); + System.out.println("testBaseFilterOperator base Op Time = "+(endTime1-startTime1)); + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorGroupByOperator.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorGroupByOperator.java new file mode 100644 index 0000000..d1d2ea9 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorGroupByOperator.java @@ -0,0 +1,2128 @@ +/** + * 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.exec.vector; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.lang.reflect.Constructor; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.hadoop.hive.ql.exec.vector.util.FakeCaptureOutputOperator; +import org.apache.hadoop.hive.ql.exec.vector.util.FakeVectorRowBatchFromConcat; +import org.apache.hadoop.hive.ql.exec.vector.util.FakeVectorRowBatchFromLongIterables; +import org.apache.hadoop.hive.ql.exec.vector.util.FakeVectorRowBatchFromObjectIterables; +import org.apache.hadoop.hive.ql.exec.vector.util.FakeVectorRowBatchFromRepeats; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.GroupByDesc; +import org.apache.hadoop.hive.serde2.io.ByteWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.io.ShortWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.FloatWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.Text; +import org.junit.Assert; +import org.junit.Test; + +/** + * Unit test for the vectorized GROUP BY operator. + */ +public class TestVectorGroupByOperator { + + private static ExprNodeDesc buildColumnDesc( + VectorizationContext ctx, + String column, + TypeInfo typeInfo) { + + return new ExprNodeColumnDesc( + typeInfo, column, "table", false); + } + + private static AggregationDesc buildAggregationDesc( + VectorizationContext ctx, + String aggregate, + String column, + TypeInfo typeInfo) { + + ExprNodeDesc inputColumn = buildColumnDesc(ctx, column, typeInfo); + + ArrayList params = new ArrayList(); + params.add(inputColumn); + + AggregationDesc agg = new AggregationDesc(); + agg.setGenericUDAFName(aggregate); + agg.setParameters(params); + + return agg; + } + private static AggregationDesc buildAggregationDescCountStar( + VectorizationContext ctx) { + AggregationDesc agg = new AggregationDesc(); + agg.setGenericUDAFName("COUNT"); + agg.setParameters(new ArrayList()); + return agg; + } + + + private static GroupByDesc buildGroupByDescType( + VectorizationContext ctx, + String aggregate, + String column, + TypeInfo dataType) { + + AggregationDesc agg = buildAggregationDesc(ctx, aggregate, + column, dataType); + ArrayList aggs = new ArrayList(); + aggs.add(agg); + + ArrayList outputColumnNames = new ArrayList(); + outputColumnNames.add("_col0"); + + GroupByDesc desc = new GroupByDesc(); + desc.setOutputColumnNames(outputColumnNames); + desc.setAggregators(aggs); + + return desc; + } + + private static GroupByDesc buildGroupByDescCountStar( + VectorizationContext ctx) { + + AggregationDesc agg = buildAggregationDescCountStar(ctx); + ArrayList aggs = new ArrayList(); + aggs.add(agg); + + ArrayList outputColumnNames = new ArrayList(); + outputColumnNames.add("_col0"); + + GroupByDesc desc = new GroupByDesc(); + desc.setOutputColumnNames(outputColumnNames); + desc.setAggregators(aggs); + + return desc; + } + + + private static GroupByDesc buildKeyGroupByDesc( + VectorizationContext ctx, + String aggregate, + String column, + TypeInfo dataTypeInfo, + String key, + TypeInfo keyTypeInfo) { + + GroupByDesc desc = buildGroupByDescType(ctx, aggregate, column, dataTypeInfo); + + ExprNodeDesc keyExp = buildColumnDesc(ctx, key, keyTypeInfo); + ArrayList keys = new ArrayList(); + keys.add(keyExp); + desc.setKeys(keys); + + desc.getOutputColumnNames().add("_col1"); + + return desc; + } + + @Test + public void testMultiKeyIntStringInt() throws HiveException { + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"int", "string", "int", "double"}, + Arrays.asList(new Object[]{null, 1, 1, null, 2, 2, null}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{null, 2, 2, null, 2, 2, null}), + Arrays.asList(new Object[]{1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0})), + buildHashMap( + Arrays.asList( 1, "A", 2), 6.0, + Arrays.asList(null, "C", null), 8.0, + Arrays.asList( 2, null, 2), 48.0, + Arrays.asList(null, "A", null), 65.0)); + } + + @Test + public void testMultiKeyStringByteString() throws HiveException { + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 1, + new String[] {"string", "tinyint", "string", "double"}, + Arrays.asList(new Object[]{"A", "A", null}), + Arrays.asList(new Object[]{ 1, 1, 1}), + Arrays.asList(new Object[]{ "A", "A", "A"}), + Arrays.asList(new Object[]{ 1.0, 1.0, 1.0})), + buildHashMap( + Arrays.asList( "A", (byte)1, "A"), 2.0, + Arrays.asList( null, (byte)1, "A"), 1.0)); + } + + @Test + public void testMultiKeyStringIntString() throws HiveException { + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"string", "int", "string", "double"}, + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{null, 1, 1, null, 2, 2, null}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0})), + buildHashMap( + Arrays.asList(null, 2, null), 2.0, + Arrays.asList( "C", null, "C"), 1.0, + Arrays.asList( "A", 1, "A"), 2.0, + Arrays.asList( "A", null, "A"), 2.0)); + } + + @Test + public void testMultiKeyIntStringString() throws HiveException { + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"int", "string", "string", "double"}, + Arrays.asList(new Object[]{null, 1, 1, null, 2, 2, null}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0})), + buildHashMap( + Arrays.asList( 2, null, null), 2.0, + Arrays.asList(null, "C", "C"), 1.0, + Arrays.asList( 1, "A", "A"), 2.0, + Arrays.asList(null, "A", "A"), 2.0)); + } + + @Test + public void testMultiKeyDoubleStringInt() throws HiveException { + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"double", "string", "int", "double"}, + Arrays.asList(new Object[]{null, 1.0, 1.0, null, 2.0, 2.0, null}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{null, 2, 2, null, 2, 2, null}), + Arrays.asList(new Object[]{1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0})), + buildHashMap( + Arrays.asList( 1.0, "A", 2), 6.0, + Arrays.asList(null, "C", null), 8.0, + Arrays.asList( 2.0, null, 2), 48.0, + Arrays.asList(null, "A", null), 65.0)); + } + + @Test + public void testMultiKeyDoubleShortString() throws HiveException { + short s = 2; + testMultiKey( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"double", "smallint", "string", "double"}, + Arrays.asList(new Object[]{null, 1.0, 1.0, null, 2.0, 2.0, null}), + Arrays.asList(new Object[]{null, s, s, null, s, s, null}), + Arrays.asList(new Object[]{ "A", "A", "A", "C", null, null, "A"}), + Arrays.asList(new Object[]{1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0})), + buildHashMap( + Arrays.asList( 1.0, s, "A"), 6.0, + Arrays.asList(null, null, "C"), 8.0, + Arrays.asList( 2.0, s, null), 48.0, + Arrays.asList(null, null, "A"), 65.0)); + } + + + @Test + public void testDoubleValueTypeSum() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 20.0, null, 19.0)); + } + + @Test + public void testDoubleValueTypeSumOneKey() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 39.0)); + } + + @Test + public void testDoubleValueTypeCount() throws HiveException { + testKeyTypeAggregate( + "count", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 2L, null, 1L)); + } + + public void testDoubleValueTypeCountOneKey() throws HiveException { + testKeyTypeAggregate( + "count", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 3L)); + } + + @Test + public void testDoubleValueTypeAvg() throws HiveException { + testKeyTypeAggregate( + "avg", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 10.0, null, 19.0)); + } + + @Test + public void testDoubleValueTypeAvgOneKey() throws HiveException { + testKeyTypeAggregate( + "avg", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 13.0)); + } + + @Test + public void testDoubleValueTypeMin() throws HiveException { + testKeyTypeAggregate( + "min", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 7.0, null, 19.0)); + } + + @Test + public void testDoubleValueTypeMinOneKey() throws HiveException { + testKeyTypeAggregate( + "min", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 7.0)); + } + + @Test + public void testDoubleValueTypeMax() throws HiveException { + testKeyTypeAggregate( + "max", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 13.0, null, 19.0)); + } + + @Test + public void testDoubleValueTypeMaxOneKey() throws HiveException { + testKeyTypeAggregate( + "max", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 19.0)); + } + + @Test + public void testDoubleValueTypeVariance() throws HiveException { + testKeyTypeAggregate( + "variance", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 9.0, null, 0.0)); + } + + @Test + public void testDoubleValueTypeVarianceOneKey() throws HiveException { + testKeyTypeAggregate( + "variance", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "double"}, + Arrays.asList(new Object[]{ 1, 1, 1, 1}), + Arrays.asList(new Object[]{13.0,null,7.0, 19.0})), + buildHashMap((byte)1, 24.0)); + } + @Test + public void testTinyintKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"tinyint", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((byte)1, 20L, null, 19L)); + } + + @Test + public void testSmallintKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"smallint", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((short)1, 20L, null, 19L)); + } + + @Test + public void testIntKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"int", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((int)1, 20L, null, 19L)); + } + + @Test + public void testBigintKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"bigint", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((long)1L, 20L, null, 19L)); + } + + @Test + public void testBooleanKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"boolean", "bigint"}, + Arrays.asList(new Object[]{ true,null, true, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap(true, 20L, null, 19L)); + } + + @Test + public void testTimestampKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"timestamp", "bigint"}, + Arrays.asList(new Object[]{new Timestamp(1),null, new Timestamp(1), null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap(new Timestamp(1), 20L, null, 19L)); + } + + @Test + public void testFloatKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"float", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((float)1.0, 20L, null, 19L)); + } + + @Test + public void testDoubleKeyTypeAggregate() throws HiveException { + testKeyTypeAggregate( + "sum", + new FakeVectorRowBatchFromObjectIterables( + 2, + new String[] {"double", "bigint"}, + Arrays.asList(new Object[]{ 1,null, 1, null}), + Arrays.asList(new Object[]{13L,null,7L, 19L})), + buildHashMap((double)1.0, 20L, null, 19L)); + } + + @Test + public void testCountStar() throws HiveException { + testAggregateCountStar( + 2, + Arrays.asList(new Long[]{13L,null,7L,19L}), + 4L); + } + + @Test + public void testCountString() throws HiveException { + testAggregateString( + "count", + 2, + Arrays.asList(new Object[]{"A","B","C"}), + 3L); + } + + @Test + public void testMaxString() throws HiveException { + testAggregateString( + "max", + 2, + Arrays.asList(new Object[]{"A","B","C"}), + "C"); + testAggregateString( + "max", + 2, + Arrays.asList(new Object[]{"C", "B", "A"}), + "C"); + } + + @Test + public void testMinString() throws HiveException { + testAggregateString( + "min", + 2, + Arrays.asList(new Object[]{"A","B","C"}), + "A"); + testAggregateString( + "min", + 2, + Arrays.asList(new Object[]{"C", "B", "A"}), + "A"); + } + + @Test + public void testMaxNullString() throws HiveException { + testAggregateString( + "max", + 2, + Arrays.asList(new Object[]{"A","B",null}), + "B"); + testAggregateString( + "max", + 2, + Arrays.asList(new Object[]{null, null, null}), + null); + } + + @Test + public void testCountStringWithNull() throws HiveException { + testAggregateString( + "count", + 2, + Arrays.asList(new Object[]{"A",null,"C", "D", null}), + 3L); + } + + @Test + public void testCountStringAllNull() throws HiveException { + testAggregateString( + "count", + 4, + Arrays.asList(new Object[]{null, null, null, null, null}), + 0L); + } + + + @Test + public void testMinLongNullStringKeys() throws HiveException { + testAggregateStringKeyAggregate( + "min", + 2, + Arrays.asList(new Object[]{"A",null,"A",null}), + Arrays.asList(new Object[]{13L, 5L, 7L,19L}), + buildHashMap("A", 7L, null, 5L)); + } + + @Test + public void testMinLongStringKeys() throws HiveException { + testAggregateStringKeyAggregate( + "min", + 2, + Arrays.asList(new Object[]{"A","B","A","B"}), + Arrays.asList(new Object[]{13L, 5L, 7L,19L}), + buildHashMap("A", 7L, "B", 5L)); + } + + @Test + public void testMinLongKeyGroupByCompactBatch() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 2, + Arrays.asList(new Long[]{01L,1L,2L,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(1L, 5L, 2L, 7L)); + } + + @Test + public void testMinLongKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 4, + Arrays.asList(new Long[]{01L,1L,2L,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(1L, 5L, 2L, 7L)); + } + + @Test + public void testMinLongKeyGroupByCrossBatch() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 2, + Arrays.asList(new Long[]{01L,2L,1L,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(1L, 7L, 2L, 5L)); + } + + @Test + public void testMinLongNullKeyGroupByCrossBatch() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 2, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 7L, 2L, 5L)); + } + + @Test + public void testMinLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 7L, 2L, 5L)); + } + + @Test + public void testMaxLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "max", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 13L, 2L, 19L)); + } + + @Test + public void testCountLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "count", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 2L, 2L, 2L)); + } + + @Test + public void testSumLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "sum", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 20L, 2L, 24L)); + } + + @Test + public void testAvgLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "avg", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{13L,5L,7L,19L}), + buildHashMap(null, 10.0, 2L, 12.0)); + } + + @Test + public void testVarLongNullKeyGroupBySingleBatch() throws HiveException { + testAggregateLongKeyAggregate( + "variance", + 4, + Arrays.asList(new Long[]{null,2L,01L,02L,01L,01L}), + Arrays.asList(new Long[]{13L, 5L,18L,19L,12L,15L}), + buildHashMap(null, 0.0, 2L, 49.0, 01L, 6.0)); + } + + @Test + public void testMinNullLongNullKeyGroupBy() throws HiveException { + testAggregateLongKeyAggregate( + "min", + 4, + Arrays.asList(new Long[]{null,2L,null,02L}), + Arrays.asList(new Long[]{null, null, null, null}), + buildHashMap(null, null, 2L, null)); + } + + @Test + public void testMinLongGroupBy() throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + 5L); + } + + + @Test + public void testMinLongSimple() throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + 5L); + } + + @Test + public void testMinLongEmpty() throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{}), + null); + } + + @Test + public void testMinLongNulls() throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{null}), + null); + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{null, null, null}), + null); + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{null,5L,7L,19L}), + 5L); + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,null,7L,19L}), + 7L); + } + + @Test + public void testMinLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "min", + 42L, + 4096, + 1024, + 42L); + } + + @Test + public void testMinLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "min", + null, + 4096, + 1024, + null); + } + + + @Test + public void testMinLongNegative () throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,5L,7L,-19L}), + -19L); + } + + @Test + public void testMinLongMinInt () throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,5L,(long)Integer.MIN_VALUE,-19L}), + (long)Integer.MIN_VALUE); + } + + @Test + public void testMinLongMinLong () throws HiveException { + testAggregateLongAggregate( + "min", + 2, + Arrays.asList(new Long[]{13L,5L, Long.MIN_VALUE, (long)Integer.MIN_VALUE}), + Long.MIN_VALUE); + } + + @Test + public void testMaxLongSimple () throws HiveException { + testAggregateLongAggregate( + "max", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + 19L); + } + + @Test + public void testMaxLongEmpty () throws HiveException { + testAggregateLongAggregate( + "max", + 2, + Arrays.asList(new Long[]{}), + null); + } + + + @Test + public void testMaxLongNegative () throws HiveException { + testAggregateLongAggregate( + "max", + 2, + Arrays.asList(new Long[]{-13L,-5L,-7L,-19L}), + -5L); + } + + @Test + public void testMaxLongMaxInt () throws HiveException { + testAggregateLongAggregate( + "max", + 2, + Arrays.asList(new Long[]{13L,5L,7L,(long)Integer.MAX_VALUE}), + (long)Integer.MAX_VALUE); + } + + @Test + public void testMaxLongMaxLong () throws HiveException { + testAggregateLongAggregate( + "max", + 2, + Arrays.asList(new Long[]{13L,Long.MAX_VALUE - 1L,Long.MAX_VALUE,(long)Integer.MAX_VALUE}), + Long.MAX_VALUE); + } + + @Test + public void testMaxLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "max", + 42L, + 4096, + 1024, + 42L); + } + + @Test + public void testMaxLongNulls () throws HiveException { + testAggregateLongRepeats ( + "max", + null, + 4096, + 1024, + null); + } + + @SuppressWarnings("unchecked") + @Test + public void testMinLongConcatRepeat () throws HiveException { + testAggregateLongIterable ("min", + new FakeVectorRowBatchFromConcat( + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2), + new FakeVectorRowBatchFromRepeats( + new Long[] {7L}, 15, 2), + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2)), + 7L); + } + + @SuppressWarnings("unchecked") + @Test + public void testMinLongRepeatConcatValues () throws HiveException { + testAggregateLongIterable ("min", + new FakeVectorRowBatchFromConcat( + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2), + new FakeVectorRowBatchFromLongIterables( + 3, + Arrays.asList(new Long[]{13L, 7L, 23L, 29L}))), + 7L); + } + + @Test + public void testCountLongSimple () throws HiveException { + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + 4L); + } + + @Test + public void testCountLongEmpty () throws HiveException { + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{}), + null); + } + + @Test + public void testCountLongNulls () throws HiveException { + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{null}), + 0L); + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{null, null, null}), + 0L); + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{null,5L,7L,19L}), + 3L); + testAggregateLongAggregate( + "count", + 2, + Arrays.asList(new Long[]{13L,null,7L,19L}), + 3L); + } + + + @Test + public void testCountLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "count", + 42L, + 4096, + 1024, + 4096L); + } + + @Test + public void testCountLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "count", + null, + 4096, + 1024, + 0L); + } + + + @SuppressWarnings("unchecked") + @Test + public void testCountLongRepeatConcatValues () throws HiveException { + testAggregateLongIterable ("count", + new FakeVectorRowBatchFromConcat( + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2), + new FakeVectorRowBatchFromLongIterables( + 3, + Arrays.asList(new Long[]{13L, 7L, 23L, 29L}))), + 14L); + } + + @Test + public void testSumDoubleSimple() throws HiveException { + testAggregateDouble( + "sum", + 2, + Arrays.asList(new Object[]{13.0,5.0,7.0,19.0}), + 13.0 + 5.0 + 7.0 + 19.0); + } + + @Test + public void testSumDoubleGroupByString() throws HiveException { + testAggregateDoubleStringKeyAggregate( + "sum", + 4, + Arrays.asList(new Object[]{"A", null, "A", null}), + Arrays.asList(new Object[]{13.0,5.0,7.0,19.0}), + buildHashMap("A", 20.0, null, 24.0)); + } + + @Test + public void testSumLongSimple () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + 13L + 5L + 7L + 19L); + } + + @Test + public void testSumLongEmpty () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{}), + null); + } + + @Test + public void testSumLongNulls () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{null}), + null); + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{null, null, null}), + null); + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{null,5L,7L,19L}), + 5L + 7L + 19L); + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{13L,null,7L,19L}), + 13L + 7L + 19L); + } + + @Test + public void testSumLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "sum", + 42L, + 4096, + 1024, + 4096L * 42L); + } + + @Test + public void testSumLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "sum", + null, + 4096, + 1024, + null); + } + + + @SuppressWarnings("unchecked") + @Test + public void testSumLongRepeatConcatValues () throws HiveException { + testAggregateLongIterable ("sum", + new FakeVectorRowBatchFromConcat( + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2), + new FakeVectorRowBatchFromLongIterables( + 3, + Arrays.asList(new Long[]{13L, 7L, 23L, 29L}))), + 19L*10L + 13L + 7L + 23L +29L); + } + + @Test + public void testSumLongZero () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{-(long)Integer.MAX_VALUE, (long)Integer.MAX_VALUE}), + 0L); + } + + @Test + public void testSumLong2MaxInt () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{(long)Integer.MAX_VALUE, (long)Integer.MAX_VALUE}), + 4294967294L); + } + + @Test + public void testSumLong2MinInt () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{(long)Integer.MIN_VALUE, (long)Integer.MIN_VALUE}), + -4294967296L); + } + + @Test + public void testSumLong2MaxLong () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{Long.MAX_VALUE, Long.MAX_VALUE}), + -2L); // silent overflow + } + + @Test + public void testSumLong2MinLong () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{Long.MIN_VALUE, Long.MIN_VALUE}), + 0L); // silent overflow + } + + @Test + public void testSumLongMinMaxLong () throws HiveException { + testAggregateLongAggregate( + "sum", + 2, + Arrays.asList(new Long[]{Long.MAX_VALUE, Long.MIN_VALUE}), + -1L); + } + + @Test + public void testAvgLongSimple () throws HiveException { + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + (double) (13L + 5L + 7L + 19L) / (double) 4L); + } + + @Test + public void testAvgLongEmpty () throws HiveException { + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{}), + null); + } + + @Test + public void testAvgLongNulls () throws HiveException { + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{null}), + null); + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{null, null, null}), + null); + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{null,5L,7L,19L}), + (double) (5L + 7L + 19L) / (double) 3L); + testAggregateLongAggregate( + "avg", + 2, + Arrays.asList(new Long[]{13L,null,7L,19L}), + (double) (13L + + 7L + 19L) / (double) 3L); + } + + + @Test + public void testAvgLongRepeat () throws HiveException + { + testAggregateLongRepeats ( + "avg", + 42L, + 4096, + 1024, + (double)42); + } + + @Test + public void testAvgLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "avg", + null, + 4096, + 1024, + null); + } + + @SuppressWarnings("unchecked") + @Test + public void testAvgLongRepeatConcatValues () throws HiveException { + testAggregateLongIterable ("avg", + new FakeVectorRowBatchFromConcat( + new FakeVectorRowBatchFromRepeats( + new Long[] {19L}, 10, 2), + new FakeVectorRowBatchFromLongIterables( + 3, + Arrays.asList(new Long[]{13L, 7L, 23L, 29L}))), + (double) (19L*10L + 13L + 7L + 23L +29L) / (double) 14 ); + } + + @Test + public void testVarianceLongSimple () throws HiveException { + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + (double) 30L); + } + + @Test + public void testVarianceLongEmpty () throws HiveException { + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{}), + null); + } + + @Test + public void testVarianceLongSingle () throws HiveException { + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{97L}), + (double)0.0); + } + + @Test + public void testVarianceLongNulls () throws HiveException { + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{null}), + null); + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{null, null, null}), + null); + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{null,13L, 5L,7L,19L}), + (double) 30.0); + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{13L,null,5L, 7L,19L}), + (double) 30.0); + testAggregateLongAggregate( + "variance", + 2, + Arrays.asList(new Long[]{null,null,null,19L}), + (double) 0); + } + + @Test + public void testVarPopLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "var_pop", + null, + 4096, + 1024, + null); + } + + @Test + public void testVarPopLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "var_pop", + 42L, + 4096, + 1024, + (double)0); + } + + @Test + public void testVarSampLongSimple () throws HiveException { + testAggregateLongAggregate( + "var_samp", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + (double) 40L); + } + + @Test + public void testVarSampLongEmpty () throws HiveException { + testAggregateLongAggregate( + "var_samp", + 2, + Arrays.asList(new Long[]{}), + null); + } + + + @Test + public void testVarSampLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "var_samp", + 42L, + 4096, + 1024, + (double)0); + } + + @Test + public void testStdLongSimple () throws HiveException { + testAggregateLongAggregate( + "std", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + (double) Math.sqrt(30)); + } + + @Test + public void testStdLongEmpty () throws HiveException { + testAggregateLongAggregate( + "std", + 2, + Arrays.asList(new Long[]{}), + null); + } + + + @Test + public void testStdDevLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "stddev", + 42L, + 4096, + 1024, + (double)0); + } + + @Test + public void testStdDevLongRepeatNulls () throws HiveException { + testAggregateLongRepeats ( + "stddev", + null, + 4096, + 1024, + null); + } + + + @Test + public void testStdDevSampSimple () throws HiveException { + testAggregateLongAggregate( + "stddev_samp", + 2, + Arrays.asList(new Long[]{13L,5L,7L,19L}), + (double) Math.sqrt(40)); + } + + @Test + public void testStdDevSampLongRepeat () throws HiveException { + testAggregateLongRepeats ( + "stddev_samp", + 42L, + 3, + 1024, + (double)0); + } + + private void testMultiKey( + String aggregateName, + FakeVectorRowBatchFromObjectIterables data, + HashMap expected) throws HiveException { + + Map mapColumnNames = new HashMap(); + ArrayList outputColumnNames = new ArrayList(); + ArrayList keysDesc = new ArrayList(); + Set keys = new HashSet(); + + // The types array tells us the number of columns in the data + final String[] columnTypes = data.getTypes(); + + // Columns 0..N-1 are keys. Column N is the aggregate value input + int i=0; + for(; i aggs = new ArrayList(1); + aggs.add( + buildAggregationDesc(ctx, aggregateName, + "value", TypeInfoFactory.getPrimitiveTypeInfo(columnTypes[i]))); + + for(i=0; i expected; + private Set keys; + + @Override + public void inspectRow(Object row, int tag) throws HiveException { + assertTrue(row instanceof Object[]); + Object[] fields = (Object[]) row; + assertEquals(columnTypes.length, fields.length); + ArrayList keyValue = new ArrayList(columnTypes.length-1); + for(int i=0; i expected, Set keys) { + this.aggregateName = aggregateName; + this.expected = expected; + this.keys = keys; + return this; + } + }.init(aggregateName, expected, keys)); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(expected.size(), outBatchList.size()); + assertEquals(expected.size(), keys.size()); + } + + + private void testKeyTypeAggregate( + String aggregateName, + FakeVectorRowBatchFromObjectIterables data, + Map expected) throws HiveException { + + Map mapColumnNames = new HashMap(); + mapColumnNames.put("Key", 0); + mapColumnNames.put("Value", 1); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 2); + Set keys = new HashSet(); + + AggregationDesc agg = buildAggregationDesc(ctx, aggregateName, + "Value", TypeInfoFactory.getPrimitiveTypeInfo(data.getTypes()[1])); + ArrayList aggs = new ArrayList(); + aggs.add(agg); + + ArrayList outputColumnNames = new ArrayList(); + outputColumnNames.add("_col0"); + outputColumnNames.add("_col1"); + + GroupByDesc desc = new GroupByDesc(); + desc.setOutputColumnNames(outputColumnNames); + desc.setAggregators(aggs); + + ExprNodeDesc keyExp = buildColumnDesc(ctx, "Key", + TypeInfoFactory.getPrimitiveTypeInfo(data.getTypes()[0])); + ArrayList keysDesc = new ArrayList(); + keysDesc.add(keyExp); + desc.setKeys(keysDesc); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + out.setOutputInspector(new FakeCaptureOutputOperator.OutputInspector() { + + private int rowIndex; + private String aggregateName; + private Map expected; + private Set keys; + + @Override + public void inspectRow(Object row, int tag) throws HiveException { + assertTrue(row instanceof Object[]); + Object[] fields = (Object[]) row; + assertEquals(2, fields.length); + Object key = fields[0]; + Object keyValue = null; + if (null == key) { + keyValue = null; + } else if (key instanceof ByteWritable) { + ByteWritable bwKey = (ByteWritable)key; + keyValue = bwKey.get(); + } else if (key instanceof ShortWritable) { + ShortWritable swKey = (ShortWritable)key; + keyValue = swKey.get(); + } else if (key instanceof IntWritable) { + IntWritable iwKey = (IntWritable)key; + keyValue = iwKey.get(); + } else if (key instanceof LongWritable) { + LongWritable lwKey = (LongWritable)key; + keyValue = lwKey.get(); + } else if (key instanceof TimestampWritable) { + TimestampWritable twKey = (TimestampWritable)key; + keyValue = twKey.getTimestamp(); + } else if (key instanceof DoubleWritable) { + DoubleWritable dwKey = (DoubleWritable)key; + keyValue = dwKey.get(); + } else if (key instanceof FloatWritable) { + FloatWritable fwKey = (FloatWritable)key; + keyValue = fwKey.get(); + } else if (key instanceof BooleanWritable) { + BooleanWritable bwKey = (BooleanWritable)key; + keyValue = bwKey.get(); + } else { + Assert.fail(String.format("Not implemented key output type %s: %s", + key.getClass().getName(), key)); + } + + String keyValueAsString = String.format("%s", keyValue); + + assertTrue(expected.containsKey(keyValue)); + Object expectedValue = expected.get(keyValue); + Object value = fields[1]; + Validator validator = getValidator(aggregateName); + validator.validate(keyValueAsString, expectedValue, new Object[] {value}); + keys.add(keyValue); + } + + private FakeCaptureOutputOperator.OutputInspector init( + String aggregateName, Map expected, Set keys) { + this.aggregateName = aggregateName; + this.expected = expected; + this.keys = keys; + return this; + } + }.init(aggregateName, expected, keys)); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(expected.size(), outBatchList.size()); + assertEquals(expected.size(), keys.size()); + } + + + public void testAggregateLongRepeats ( + String aggregateName, + Long value, + int repeat, + int batchSize, + Object expected) throws HiveException { + FakeVectorRowBatchFromRepeats fdr = new FakeVectorRowBatchFromRepeats( + new Long[] {value}, repeat, batchSize); + testAggregateLongIterable (aggregateName, fdr, expected); + } + + public HashMap buildHashMap(Object... pairs) { + HashMap map = new HashMap(); + for(int i = 0; i < pairs.length; i += 2) { + map.put(pairs[i], pairs[i+1]); + } + return map; + } + + public void testAggregateStringKeyAggregate ( + String aggregateName, + int batchSize, + Iterable list, + Iterable values, + HashMap expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromObjectIterables fdr = new FakeVectorRowBatchFromObjectIterables( + batchSize, + new String[] {"string", "long"}, + list, + values); + testAggregateStringKeyIterable (aggregateName, fdr, TypeInfoFactory.longTypeInfo, expected); + } + + public void testAggregateDoubleStringKeyAggregate ( + String aggregateName, + int batchSize, + Iterable list, + Iterable values, + HashMap expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromObjectIterables fdr = new FakeVectorRowBatchFromObjectIterables( + batchSize, + new String[] {"string", "double"}, + list, + values); + testAggregateStringKeyIterable (aggregateName, fdr, TypeInfoFactory.doubleTypeInfo, expected); + } + + public void testAggregateLongKeyAggregate ( + String aggregateName, + int batchSize, + List list, + Iterable values, + HashMap expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromLongIterables fdr = new FakeVectorRowBatchFromLongIterables(batchSize, + list, values); + testAggregateLongKeyIterable (aggregateName, fdr, expected); + } + + public void testAggregateString ( + String aggregateName, + int batchSize, + Iterable values, + Object expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromObjectIterables fdr = new FakeVectorRowBatchFromObjectIterables( + batchSize, new String[] {"string"}, values); + testAggregateStringIterable (aggregateName, fdr, expected); + } + + public void testAggregateDouble ( + String aggregateName, + int batchSize, + Iterable values, + Object expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromObjectIterables fdr = new FakeVectorRowBatchFromObjectIterables( + batchSize, new String[] {"double"}, values); + testAggregateDoubleIterable (aggregateName, fdr, expected); + } + + + public void testAggregateLongAggregate ( + String aggregateName, + int batchSize, + Iterable values, + Object expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromLongIterables fdr = new FakeVectorRowBatchFromLongIterables(batchSize, + values); + testAggregateLongIterable (aggregateName, fdr, expected); + } + + public void testAggregateCountStar ( + int batchSize, + Iterable values, + Object expected) throws HiveException { + + @SuppressWarnings("unchecked") + FakeVectorRowBatchFromLongIterables fdr = new FakeVectorRowBatchFromLongIterables(batchSize, + values); + testAggregateCountStarIterable (fdr, expected); + } + + + public static interface Validator { + void validate (String key, Object expected, Object result); + }; + + public static class ValueValidator implements Validator { + @Override + public void validate(String key, Object expected, Object result) { + + assertEquals(true, result instanceof Object[]); + Object[] arr = (Object[]) result; + assertEquals(1, arr.length); + + if (expected == null) { + assertEquals(key, null, arr[0]); + } else if (arr[0] instanceof LongWritable) { + LongWritable lw = (LongWritable) arr[0]; + assertEquals(key, (Long) expected, (Long) lw.get()); + } else if (arr[0] instanceof Text) { + Text tx = (Text) arr[0]; + String sbw = tx.toString(); + assertEquals(key, (String) expected, sbw); + } else if (arr[0] instanceof DoubleWritable) { + DoubleWritable dw = (DoubleWritable) arr[0]; + assertEquals (key, (Double) expected, (Double) dw.get()); + } else if (arr[0] instanceof Double) { + assertEquals (key, (Double) expected, (Double) arr[0]); + } else if (arr[0] instanceof Long) { + assertEquals (key, (Long) expected, (Long) arr[0]); + } else { + Assert.fail("Unsupported result type: " + arr[0].getClass().getName()); + } + } + } + + public static class AvgValidator implements Validator { + + @Override + public void validate(String key, Object expected, Object result) { + Object[] arr = (Object[]) result; + assertEquals (1, arr.length); + + if (expected == null) { + assertEquals(key, null, arr[0]); + } else { + assertEquals (true, arr[0] instanceof Object[]); + Object[] vals = (Object[]) arr[0]; + assertEquals (2, vals.length); + + assertEquals (true, vals[0] instanceof LongWritable); + assertEquals (true, vals[1] instanceof DoubleWritable); + LongWritable lw = (LongWritable) vals[0]; + DoubleWritable dw = (DoubleWritable) vals[1]; + assertFalse (lw.get() == 0L); + assertEquals (key, (Double) expected, (Double) (dw.get() / lw.get())); + } + } + + } + + public abstract static class BaseVarianceValidator implements Validator { + + abstract void validateVariance (String key, + double expected, long cnt, double sum, double variance); + + @Override + public void validate(String key, Object expected, Object result) { + Object[] arr = (Object[]) result; + assertEquals (1, arr.length); + + if (expected == null) { + assertEquals(null, arr[0]); + } else { + assertEquals (true, arr[0] instanceof Object[]); + Object[] vals = (Object[]) arr[0]; + assertEquals (3, vals.length); + + assertEquals (true, vals[0] instanceof LongWritable); + assertEquals (true, vals[1] instanceof DoubleWritable); + assertEquals (true, vals[2] instanceof DoubleWritable); + LongWritable cnt = (LongWritable) vals[0]; + DoubleWritable sum = (DoubleWritable) vals[1]; + DoubleWritable var = (DoubleWritable) vals[2]; + assertTrue (1 <= cnt.get()); + validateVariance (key, (Double) expected, cnt.get(), sum.get(), var.get()); + } + } + } + + public static class VarianceValidator extends BaseVarianceValidator { + + @Override + void validateVariance(String key, double expected, long cnt, double sum, double variance) { + assertEquals (key, expected, variance /cnt, 0.0); + } + } + + public static class VarianceSampValidator extends BaseVarianceValidator { + + @Override + void validateVariance(String key, double expected, long cnt, double sum, double variance) { + assertEquals (key, expected, variance /(cnt-1), 0.0); + } + } + + public static class StdValidator extends BaseVarianceValidator { + + @Override + void validateVariance(String key, double expected, long cnt, double sum, double variance) { + assertEquals (key, expected, Math.sqrt(variance / cnt), 0.0); + } + } + + public static class StdSampValidator extends BaseVarianceValidator { + + @Override + void validateVariance(String key, double expected, long cnt, double sum, double variance) { + assertEquals (key, expected, Math.sqrt(variance / (cnt-1)), 0.0); + } + } + + private static Object[][] validators = { + {"count", ValueValidator.class}, + {"min", ValueValidator.class}, + {"max", ValueValidator.class}, + {"sum", ValueValidator.class}, + {"avg", AvgValidator.class}, + {"variance", VarianceValidator.class}, + {"var_pop", VarianceValidator.class}, + {"var_samp", VarianceSampValidator.class}, + {"std", StdValidator.class}, + {"stddev", StdValidator.class}, + {"stddev_samp", StdSampValidator.class}, + }; + + public static Validator getValidator(String aggregate) throws HiveException { + try + { + for (Object[] v: validators) { + if (aggregate.equalsIgnoreCase((String) v[0])) { + @SuppressWarnings("unchecked") + Class c = (Class) v[1]; + Constructor ctr = c.getConstructor(); + return ctr.newInstance(); + } + } + }catch(Exception e) { + throw new HiveException(e); + } + throw new HiveException("Missing validator for aggregate: " + aggregate); + } + + public void testAggregateCountStarIterable ( + Iterable data, + Object expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("A", 0); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 1); + + GroupByDesc desc = buildGroupByDescCountStar (ctx); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(1, outBatchList.size()); + + Object result = outBatchList.get(0); + + Validator validator = getValidator("count"); + validator.validate("_total", expected, result); + } + + public void testAggregateStringIterable ( + String aggregateName, + Iterable data, + Object expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("A", 0); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 1); + + GroupByDesc desc = buildGroupByDescType(ctx, aggregateName, "A", + TypeInfoFactory.stringTypeInfo); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(1, outBatchList.size()); + + Object result = outBatchList.get(0); + + Validator validator = getValidator(aggregateName); + validator.validate("_total", expected, result); + } + + public void testAggregateDoubleIterable ( + String aggregateName, + Iterable data, + Object expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("A", 0); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 1); + + GroupByDesc desc = buildGroupByDescType (ctx, aggregateName, "A", + TypeInfoFactory.doubleTypeInfo); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(1, outBatchList.size()); + + Object result = outBatchList.get(0); + + Validator validator = getValidator(aggregateName); + validator.validate("_total", expected, result); + } + + public void testAggregateLongIterable ( + String aggregateName, + Iterable data, + Object expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("A", 0); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 1); + + GroupByDesc desc = buildGroupByDescType(ctx, aggregateName, "A", TypeInfoFactory.longTypeInfo); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(1, outBatchList.size()); + + Object result = outBatchList.get(0); + + Validator validator = getValidator(aggregateName); + validator.validate("_total", expected, result); + } + + public void testAggregateLongKeyIterable ( + String aggregateName, + Iterable data, + HashMap expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("Key", 0); + mapColumnNames.put("Value", 1); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 2); + Set keys = new HashSet(); + + GroupByDesc desc = buildKeyGroupByDesc (ctx, aggregateName, "Value", + TypeInfoFactory.longTypeInfo, "Key", TypeInfoFactory.longTypeInfo); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + out.setOutputInspector(new FakeCaptureOutputOperator.OutputInspector() { + + private int rowIndex; + private String aggregateName; + private HashMap expected; + private Set keys; + + @Override + public void inspectRow(Object row, int tag) throws HiveException { + assertTrue(row instanceof Object[]); + Object[] fields = (Object[]) row; + assertEquals(2, fields.length); + Object key = fields[0]; + Long keyValue = null; + if (null != key) { + assertTrue(key instanceof LongWritable); + LongWritable lwKey = (LongWritable)key; + keyValue = lwKey.get(); + } + assertTrue(expected.containsKey(keyValue)); + String keyAsString = String.format("%s", key); + Object expectedValue = expected.get(keyValue); + Object value = fields[1]; + Validator validator = getValidator(aggregateName); + validator.validate(keyAsString, expectedValue, new Object[] {value}); + keys.add(keyValue); + } + + private FakeCaptureOutputOperator.OutputInspector init( + String aggregateName, HashMap expected, Set keys) { + this.aggregateName = aggregateName; + this.expected = expected; + this.keys = keys; + return this; + } + }.init(aggregateName, expected, keys)); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(expected.size(), outBatchList.size()); + assertEquals(expected.size(), keys.size()); + } + + public void testAggregateStringKeyIterable ( + String aggregateName, + Iterable data, + TypeInfo dataTypeInfo, + HashMap expected) throws HiveException { + Map mapColumnNames = new HashMap(); + mapColumnNames.put("Key", 0); + mapColumnNames.put("Value", 1); + VectorizationContext ctx = new VectorizationContext(mapColumnNames, 2); + Set keys = new HashSet(); + + GroupByDesc desc = buildKeyGroupByDesc (ctx, aggregateName, "Value", + dataTypeInfo, "Key", TypeInfoFactory.stringTypeInfo); + + VectorGroupByOperator vgo = new VectorGroupByOperator(ctx, desc); + + FakeCaptureOutputOperator out = FakeCaptureOutputOperator.addCaptureOutputChild(vgo); + vgo.initialize(null, null); + out.setOutputInspector(new FakeCaptureOutputOperator.OutputInspector() { + + private int rowIndex; + private String aggregateName; + private HashMap expected; + private Set keys; + + @SuppressWarnings("deprecation") + @Override + public void inspectRow(Object row, int tag) throws HiveException { + assertTrue(row instanceof Object[]); + Object[] fields = (Object[]) row; + assertEquals(2, fields.length); + Object key = fields[0]; + String keyValue = null; + if (null != key) { + assertTrue(key instanceof Text); + Text bwKey = (Text)key; + keyValue = bwKey.toString(); + } + assertTrue(expected.containsKey(keyValue)); + Object expectedValue = expected.get(keyValue); + Object value = fields[1]; + Validator validator = getValidator(aggregateName); + String keyAsString = String.format("%s", key); + validator.validate(keyAsString, expectedValue, new Object[] {value}); + keys.add(keyValue); + } + + private FakeCaptureOutputOperator.OutputInspector init( + String aggregateName, HashMap expected, Set keys) { + this.aggregateName = aggregateName; + this.expected = expected; + this.keys = keys; + return this; + } + }.init(aggregateName, expected, keys)); + + for (VectorizedRowBatch unit: data) { + vgo.process(unit, 0); + } + vgo.close(false); + + List outBatchList = out.getCapturedRows(); + assertNotNull(outBatchList); + assertEquals(expected.size(), outBatchList.size()); + assertEquals(expected.size(), keys.size()); + } + + +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorSelectOperator.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorSelectOperator.java new file mode 100644 index 0000000..759601d --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorSelectOperator.java @@ -0,0 +1,123 @@ +/** + * 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.exec.vector; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.SelectDesc; +import org.apache.hadoop.hive.ql.udf.UDFOPPlus; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.junit.Test; + +/** + * Unit tests for vectorized select operator. + */ +public class TestVectorSelectOperator { + + static class ValidatorVectorSelectOperator extends VectorSelectOperator { + + private static final long serialVersionUID = 1L; + + public ValidatorVectorSelectOperator(VectorizationContext ctxt, OperatorDesc conf) + throws HiveException { + super(ctxt, conf); + initializeOp(null); + } + + /** + * Override forward to do validation + */ + @Override + public void forward(Object row, ObjectInspector rowInspector) throws HiveException { + VectorizedRowBatch vrg = (VectorizedRowBatch) row; + + int[] projections = vrg.projectedColumns; + assertEquals(2, vrg.projectionSize); + assertEquals(3, projections[0]); + assertEquals(2, projections[1]); + + LongColumnVector out0 = (LongColumnVector) vrg.cols[projections[0]]; + LongColumnVector out1 = (LongColumnVector) vrg.cols[projections[1]]; + + LongColumnVector in0 = (LongColumnVector) vrg.cols[0]; + LongColumnVector in1 = (LongColumnVector) vrg.cols[1]; + LongColumnVector in2 = (LongColumnVector) vrg.cols[2]; + LongColumnVector in3 = (LongColumnVector) vrg.cols[3]; + + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + assertEquals(in0.vector[i] + in1.vector[i], out0.vector[i]); + assertEquals(in3.vector[i], out0.vector[i]); + assertEquals(in2.vector[i], out1.vector[i]); + } + } + } + + @Test + public void testSelectOperator() throws HiveException { + + Map columnMap = new HashMap(); + columnMap.put("a", 0); columnMap.put("b", 1); columnMap.put("c", 2); + VectorizationContext vc = new VectorizationContext(columnMap, 3); + + SelectDesc selDesc = new SelectDesc(false); + List colList = new ArrayList(); + ExprNodeColumnDesc colDesc1 = new ExprNodeColumnDesc(Long.class, "a", "table", false); + ExprNodeColumnDesc colDesc2 = new ExprNodeColumnDesc(Long.class, "b", "table", false); + ExprNodeColumnDesc colDesc3 = new ExprNodeColumnDesc(Long.class, "c", "table", false); + ExprNodeGenericFuncDesc plusDesc = new ExprNodeGenericFuncDesc(); + GenericUDF gudf = new GenericUDFBridge("+", true, UDFOPPlus.class.getCanonicalName()); + plusDesc.setGenericUDF(gudf); + List children = new ArrayList(); + children.add(colDesc1); + children.add(colDesc2); + plusDesc.setChildExprs(children); + plusDesc.setTypeInfo(TypeInfoFactory.longTypeInfo); + + colList.add(plusDesc); + colList.add(colDesc3); + selDesc.setColList(colList); + + List outputColNames = new ArrayList(); + outputColNames.add("_col0"); + outputColNames.add("_col1"); + selDesc.setOutputColumnNames(outputColNames); + + ValidatorVectorSelectOperator vso = new ValidatorVectorSelectOperator(vc, selDesc); + + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + VectorizedRowBatch.DEFAULT_SIZE, 4, 17); + + vso.processOp(vrg, 0); + } + +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizationContext.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizationContext.java new file mode 100644 index 0000000..2276330 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizationContext.java @@ -0,0 +1,401 @@ +/** + * 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.exec.vector; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterExprAndExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.FilterExprOrExpr; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DoubleColUnaryMinus; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterDoubleColLessDoubleScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongScalarGreaterLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColGreaterStringColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColGreaterStringScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColModuloLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColMultiplyLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColSubtractLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColUnaryMinus; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongScalarSubtractLongColumn; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.ql.udf.UDFOPMinus; +import org.apache.hadoop.hive.ql.udf.UDFOPMod; +import org.apache.hadoop.hive.ql.udf.UDFOPMultiply; +import org.apache.hadoop.hive.ql.udf.UDFOPNegative; +import org.apache.hadoop.hive.ql.udf.UDFOPPlus; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPAnd; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPGreaterThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPLessThan; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFOPOr; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.junit.Test; + +public class TestVectorizationContext { + + @Test + public void testArithmeticExpressionVectorization() throws HiveException { + /** + * Create original expression tree for following + * (plus (minus (plus col1 col2) col3) (multiply col4 (mod col5 col6)) ) + */ + GenericUDFBridge udf1 = new GenericUDFBridge("+", true, UDFOPPlus.class.getCanonicalName()); + GenericUDFBridge udf2 = new GenericUDFBridge("-", true, UDFOPMinus.class.getCanonicalName()); + GenericUDFBridge udf3 = new GenericUDFBridge("*", true, UDFOPMultiply.class.getCanonicalName()); + GenericUDFBridge udf4 = new GenericUDFBridge("+", true, UDFOPPlus.class.getCanonicalName()); + GenericUDFBridge udf5 = new GenericUDFBridge("%", true, UDFOPMod.class.getCanonicalName()); + + ExprNodeGenericFuncDesc sumExpr = new ExprNodeGenericFuncDesc(); + sumExpr.setGenericUDF(udf1); + ExprNodeGenericFuncDesc minusExpr = new ExprNodeGenericFuncDesc(); + minusExpr.setGenericUDF(udf2); + ExprNodeGenericFuncDesc multiplyExpr = new ExprNodeGenericFuncDesc(); + multiplyExpr.setGenericUDF(udf3); + ExprNodeGenericFuncDesc sum2Expr = new ExprNodeGenericFuncDesc(); + sum2Expr.setGenericUDF(udf4); + ExprNodeGenericFuncDesc modExpr = new ExprNodeGenericFuncDesc(); + modExpr.setGenericUDF(udf5); + + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Long.class, "col1", "table", false); + ExprNodeColumnDesc col2Expr = new ExprNodeColumnDesc(Long.class, "col2", "table", false); + ExprNodeColumnDesc col3Expr = new ExprNodeColumnDesc(Long.class, "col3", "table", false); + ExprNodeColumnDesc col4Expr = new ExprNodeColumnDesc(Long.class, "col4", "table", false); + ExprNodeColumnDesc col5Expr = new ExprNodeColumnDesc(Long.class, "col5", "table", false); + ExprNodeColumnDesc col6Expr = new ExprNodeColumnDesc(Long.class, "col6", "table", false); + + List children1 = new ArrayList(2); + List children2 = new ArrayList(2); + List children3 = new ArrayList(2); + List children4 = new ArrayList(2); + List children5 = new ArrayList(2); + + children1.add(minusExpr); + children1.add(multiplyExpr); + sumExpr.setChildExprs(children1); + + children2.add(sum2Expr); + children2.add(col3Expr); + minusExpr.setChildExprs(children2); + + children3.add(col1Expr); + children3.add(col2Expr); + sum2Expr.setChildExprs(children3); + + children4.add(col4Expr); + children4.add(modExpr); + multiplyExpr.setChildExprs(children4); + + children5.add(col5Expr); + children5.add(col6Expr); + modExpr.setChildExprs(children5); + + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + columnMap.put("col2", 2); + columnMap.put("col3", 3); + columnMap.put("col4", 4); + columnMap.put("col5", 5); + columnMap.put("col6", 6); + + //Generate vectorized expression + VectorizationContext vc = new VectorizationContext(columnMap, 6); + + VectorExpression ve = vc.getVectorExpression(sumExpr); + + //Verify vectorized expression + assertTrue(ve instanceof LongColAddLongColumn); + assertEquals(2, ve.getChildExpressions().length); + VectorExpression childExpr1 = ve.getChildExpressions()[0]; + VectorExpression childExpr2 = ve.getChildExpressions()[1]; + assertEquals(6, ve.getOutputColumn()); + + assertTrue(childExpr1 instanceof LongColSubtractLongColumn); + assertEquals(1, childExpr1.getChildExpressions().length); + assertTrue(childExpr1.getChildExpressions()[0] instanceof LongColAddLongColumn); + assertEquals(7, childExpr1.getOutputColumn()); + assertEquals(6, childExpr1.getChildExpressions()[0].getOutputColumn()); + + assertTrue(childExpr2 instanceof LongColMultiplyLongColumn); + assertEquals(1, childExpr2.getChildExpressions().length); + assertTrue(childExpr2.getChildExpressions()[0] instanceof LongColModuloLongColumn); + assertEquals(8, childExpr2.getOutputColumn()); + assertEquals(6, childExpr2.getChildExpressions()[0].getOutputColumn()); + } + + @Test + public void testStringFilterExpressions() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(String.class, "col1", "table", false); + ExprNodeConstantDesc constDesc = new ExprNodeConstantDesc("Alpha"); + + GenericUDFOPGreaterThan udf = new GenericUDFOPGreaterThan(); + ExprNodeGenericFuncDesc exprDesc = new ExprNodeGenericFuncDesc(); + exprDesc.setGenericUDF(udf); + List children1 = new ArrayList(2); + children1.add(col1Expr); + children1.add(constDesc); + exprDesc.setChildExprs(children1); + + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + columnMap.put("col2", 2); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.FILTER); + + VectorExpression ve = vc.getVectorExpression(exprDesc); + + assertTrue(ve instanceof FilterStringColGreaterStringScalar); + } + + @Test + public void testFilterStringColCompareStringColumnExpressions() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(String.class, "col1", "table", false); + ExprNodeColumnDesc col2Expr = new ExprNodeColumnDesc(String.class, "col2", "table", false); + + GenericUDFOPGreaterThan udf = new GenericUDFOPGreaterThan(); + ExprNodeGenericFuncDesc exprDesc = new ExprNodeGenericFuncDesc(); + exprDesc.setGenericUDF(udf); + List children1 = new ArrayList(2); + children1.add(col1Expr); + children1.add(col2Expr); + exprDesc.setChildExprs(children1); + + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + columnMap.put("col2", 2); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.FILTER); + + VectorExpression ve = vc.getVectorExpression(exprDesc); + + assertTrue(ve instanceof FilterStringColGreaterStringColumn); + } + + @Test + public void testFloatInExpressions() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Float.class, "col1", "table", false); + ExprNodeConstantDesc constDesc = new ExprNodeConstantDesc(new Integer(10)); + + GenericUDFBridge udf = new GenericUDFBridge("+", false, UDFOPPlus.class.getCanonicalName()); + ExprNodeGenericFuncDesc exprDesc = new ExprNodeGenericFuncDesc(); + exprDesc.setGenericUDF(udf); + + List children1 = new ArrayList(2); + children1.add(col1Expr); + children1.add(constDesc); + exprDesc.setChildExprs(children1); + + Map columnMap = new HashMap(); + columnMap.put("col1", 0); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.SELECT); + + VectorExpression ve = vc.getVectorExpression(exprDesc); + + assertTrue(ve.getOutputType().equalsIgnoreCase("double")); + } + + @Test + public void testVectorizeAndOrExpression() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Integer.class, "col1", "table", false); + ExprNodeConstantDesc constDesc = new ExprNodeConstantDesc(new Integer(10)); + + GenericUDFOPGreaterThan udf = new GenericUDFOPGreaterThan(); + ExprNodeGenericFuncDesc greaterExprDesc = new ExprNodeGenericFuncDesc(); + greaterExprDesc.setGenericUDF(udf); + List children1 = new ArrayList(2); + children1.add(col1Expr); + children1.add(constDesc); + greaterExprDesc.setChildExprs(children1); + + ExprNodeColumnDesc col2Expr = new ExprNodeColumnDesc(Float.class, "col2", "table", false); + ExprNodeConstantDesc const2Desc = new ExprNodeConstantDesc(new Float(1.0)); + + GenericUDFOPLessThan udf2 = new GenericUDFOPLessThan(); + ExprNodeGenericFuncDesc lessExprDesc = new ExprNodeGenericFuncDesc(); + lessExprDesc.setGenericUDF(udf2); + List children2 = new ArrayList(2); + children2.add(col2Expr); + children2.add(const2Desc); + lessExprDesc.setChildExprs(children2); + + GenericUDFOPAnd andUdf = new GenericUDFOPAnd(); + ExprNodeGenericFuncDesc andExprDesc = new ExprNodeGenericFuncDesc(); + andExprDesc.setGenericUDF(andUdf); + List children3 = new ArrayList(2); + children3.add(greaterExprDesc); + children3.add(lessExprDesc); + andExprDesc.setChildExprs(children3); + + Map columnMap = new HashMap(); + columnMap.put("col1", 0); + columnMap.put("col2", 1); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.FILTER); + + VectorExpression ve = vc.getVectorExpression(andExprDesc); + + assertEquals(ve.getClass(), FilterExprAndExpr.class); + assertEquals(ve.getChildExpressions()[0].getClass(), FilterLongColGreaterLongScalar.class); + assertEquals(ve.getChildExpressions()[1].getClass(), FilterDoubleColLessDoubleScalar.class); + + GenericUDFOPOr orUdf = new GenericUDFOPOr(); + ExprNodeGenericFuncDesc orExprDesc = new ExprNodeGenericFuncDesc(); + orExprDesc.setGenericUDF(orUdf); + List children4 = new ArrayList(2); + children4.add(greaterExprDesc); + children4.add(lessExprDesc); + orExprDesc.setChildExprs(children4); + + + VectorExpression veOr = vc.getVectorExpression(orExprDesc); + + assertEquals(veOr.getClass(), FilterExprOrExpr.class); + assertEquals(veOr.getChildExpressions()[0].getClass(), FilterLongColGreaterLongScalar.class); + assertEquals(veOr.getChildExpressions()[1].getClass(), FilterDoubleColLessDoubleScalar.class); + } + + @Test + public void testVectorizeScalarColumnExpression() throws HiveException { + ExprNodeGenericFuncDesc scalarMinusConstant = new ExprNodeGenericFuncDesc(); + GenericUDF gudf = new GenericUDFBridge("-", true, UDFOPMinus.class.getCanonicalName()); + scalarMinusConstant.setGenericUDF(gudf); + List children = new ArrayList(2); + ExprNodeConstantDesc constDesc = new ExprNodeConstantDesc(TypeInfoFactory.longTypeInfo, 20); + ExprNodeColumnDesc colDesc = new ExprNodeColumnDesc(Long.class, "a", "table", false); + + children.add(constDesc); + children.add(colDesc); + + scalarMinusConstant.setChildExprs(children); + + Map columnMap = new HashMap(); + columnMap.put("a", 0); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + VectorExpression ve = vc.getVectorExpression(scalarMinusConstant); + + assertEquals(ve.getClass(), LongScalarSubtractLongColumn.class); + } + + @Test + public void testFilterWithNegativeScalar() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Integer.class, "col1", "table", false); + ExprNodeConstantDesc constDesc = new ExprNodeConstantDesc(new Integer(-10)); + + GenericUDFOPGreaterThan udf = new GenericUDFOPGreaterThan(); + ExprNodeGenericFuncDesc exprDesc = new ExprNodeGenericFuncDesc(); + exprDesc.setGenericUDF(udf); + List children1 = new ArrayList(2); + children1.add(col1Expr); + children1.add(constDesc); + exprDesc.setChildExprs(children1); + + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + columnMap.put("col2", 2); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.FILTER); + + VectorExpression ve = vc.getVectorExpression(exprDesc); + + assertTrue(ve instanceof FilterLongColGreaterLongScalar); + } + + @Test + public void testUnaryMinusColumnLong() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Integer.class, "col1", "table", false); + ExprNodeGenericFuncDesc negExprDesc = new ExprNodeGenericFuncDesc(); + GenericUDF gudf = new GenericUDFBridge("-", true, UDFOPNegative.class.getCanonicalName()); + negExprDesc.setGenericUDF(gudf); + List children = new ArrayList(1); + children.add(col1Expr); + negExprDesc.setChildExprs(children); + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + VectorizationContext vc = new VectorizationContext(columnMap, 1); + vc.setOperatorType(OperatorType.SELECT); + + VectorExpression ve = vc.getVectorExpression(negExprDesc); + + assertTrue( ve instanceof LongColUnaryMinus); + } + + @Test + public void testUnaryMinusColumnDouble() throws HiveException { + ExprNodeColumnDesc col1Expr = new ExprNodeColumnDesc(Float.class, "col1", "table", false); + ExprNodeGenericFuncDesc negExprDesc = new ExprNodeGenericFuncDesc(); + GenericUDF gudf = new GenericUDFBridge("-", true, UDFOPNegative.class.getCanonicalName()); + negExprDesc.setGenericUDF(gudf); + List children = new ArrayList(1); + children.add(col1Expr); + negExprDesc.setChildExprs(children); + Map columnMap = new HashMap(); + columnMap.put("col1", 1); + VectorizationContext vc = new VectorizationContext(columnMap, 1); + vc.setOperatorType(OperatorType.SELECT); + + VectorExpression ve = vc.getVectorExpression(negExprDesc); + + assertTrue( ve instanceof DoubleColUnaryMinus); + } + + @Test + public void testFilterScalarCompareColumn() throws HiveException { + ExprNodeGenericFuncDesc scalarGreaterColExpr = new ExprNodeGenericFuncDesc(); + GenericUDFOPGreaterThan gudf = new GenericUDFOPGreaterThan(); + scalarGreaterColExpr.setGenericUDF(gudf); + List children = new ArrayList(2); + ExprNodeConstantDesc constDesc = + new ExprNodeConstantDesc(TypeInfoFactory.longTypeInfo, 20); + ExprNodeColumnDesc colDesc = + new ExprNodeColumnDesc(Long.class, "a", "table", false); + + children.add(constDesc); + children.add(colDesc); + + scalarGreaterColExpr.setChildExprs(children); + + Map columnMap = new HashMap(); + columnMap.put("a", 0); + + VectorizationContext vc = new VectorizationContext(columnMap, 2); + vc.setOperatorType(OperatorType.FILTER); + VectorExpression ve = vc.getVectorExpression(scalarGreaterColExpr); + assertEquals(FilterLongScalarGreaterLongColumn.class, ve.getClass()); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatch.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatch.java new file mode 100644 index 0000000..a250c9d --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatch.java @@ -0,0 +1,221 @@ +/** + * 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.exec.vector; + +import java.util.Random; + +import junit.framework.Assert; +import org.junit.Test; + +/** + * Test creation and basic manipulation of VectorizedRowBatch. + */ +public class TestVectorizedRowBatch { + + // test fields + static final String[] COLORS = {"red", "yellow", "green", "blue", "violet", "orange"}; + private static byte[][] colorsBytes; + + private VectorizedRowBatch makeBatch() { + VectorizedRowBatch batch = new VectorizedRowBatch(3); + LongColumnVector lv = new LongColumnVector(); + DoubleColumnVector dv = new DoubleColumnVector(); + BytesColumnVector bv = new BytesColumnVector(); + setSampleStringCol(bv); + batch.cols[0] = lv; + batch.cols[1] = dv; + batch.cols[2] = bv; + addRandomNulls(batch); + return batch; + } + + @Test + /** + * Make sure you can create a batch and that all columns are the + * default size. + */ + public void testVectorizedRowBatchCreate() { + VectorizedRowBatch batch = makeBatch(); + Assert.assertEquals(3, batch.numCols); + Assert.assertEquals(VectorizedRowBatch.DEFAULT_SIZE, batch.size); + Assert.assertEquals(((LongColumnVector) batch.cols[0]).vector.length, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertEquals(((DoubleColumnVector) batch.cols[1]).vector.length, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertEquals(((BytesColumnVector) batch.cols[2]).vector.length, + VectorizedRowBatch.DEFAULT_SIZE); + } + + /* + * Test routines to exercise VectorizedRowBatch + * by filling column vectors with data and null values. + */ + + public static void setRandom(VectorizedRowBatch batch) { + batch.size = VectorizedRowBatch.DEFAULT_SIZE; + for (int i = 0; i != batch.numCols; i++) { + batch.cols[i] = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + setRandomLongCol((LongColumnVector) batch.cols[i]); + } + } + + public static void setSample(VectorizedRowBatch batch) { + batch.size = VectorizedRowBatch.DEFAULT_SIZE; + for (int i = 0; i != batch.numCols; i++) { + setSampleLongCol((LongColumnVector) batch.cols[i]); + } + } + + /** + * Set to sample data, re-using existing columns in batch. + * + * @param batch + */ + public static void setSampleOverwrite(VectorizedRowBatch batch) { + + // Put sample data in the columns. + for (int i = 0; i != batch.numCols; i++) { + setSampleLongCol((LongColumnVector) batch.cols[i]); + } + + // Reset the selection vector. + batch.selectedInUse = false; + batch.size = VectorizedRowBatch.DEFAULT_SIZE; + } + + /** + * Sprinkle null values in this column vector. + * + * @param col + */ + public static void addRandomNulls(ColumnVector col) { + col.noNulls = false; + Random rand = new Random(); + for(int i = 0; i != col.isNull.length; i++) { + col.isNull[i] = Math.abs(rand.nextInt() % 11) == 0; + } + } + + /** + * Add null values, but do it faster, by avoiding use of Random(). + * + * @param col + */ + public void addSampleNulls(ColumnVector col) { + col.noNulls = false; + assert col.isNull != null; + for(int i = 0; i != col.isNull.length; i++) { + col.isNull[i] = i % 11 == 0; + } + } + + public static void addRandomNulls(VectorizedRowBatch batch) { + for (int i = 0; i != batch.numCols; i++) { + addRandomNulls(batch.cols[i]); + } + } + + public void addSampleNulls(VectorizedRowBatch batch) { + for (int i = 0; i != batch.numCols; i++) { + addSampleNulls(batch.cols[i]); + } + } + + /** + * Set vector elements to sample string data from colorsBytes string table. + * @param col + */ + public static void setSampleStringCol(BytesColumnVector col) { + initColors(); + int size = col.vector.length; + for(int i = 0; i != size; i++) { + int pos = i % colorsBytes.length; + col.setRef(i, colorsBytes[pos], 0, colorsBytes[pos].length); + } + } + + /* + * Initialize string table in a lazy fashion. + */ + private static void initColors() { + if (colorsBytes == null) { + colorsBytes = new byte[COLORS.length][]; + for (int i = 0; i != COLORS.length; i++) { + colorsBytes[i] = COLORS[i].getBytes(); + } + } + } + + + /** + * Set the vector to sample data that repeats an iteration from 0 to 99. + * @param col + */ + public static void setSampleLongCol(LongColumnVector col) { + int size = col.vector.length; + for(int i = 0; i != size; i++) { + col.vector[i] = i % 100; + } + } + + /** + * Set the vector to random data in the range 0 to 99. + * This has significant overhead for random number generation. Use setSample() to reduce overhead. + */ + public static void setRandomLongCol(LongColumnVector col) { + int size = col.vector.length; + Random rand = new Random(System.currentTimeMillis()); + for(int i = 0; i != size; i++) { + col.vector[i] = Math.abs(rand.nextInt() % 100); + } + } + + public static void setRepeatingLongCol(LongColumnVector col) { + col.isRepeating = true; + col.vector[0] = 50; + } + + /** + * Set the vector to sample data that repeats an iteration from 0 to 99. + * @param col + */ + public static void setSampleDoubleCol(DoubleColumnVector col) { + int size = col.vector.length; + for(int i = 0; i != size; i++) { + col.vector[i] = i % 100; + } + } + + /** + * Set the vector to random data in the range 0 to 99. + * This has significant overhead for random number generation. Use setSample() to reduce overhead. + */ + public static void setRandomDoubleCol(DoubleColumnVector col) { + int size = col.vector.length; + Random rand = new Random(); + for(int i = 0; i != size; i++) { + col.vector[i] = Math.abs(rand.nextInt() % 100); + } + } + + public static void setRepeatingDoubleCol(DoubleColumnVector col) { + col.isRepeating = true; + col.vector[0] = 50.0; + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatchCtx.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatchCtx.java new file mode 100644 index 0000000..efbc758 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/TestVectorizedRowBatchCtx.java @@ -0,0 +1,342 @@ +/** + * 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.exec.vector; + +import java.io.File; +import java.io.IOException; +import java.sql.Timestamp; +import java.util.Calendar; +import java.util.List; +import java.util.Properties; + +import junit.framework.Assert; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.ql.io.RCFile; +import org.apache.hadoop.hive.ql.io.RCFileOutputFormat; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.serde.serdeConstants; +import org.apache.hadoop.hive.serde2.SerDeException; +import org.apache.hadoop.hive.serde2.columnar.BytesRefArrayWritable; +import org.apache.hadoop.hive.serde2.columnar.BytesRefWritable; +import org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe; +import org.apache.hadoop.hive.serde2.io.ByteWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.io.ShortWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category; +import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.StructField; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.FloatWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.ObjectWritable; +import org.apache.hadoop.io.Text; +import org.apache.hadoop.io.Writable; +import org.apache.hadoop.io.compress.DefaultCodec; +import org.junit.Before; +import org.junit.Test; + +/** + * Class that tests the functionality of VectorizedRowBatchCtx. + */ +public class TestVectorizedRowBatchCtx { + + private Configuration conf; + private FileSystem fs; + private Path testFilePath; + private int colCount; + private ColumnarSerDe serDe; + private Properties tbl; + + @Before + public void openFileSystem() throws Exception { + conf = new Configuration(); + fs = FileSystem.getLocal(conf); + Path workDir = new Path(System.getProperty("test.tmp.dir", + "target" + File.separator + "test" + File.separator + "tmp")); + fs.setWorkingDirectory(workDir); + testFilePath = new Path("TestVectorizedRowBatchCtx.testDump.rc"); + fs.delete(testFilePath, false); + } + + private void initSerde() { + tbl = new Properties(); + + // Set the configuration parameters + tbl.setProperty(serdeConstants.SERIALIZATION_FORMAT, "6"); + tbl.setProperty("columns", + "ashort,aint,along,adouble,afloat,astring,abyte,aboolean,atimestamp"); + tbl.setProperty("columns.types", + "smallint:int:bigint:double:float:string:tinyint:boolean:timestamp"); + colCount = 9; + tbl.setProperty(serdeConstants.SERIALIZATION_NULL_FORMAT, "NULL"); + + try { + serDe = new ColumnarSerDe(); + serDe.initialize(conf, tbl); + } catch (SerDeException e) { + new RuntimeException(e); + } + } + + private void WriteRCFile(FileSystem fs, Path file, Configuration conf) + throws IOException, SerDeException { + fs.delete(file, true); + + RCFileOutputFormat.setColumnNumber(conf, colCount); + RCFile.Writer writer = + new RCFile.Writer(fs, conf, file, null, null, + new DefaultCodec()); + + for (int i = 0; i < 10; ++i) { + BytesRefArrayWritable bytes = new BytesRefArrayWritable(colCount); + BytesRefWritable cu; + + if (i % 3 != 0) { + //if (i < 100) { + cu = new BytesRefWritable((i + "").getBytes("UTF-8"), 0, (i + "").getBytes("UTF-8").length); + bytes.set(0, cu); + + cu = new BytesRefWritable((i + 100 + "").getBytes("UTF-8"), 0, + (i + 100 + "").getBytes("UTF-8").length); + bytes.set(1, cu); + + cu = new BytesRefWritable((i + 200 + "").getBytes("UTF-8"), 0, + (i + 200 + "").getBytes("UTF-8").length); + bytes.set(2, cu); + + cu = new BytesRefWritable((i + 1.23 + "").getBytes("UTF-8"), 0, + (i + 1.23 + "").getBytes("UTF-8").length); + bytes.set(3, cu); + + cu = new BytesRefWritable((i + 2.23 + "").getBytes("UTF-8"), 0, + (i + 2.23 + "").getBytes("UTF-8").length); + bytes.set(4, cu); + + cu = new BytesRefWritable(("Test string").getBytes("UTF-8"), 0, + ("Test string").getBytes("UTF-8").length); + bytes.set(5, cu); + + cu = new BytesRefWritable((1 + "").getBytes("UTF-8"), 0, + (1 + "").getBytes("UTF-8").length); + bytes.set(6, cu); + + cu = new BytesRefWritable(("true").getBytes("UTF-8"), 0, + ("true").getBytes("UTF-8").length); + bytes.set(7, cu); + + Timestamp t = new Timestamp(Calendar.getInstance().getTime().getTime()); + cu = new BytesRefWritable(t.toString().getBytes("UTF-8"), 0, + t.toString().getBytes("UTF-8").length); + bytes.set(8, cu); + + } else { + cu = new BytesRefWritable((i + "").getBytes("UTF-8"), 0, (i + "").getBytes("UTF-8").length); + bytes.set(0, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(1, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(2, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(3, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(4, cu); + + cu = new BytesRefWritable(("Test string").getBytes("UTF-8"), 0, + ("Test string").getBytes("UTF-8").length); + bytes.set(5, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(6, cu); + + cu = new BytesRefWritable(new byte[0], 0, 0); + bytes.set(7, cu); + +// cu = new BytesRefWritable(new byte[0], 0, 0); +// bytes.set(8, cu); + Timestamp t = new Timestamp(Calendar.getInstance().getTime().getTime()); + cu = new BytesRefWritable(t.toString().getBytes("UTF-8"), 0, + t.toString().getBytes("UTF-8").length); + bytes.set(8, cu); + } + writer.append(bytes); + } + writer.close(); + } + + private VectorizedRowBatch GetRowBatch() throws SerDeException, HiveException, IOException { + + RCFile.Reader reader = new RCFile.Reader(fs, this.testFilePath, conf); + + // Get object inspector + StructObjectInspector oi = (StructObjectInspector) serDe + .getObjectInspector(); + List fieldRefs = oi.getAllStructFieldRefs(); + + Assert.assertEquals("Field size should be 9", colCount, fieldRefs.size()); + + // Create the context + VectorizedRowBatchCtx ctx = new VectorizedRowBatchCtx(oi, oi, serDe, null); + VectorizedRowBatch batch = ctx.createVectorizedRowBatch(); + VectorizedBatchUtil.SetNoNullFields(true, batch); + + // Iterate thru the rows and populate the batch + LongWritable rowID = new LongWritable(); + for (int i = 0; i < 10; i++) { + reader.next(rowID); + BytesRefArrayWritable cols = new BytesRefArrayWritable(); + reader.getCurrentRow(cols); + cols.resetValid(colCount); + ctx.addRowToBatch(i, cols, batch); + } + reader.close(); + batch.size = 10; + return batch; + } + + void ValidateRowBatch(VectorizedRowBatch batch) throws IOException, SerDeException { + + LongWritable rowID = new LongWritable(); + RCFile.Reader reader = new RCFile.Reader(fs, this.testFilePath, conf); + for (int i = 0; i < batch.size; i++) { + reader.next(rowID); + BytesRefArrayWritable cols = new BytesRefArrayWritable(); + reader.getCurrentRow(cols); + cols.resetValid(colCount); + Object row = serDe.deserialize(cols); + + StructObjectInspector oi = (StructObjectInspector) serDe + .getObjectInspector(); + List fieldRefs = oi.getAllStructFieldRefs(); + + for (int j = 0; j < fieldRefs.size(); j++) { + Object fieldData = oi.getStructFieldData(row, fieldRefs.get(j)); + ObjectInspector foi = fieldRefs.get(j).getFieldObjectInspector(); + + // Vectorization only supports PRIMITIVE data types. Assert the same + Assert.assertEquals(true, foi.getCategory() == Category.PRIMITIVE); + + PrimitiveObjectInspector poi = (PrimitiveObjectInspector) foi; + Object writableCol = poi.getPrimitiveWritableObject(fieldData); + if (writableCol != null) { + switch (poi.getPrimitiveCategory()) { + case BOOLEAN: { + LongColumnVector lcv = (LongColumnVector) batch.cols[j]; + Assert.assertEquals(true, lcv.vector[i] == (((BooleanWritable) writableCol).get() ? 1 + : 0)); + } + break; + case BYTE: { + LongColumnVector lcv = (LongColumnVector) batch.cols[j]; + Assert.assertEquals(true, lcv.vector[i] == (long) ((ByteWritable) writableCol).get()); + } + break; + case SHORT: { + LongColumnVector lcv = (LongColumnVector) batch.cols[j]; + Assert.assertEquals(true, lcv.vector[i] == ((ShortWritable) writableCol).get()); + } + break; + case INT: { + LongColumnVector lcv = (LongColumnVector) batch.cols[j]; + Assert.assertEquals(true, lcv.vector[i] == ((IntWritable) writableCol).get()); + } + break; + case LONG: { + LongColumnVector lcv = (LongColumnVector) batch.cols[j]; + Assert.assertEquals(true, lcv.vector[i] == ((LongWritable) writableCol).get()); + } + break; + case FLOAT: { + DoubleColumnVector dcv = (DoubleColumnVector) batch.cols[j]; + Assert.assertEquals(true, dcv.vector[i] == ((FloatWritable) writableCol).get()); + } + break; + case DOUBLE: { + DoubleColumnVector dcv = (DoubleColumnVector) batch.cols[j]; + Assert.assertEquals(true, dcv.vector[i] == ((DoubleWritable) writableCol).get()); + } + break; + case STRING: { + BytesColumnVector bcv = (BytesColumnVector) batch.cols[j]; + Text colText = (Text) writableCol; + Text batchText = (Text) bcv.getWritableObject(i); + String a = colText.toString(); + String b = batchText.toString(); + Assert.assertEquals(true, a.equals(b)); + } + break; + case TIMESTAMP: { + LongColumnVector tcv = (LongColumnVector) batch.cols[j]; + Timestamp t = ((TimestampWritable) writableCol).getTimestamp(); + long timeInNanoSec = (t.getTime() * 1000000) + (t.getNanos() % 1000000); + Assert.assertEquals(true, tcv.vector[i] == timeInNanoSec); + } + break; + default: + Assert.assertEquals("Unknown type", false); + } + } else { + Assert.assertEquals(true, batch.cols[j].isNull[i]); + } + } + + // Check repeating + Assert.assertEquals(false, batch.cols[0].isRepeating); + Assert.assertEquals(false, batch.cols[1].isRepeating); + Assert.assertEquals(false, batch.cols[2].isRepeating); + Assert.assertEquals(false, batch.cols[3].isRepeating); + Assert.assertEquals(false, batch.cols[4].isRepeating); + + // Check non null + Assert.assertEquals(true, batch.cols[0].noNulls); + Assert.assertEquals(false, batch.cols[1].noNulls); + Assert.assertEquals(false, batch.cols[2].noNulls); + Assert.assertEquals(false, batch.cols[3].noNulls); + Assert.assertEquals(false, batch.cols[4].noNulls); + } + reader.close(); + } + + @Test + public void TestCtx() throws Exception { + initSerde(); + WriteRCFile(this.fs, this.testFilePath, this.conf); + VectorizedRowBatch batch = GetRowBatch(); + ValidateRowBatch(batch); + + // Test VectorizedColumnarSerDe + VectorizedColumnarSerDe vcs = new VectorizedColumnarSerDe(); + vcs.initialize(this.conf, tbl); + Writable w = vcs.serializeVector(batch, (StructObjectInspector) serDe + .getObjectInspector()); + BytesRefArrayWritable[] refArray = (BytesRefArrayWritable[]) ((ObjectWritable) w).get(); + vcs.deserializeVector(refArray, 10, batch); + ValidateRowBatch(batch); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestConstantVectorExpression.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestConstantVectorExpression.java new file mode 100644 index 0000000..4321545 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestConstantVectorExpression.java @@ -0,0 +1,65 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + +/** + * Test vector expressions with constants. + */ +public class TestConstantVectorExpression { + + @Test + public void testConstantExpression() { + ConstantVectorExpression longCve = new ConstantVectorExpression(0, 17); + ConstantVectorExpression doubleCve = new ConstantVectorExpression(1, 17.34); + ConstantVectorExpression bytesCve = new ConstantVectorExpression(2, "alpha".getBytes()); + + int size = 20; + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch(size, 3, 0); + + LongColumnVector lcv = (LongColumnVector) vrg.cols[0]; + DoubleColumnVector dcv = new DoubleColumnVector(size); + BytesColumnVector bcv = new BytesColumnVector(size); + vrg.cols[1] = dcv; + vrg.cols[2] = bcv; + + longCve.evaluate(vrg); + doubleCve.evaluate(vrg); + bytesCve.evaluate(vrg); + + assertTrue(lcv.isRepeating); + assertTrue(dcv.isRepeating); + assertTrue(bcv.isRepeating); + assertEquals(17, lcv.vector[0]); + assertTrue(17.34 == dcv.vector[0]); + assertTrue(Arrays.equals("alpha".getBytes(), bcv.vector[0])); + } + +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestUnaryMinus.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestUnaryMinus.java new file mode 100644 index 0000000..289a508 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestUnaryMinus.java @@ -0,0 +1,46 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertEquals; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColUnaryMinus; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + +/** + * Unit tests for unary minus. + */ +public class TestUnaryMinus { + + @Test + public void testUnaryMinus() { + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch(1024, 2, 23); + LongColUnaryMinus expr = new LongColUnaryMinus(0, 1); + expr.evaluate(vrg); + //verify + long[] inVector = ((LongColumnVector) vrg.cols[0]).vector; + long[] outVector = ((LongColumnVector) vrg.cols[1]).vector; + for (int i = 0; i < outVector.length; i++) { + assertEquals(0, inVector[i]+outVector[i]); + } + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java new file mode 100644 index 0000000..9de8461 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java @@ -0,0 +1,286 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import junit.framework.Assert; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TestVectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongScalar; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + +/** + * Unit tests for vectori arithmetic expressions. + */ +public class TestVectorArithmeticExpressions { + + @Test + public void testLongColAddLongScalarNoNulls() { + VectorizedRowBatch vrg = getVectorizedRowBatchSingleLongVector(VectorizedRowBatch.DEFAULT_SIZE); + LongColAddLongScalar expr = new LongColAddLongScalar(0, 23, 1); + expr.evaluate(vrg); + //verify + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + Assert.assertEquals(i * 37 + 23, ((LongColumnVector) vrg.cols[1]).vector[i]); + } + Assert.assertTrue(((LongColumnVector)vrg.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector)vrg.cols[1]).isRepeating); + } + + private VectorizedRowBatch getVectorizedRowBatchSingleLongVector(int size) { + VectorizedRowBatch vrg = new VectorizedRowBatch(2, size); + LongColumnVector lcv = new LongColumnVector(size); + for (int i=0; i < size; i++) { + lcv.vector[i] = i*37; + } + vrg.cols[0] = lcv; + vrg.cols[1] = new LongColumnVector(size); + vrg.size = size; + return vrg; + } + + public static VectorizedRowBatch getVectorizedRowBatch2LongInDoubleOut() { + VectorizedRowBatch batch = new VectorizedRowBatch(3); + LongColumnVector lcv, lcv2; + lcv = new LongColumnVector(); + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + lcv.vector[i] = i * 37; + } + batch.cols[0] = lcv; + lcv2 = new LongColumnVector(); + batch.cols[1] = lcv2; + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + lcv2.vector[i] = i * 37; + } + batch.cols[2] = new DoubleColumnVector(); + batch.size = VectorizedRowBatch.DEFAULT_SIZE; + return batch; + } + + @Test + public void testLongColAddLongScalarWithNulls() { + VectorizedRowBatch batch = getVectorizedRowBatchSingleLongVector( + VectorizedRowBatch.DEFAULT_SIZE); + LongColumnVector lcv = (LongColumnVector) batch.cols[0]; + LongColumnVector lcvOut = (LongColumnVector) batch.cols[1]; + TestVectorizedRowBatch.addRandomNulls(lcv); + LongColAddLongScalar expr = new LongColAddLongScalar(0, 23, 1); + expr.evaluate(batch); + + // verify + for (int i=0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + if (!lcv.isNull[i]) { + Assert.assertEquals(i*37+23, lcvOut.vector[i]); + } else { + Assert.assertTrue(lcvOut.isNull[i]); + } + } + Assert.assertFalse(lcvOut.noNulls); + Assert.assertFalse(lcvOut.isRepeating); + verifyLongNullDataVectorEntries(lcvOut, batch.selected, batch.selectedInUse, batch.size); + } + + @Test + public void testLongColAddLongScalarWithRepeating() { + LongColumnVector in, out; + VectorizedRowBatch batch; + LongColAddLongScalar expr; + + // Case 1: is repeating, no nulls + batch = getVectorizedRowBatchSingleLongVector(VectorizedRowBatch.DEFAULT_SIZE); + in = (LongColumnVector) batch.cols[0]; + in.isRepeating = true; + out = (LongColumnVector) batch.cols[1]; + out.isRepeating = false; + expr = new LongColAddLongScalar(0, 23, 1); + expr.evaluate(batch); + // verify + Assert.assertTrue(out.isRepeating); + Assert.assertTrue(out.noNulls); + Assert.assertEquals(out.vector[0], 0 * 37 + 23); + + // Case 2: is repeating, has nulls + batch = getVectorizedRowBatchSingleLongVector(VectorizedRowBatch.DEFAULT_SIZE); + in = (LongColumnVector) batch.cols[0]; + in.isRepeating = true; + in.noNulls = false; + in.isNull[0] = true; + + out = (LongColumnVector) batch.cols[1]; + out.isRepeating = false; + out.isNull[0] = false; + out.noNulls = true; + expr = new LongColAddLongScalar(0, 23, 1); + expr.evaluate(batch); + // verify + Assert.assertTrue(out.isRepeating); + Assert.assertFalse(out.noNulls); + Assert.assertEquals(true, out.isNull[0]); + verifyLongNullDataVectorEntries(out, batch.selected, batch.selectedInUse, batch.size); + } + + /* Make sure all the NULL entries in this long column output vector have their data vector + * element set to the correct value, as per the specification, to prevent later arithmetic + * errors (e.g. zero-divide). + */ + public static void verifyLongNullDataVectorEntries( + LongColumnVector v, int[] sel, boolean selectedInUse, int n) { + if (n == 0 || v.noNulls) { + return; + } else if (v.isRepeating) { + if (v.isNull[0]) { + assertEquals(LongColumnVector.NULL_VALUE, v.vector[0]); + } + } else if (selectedInUse) { + for (int j = 0; j != n; j++) { + int i = sel[j]; + if (v.isNull[i]) { + assertEquals(LongColumnVector.NULL_VALUE, v.vector[i]); + } + } + } else { + for (int i = 0; i != n; i++) { + if (v.isNull[i]) { + assertEquals(LongColumnVector.NULL_VALUE, v.vector[i]); + } + } + } + } + + @Test + public void testLongColAddLongColumn() { + int seed = 17; + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + VectorizedRowBatch.DEFAULT_SIZE, + 6, seed); + LongColumnVector lcv0 = (LongColumnVector) vrg.cols[0]; + LongColumnVector lcv1 = (LongColumnVector) vrg.cols[1]; + LongColumnVector lcv2 = (LongColumnVector) vrg.cols[2]; + LongColumnVector lcv3 = (LongColumnVector) vrg.cols[3]; + LongColumnVector lcv4 = (LongColumnVector) vrg.cols[4]; + LongColumnVector lcv5 = (LongColumnVector) vrg.cols[5]; + LongColAddLongColumn expr = new LongColAddLongColumn(0, 1, 2); + expr.evaluate(vrg); + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + assertEquals((i+1) * seed * 3, lcv2.vector[i]); + } + assertTrue(lcv2.noNulls); + + // Now set one column nullable + lcv1.noNulls = false; + lcv1.isNull[1] = true; + lcv2.isRepeating = true; // set output isRepeating to true to make sure it gets over-written + lcv2.noNulls = true; // similarly with noNulls + expr.evaluate(vrg); + assertTrue(lcv2.isNull[1]); + assertFalse(lcv2.noNulls); + assertFalse(lcv2.isRepeating); + verifyLongNullDataVectorEntries(lcv2, vrg.selected, vrg.selectedInUse, vrg.size); + + // Now set other column nullable too + lcv0.noNulls = false; + lcv0.isNull[1] = true; + lcv0.isNull[3] = true; + expr.evaluate(vrg); + assertTrue(lcv2.isNull[1]); + assertTrue(lcv2.isNull[3]); + assertFalse(lcv2.noNulls); + verifyLongNullDataVectorEntries(lcv2, vrg.selected, vrg.selectedInUse, vrg.size); + + // Now test with repeating flag + lcv3.isRepeating = true; + LongColAddLongColumn expr2 = new LongColAddLongColumn(3, 4, 5); + expr2.evaluate(vrg); + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + assertEquals(seed * (4 + 5*(i+1)), lcv5.vector[i]); + } + + // Repeating with other as nullable + lcv4.noNulls = false; + lcv4.isNull[0] = true; + expr2.evaluate(vrg); + assertTrue(lcv5.isNull[0]); + assertFalse(lcv5.noNulls); + verifyLongNullDataVectorEntries(lcv5, vrg.selected, vrg.selectedInUse, vrg.size); + + // Repeating null value + lcv3.isRepeating = true; + lcv3.noNulls = false; + lcv3.isNull[0] = true; + expr2.evaluate(vrg); + assertFalse(lcv5.noNulls); + assertTrue(lcv5.isRepeating); + assertTrue(lcv5.isNull[0]); + verifyLongNullDataVectorEntries(lcv5, vrg.selected, vrg.selectedInUse, vrg.size); + + // Neither input has nulls. Verify that this propagates to output. + vrg.selectedInUse = false; + lcv0.noNulls = true; + lcv1.noNulls = true; + lcv0.isRepeating = false; + lcv1.isRepeating = false; + lcv2.noNulls = false; // set output noNulls to true to make sure it gets over-written + lcv2.isRepeating = true; // similarly with isRepeating + expr.evaluate(vrg); + assertTrue(lcv2.noNulls); + assertFalse(lcv2.isRepeating); + } + + @Test + public void testLongColDivideLongColumn() { + + /* Testing for equality of doubles after a math operation is + * not always reliable so use this as a tolerance. + */ + final double eps = 1e-7d; + VectorizedRowBatch batch = getVectorizedRowBatch2LongInDoubleOut(); + LongColDivideLongColumn expr = new LongColDivideLongColumn(0, 1, 2); + batch.cols[0].isNull[1] = true; + batch.cols[0].noNulls = false; + batch.cols[1].noNulls = false; + DoubleColumnVector out = (DoubleColumnVector) batch.cols[2]; + + // Set so we can verify they are reset by operation + out.noNulls = true; + out.isRepeating = true; + + expr.evaluate(batch); + + // 0/0 for entry 0 should work but generate NaN + assertTrue(Double.isNaN(out.vector[0])); + + // verify NULL output in entry 1 is correct + assertTrue(out.isNull[1]); + assertTrue(Double.isNaN(out.vector[1])); + + // check entries beyond first 2 + for (int i = 2; i != batch.size; i++) { + assertTrue(out.vector[i] > 1.0d - eps && out.vector[i] < 1.0d + eps); + } + assertFalse(out.noNulls); + assertFalse(out.isRepeating); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorExpressionWriters.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorExpressionWriters.java new file mode 100644 index 0000000..1899c3b --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorExpressionWriters.java @@ -0,0 +1,208 @@ +/** + * 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.exec.vector.expressions; + + +import java.sql.Timestamp; +import java.util.Random; + +import junit.framework.Assert; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TimestampUtils; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.serde2.io.ByteWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.io.ShortWritable; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.FloatWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.io.Text; +import org.apache.hadoop.io.Writable; +import org.junit.Test; + +/** + * Unit tests for vector expression writers. + */ +public class TestVectorExpressionWriters { + + private final int vectorSize = 5; + + private VectorExpressionWriter getWriter(TypeInfo colTypeInfo) throws HiveException { + ExprNodeDesc columnDesc = new ExprNodeColumnDesc(); + columnDesc.setTypeInfo(colTypeInfo); + VectorExpressionWriter vew = VectorExpressionWriterFactory + .genVectorExpressionWritable(columnDesc); + return vew; + } + + private Writable getWritableValue(TypeInfo ti, double value) { + if (ti.equals(TypeInfoFactory.floatTypeInfo)) { + return new FloatWritable((float) value); + } else if (ti.equals(TypeInfoFactory.doubleTypeInfo)) { + return new DoubleWritable(value); + } + return null; + } + + private Writable getWritableValue(TypeInfo ti, byte[] value) { + if (ti.equals(TypeInfoFactory.stringTypeInfo)) { + return new Text(value); + } + return null; + } + + private Writable getWritableValue(TypeInfo ti, long value) { + if (ti.equals(TypeInfoFactory.byteTypeInfo)) { + return new ByteWritable((byte) value); + } else if (ti.equals(TypeInfoFactory.shortTypeInfo)) { + return new ShortWritable((short) value); + } else if (ti.equals(TypeInfoFactory.intTypeInfo)) { + return new IntWritable( (int) value); + } else if (ti.equals(TypeInfoFactory.longTypeInfo)) { + return new LongWritable( (long) value); + } else if (ti.equals(TypeInfoFactory.booleanTypeInfo)) { + return new BooleanWritable( value == 0 ? false : true); + } else if (ti.equals(TypeInfoFactory.timestampTypeInfo)) { + Timestamp ts = new Timestamp(value); + TimestampUtils.assignTimeInNanoSec(value, ts); + TimestampWritable tw = new TimestampWritable(ts); + return tw; + } + return null; + } + + private void testWriterDouble(TypeInfo type) throws HiveException { + DoubleColumnVector dcv = VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, false, + this.vectorSize, new Random(10)); + dcv.isNull[2] = true; + VectorExpressionWriter vew = getWriter(type); + for (int i = 0; i < vectorSize; i++) { + Writable w = (Writable) vew.writeValue(dcv, i); + if (w != null) { + Writable expected = getWritableValue(type, dcv.vector[i]); + Assert.assertEquals(expected, w); + } else { + Assert.assertTrue(dcv.isNull[i]); + } + } + } + + private void testWriterLong(TypeInfo type) throws HiveException { + LongColumnVector lcv = VectorizedRowGroupGenUtil.generateLongColumnVector(true, false, + vectorSize, new Random(10)); + lcv.isNull[3] = true; + VectorExpressionWriter vew = getWriter(type); + for (int i = 0; i < vectorSize; i++) { + Writable w = (Writable) vew.writeValue(lcv, i); + if (w != null) { + Writable expected = getWritableValue(type, lcv.vector[i]); + if (expected instanceof TimestampWritable) { + TimestampWritable t1 = (TimestampWritable) expected; + TimestampWritable t2 = (TimestampWritable) w; + Assert.assertTrue(t1.getNanos() == t2.getNanos()); + Assert.assertTrue(t1.getSeconds() == t2.getSeconds()); + continue; + } + Assert.assertEquals(expected, w); + } else { + Assert.assertTrue(lcv.isNull[i]); + } + } + } + + private void testWriterBytes(TypeInfo type) throws HiveException { + Text t1 = new Text("alpha"); + Text t2 = new Text("beta"); + BytesColumnVector bcv = new BytesColumnVector(vectorSize); + bcv.noNulls = false; + bcv.initBuffer(); + bcv.setVal(0, t1.getBytes(), 0, t1.getLength()); + bcv.isNull[1] = true; + bcv.setVal(2, t2.getBytes(), 0, t2.getLength()); + bcv.isNull[3] = true; + bcv.setVal(4, t1.getBytes(), 0, t1.getLength()); + VectorExpressionWriter vew = getWriter(type); + for (int i = 0; i < vectorSize; i++) { + Writable w = (Writable) vew.writeValue(bcv, i); + if (w != null) { + byte [] val = new byte[bcv.length[i]]; + System.arraycopy(bcv.vector[i], bcv.start[i], val, 0, bcv.length[i]); + Writable expected = getWritableValue(type, val); + Assert.assertEquals(expected, w); + } else { + Assert.assertTrue(bcv.isNull[i]); + } + } + } + + @Test + public void testVectorExpressionWriterDouble() throws HiveException { + testWriterDouble(TypeInfoFactory.doubleTypeInfo); + } + + @Test + public void testVectorExpressionWriterFloat() throws HiveException { + testWriterDouble(TypeInfoFactory.floatTypeInfo); + } + + @Test + public void testVectorExpressionWriterLong() throws HiveException { + testWriterLong(TypeInfoFactory.longTypeInfo); + } + + @Test + public void testVectorExpressionWriterInt() throws HiveException { + testWriterLong(TypeInfoFactory.intTypeInfo); + } + + @Test + public void testVectorExpressionWriterShort() throws HiveException { + testWriterLong(TypeInfoFactory.shortTypeInfo); + } + + @Test + public void testVectorExpressionWriterBoolean() throws HiveException { + testWriterLong(TypeInfoFactory.booleanTypeInfo); + } + + @Test + public void testVectorExpressionWriterTimestamp() throws HiveException { + testWriterLong(TypeInfoFactory.timestampTypeInfo); + } + + @Test + public void testVectorExpressionWriterBye() throws HiveException { + testWriterLong(TypeInfoFactory.byteTypeInfo); + } + + @Test + public void testVectorExpressionWriterBytes() throws HiveException { + testWriterBytes(TypeInfoFactory.stringTypeInfo); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorFilterExpressions.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorFilterExpressions.java new file mode 100644 index 0000000..8321772 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorFilterExpressions.java @@ -0,0 +1,281 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColEqualLongScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColGreaterLongScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongColLessLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongScalarGreaterLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterLongScalarLessLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongColAddLongScalar; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Assert; +import org.junit.Test; + +/** + * Unit tests for filter expressions. + */ +public class TestVectorFilterExpressions { + + @Test + public void testFilterLongColEqualLongScalar() { + VectorizedRowBatch vrg = + VectorizedRowGroupGenUtil.getVectorizedRowBatch(1024, 1, 23); + FilterLongColEqualLongScalar expr = new FilterLongColEqualLongScalar(0, 46); + expr.evaluate(vrg); + assertEquals(1, vrg.size); + assertEquals(1, vrg.selected[0]); + } + + @Test + public void testFilterLongColEqualLongColumn() { + int seed = 17; + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + VectorizedRowBatch.DEFAULT_SIZE, + 2, seed); + LongColumnVector lcv0 = (LongColumnVector) vrg.cols[0]; + LongColumnVector lcv1 = (LongColumnVector) vrg.cols[1]; + FilterLongColGreaterLongColumn expr = new FilterLongColGreaterLongColumn(0, 1); + + //Basic case + lcv0.vector[1] = 23; + lcv1.vector[1] = 19; + lcv0.vector[5] = 23; + lcv1.vector[5] = 19; + expr.evaluate(vrg); + assertEquals(2, vrg.size); + assertEquals(1, vrg.selected[0]); + assertEquals(5, vrg.selected[1]); + + //handle null + lcv0.noNulls = false; + lcv0.isNull[1] = true; + expr.evaluate(vrg); + assertEquals(1, vrg.size); + assertEquals(5, vrg.selected[0]); + } + + @Test + public void testColOpScalarNumericFilterNullAndRepeatingLogic() { + // No nulls, not repeating + FilterLongColGreaterLongScalar f = new FilterLongColGreaterLongScalar(0, 1); + VectorizedRowBatch batch = this.getSimpleLongBatch(); + + batch.cols[0].noNulls = true; + batch.cols[0].isRepeating = false; + f.evaluate(batch); + // only last 2 rows qualify + Assert.assertEquals(2, batch.size); + // show that their positions are recorded + Assert.assertTrue(batch.selectedInUse); + Assert.assertEquals(2, batch.selected[0]); + Assert.assertEquals(3, batch.selected[1]); + + // make everything qualify and ensure selected is not in use + f = new FilterLongColGreaterLongScalar(0, -1); // col > -1 + batch = getSimpleLongBatch(); + f.evaluate(batch); + Assert.assertFalse(batch.selectedInUse); + Assert.assertEquals(4, batch.size); + + // has nulls, not repeating + batch = getSimpleLongBatch(); + f = new FilterLongColGreaterLongScalar(0, 1); // col > 1 + batch.cols[0].noNulls = false; + batch.cols[0].isRepeating = false; + batch.cols[0].isNull[3] = true; + f.evaluate(batch); + Assert.assertTrue(batch.selectedInUse); + Assert.assertEquals(1, batch.size); + Assert.assertEquals(2, batch.selected[0]); + + // no nulls, is repeating + batch = getSimpleLongBatch(); + f = new FilterLongColGreaterLongScalar(0, -1); // col > -1 + batch.cols[0].noNulls = true; + batch.cols[0].isRepeating = true; + f.evaluate(batch); + Assert.assertFalse(batch.selectedInUse); + Assert.assertEquals(4, batch.size); // everything qualifies (4 rows, all with value -1) + + // has nulls, is repeating + batch = getSimpleLongBatch(); + batch.cols[0].noNulls = false; + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + f.evaluate(batch); + Assert.assertEquals(0, batch.size); // all values are null so none qualify + } + + private VectorizedRowBatch getSimpleLongBatch() { + VectorizedRowBatch batch = VectorizedRowGroupGenUtil + .getVectorizedRowBatch(4, 1, 1); + LongColumnVector lcv0 = (LongColumnVector) batch.cols[0]; + + lcv0.vector[0] = 0; + lcv0.vector[1] = 1; + lcv0.vector[2] = 2; + lcv0.vector[3] = 3; + return batch; + } + + @Test + public void testFilterLongColLessLongColumn() { + int seed = 17; + VectorizedRowBatch vrg = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + 5, 3, seed); + LongColumnVector lcv0 = (LongColumnVector) vrg.cols[0]; + LongColumnVector lcv1 = (LongColumnVector) vrg.cols[1]; + LongColumnVector lcv2 = (LongColumnVector) vrg.cols[2]; + FilterLongColLessLongColumn expr = new FilterLongColLessLongColumn(2, 1); + + LongColAddLongScalar childExpr = new LongColAddLongScalar(0, 10, 2); + + expr.setChildExpressions(new VectorExpression[] {childExpr}); + + //Basic case + lcv0.vector[0] = 10; + lcv0.vector[1] = 20; + lcv0.vector[2] = 9; + lcv0.vector[3] = 20; + lcv0.vector[4] = 10; + + lcv1.vector[0] = 20; + lcv1.vector[1] = 10; + lcv1.vector[2] = 20; + lcv1.vector[3] = 10; + lcv1.vector[4] = 20; + + expr.evaluate(vrg); + + assertEquals(1, vrg.size); + assertEquals(2, vrg.selected[0]); + } + + @Test + public void testFilterLongScalarLessLongColumn() { + int seed = 17; + VectorizedRowBatch vrb = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + 5, 2, seed); + LongColumnVector lcv0 = (LongColumnVector) vrb.cols[0]; + FilterLongScalarLessLongColumn expr1 = new FilterLongScalarLessLongColumn(0, 15); + + //Basic case + lcv0.vector[0] = 5; + lcv0.vector[1] = 20; + lcv0.vector[2] = 17; + lcv0.vector[3] = 15; + lcv0.vector[4] = 10; + + expr1.evaluate(vrb); + + assertEquals(2, vrb.size); + assertTrue(vrb.selectedInUse); + assertEquals(1, vrb.selected[0]); + assertEquals(2, vrb.selected[1]); + + FilterLongScalarGreaterLongColumn expr2 = new FilterLongScalarGreaterLongColumn(0, 18); + expr2.evaluate(vrb); + assertEquals(1, vrb.size); + assertTrue(vrb.selectedInUse); + assertEquals(2, vrb.selected[0]); + + //With nulls + VectorizedRowBatch vrb1 = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + 5, 2, seed); + + lcv0 = (LongColumnVector) vrb1.cols[0]; + + lcv0.vector[0] = 5; + lcv0.vector[1] = 20; + lcv0.vector[2] = 17; + lcv0.vector[3] = 15; + lcv0.vector[4] = 10; + + lcv0.noNulls = false; + lcv0.isNull[0] = true; + lcv0.isNull[2] = true; + + expr1.evaluate(vrb1); + assertEquals(1, vrb1.size); + assertTrue(vrb1.selectedInUse); + assertEquals(1, vrb1.selected[0]); + + //With nulls and selected + VectorizedRowBatch vrb2 = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + 7, 2, seed); + vrb2.selectedInUse = true; + vrb2.selected[0] = 1; + vrb2.selected[1] = 2; + vrb2.selected[2] = 4; + vrb2.size = 3; + + lcv0 = (LongColumnVector) vrb2.cols[0]; + + lcv0.vector[0] = 5; + lcv0.vector[1] = 20; + lcv0.vector[2] = 17; + lcv0.vector[3] = 15; + lcv0.vector[4] = 10; + lcv0.vector[5] = 19; + lcv0.vector[6] = 21; + + lcv0.noNulls = false; + lcv0.isNull[0] = true; + lcv0.isNull[2] = true; + lcv0.isNull[5] = true; + + expr1.evaluate(vrb2); + assertEquals(1, vrb2.size); + assertTrue(vrb2.selectedInUse); + assertEquals(1, vrb2.selected[0]); + + //Repeating non null + VectorizedRowBatch vrb3 = VectorizedRowGroupGenUtil.getVectorizedRowBatch( + 7, 2, seed); + lcv0 = (LongColumnVector) vrb3.cols[0]; + + lcv0.isRepeating = true; + lcv0.vector[0] = 17; + lcv0.vector[1] = 20; + lcv0.vector[2] = 17; + lcv0.vector[3] = 15; + lcv0.vector[4] = 10; + + expr1.evaluate(vrb3); + assertEquals(7, vrb3.size); + assertFalse(vrb3.selectedInUse); + assertTrue(lcv0.isRepeating); + + //Repeating null + lcv0.noNulls = false; + lcv0.vector[0] = 17; + lcv0.isNull[0] = true; + + expr1.evaluate(vrb3); + assertEquals(0, vrb3.size); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorLogicalExpressions.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorLogicalExpressions.java new file mode 100644 index 0000000..144cac5 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorLogicalExpressions.java @@ -0,0 +1,480 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertEquals; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.junit.Assert; +import org.junit.Test; + +/** +* Unit tests for logical expressions AND, OR, NOT, IsNull etc. +*/ +public class TestVectorLogicalExpressions { + + private static final int BOOLEAN_COLUMN_TEST_SIZE = 9; + + @Test + public void testLongColOrLongCol() { + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + ColOrCol expr = new ColOrCol(0, 1, 2); + LongColumnVector outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + // verify + Assert.assertEquals(0, outCol.vector[0]); + Assert.assertEquals(1, outCol.vector[1]); + Assert.assertEquals(1, outCol.vector[2]); + Assert.assertEquals(1, outCol.vector[3]); + Assert.assertFalse(outCol.isNull[3]); + Assert.assertTrue(outCol.isNull[4]); + Assert.assertEquals(1, outCol.vector[5]); + Assert.assertTrue(outCol.isNull[6]); + Assert.assertEquals(1, outCol.vector[7]); + Assert.assertTrue(outCol.isNull[8]); + + Assert.assertEquals(batch.size, 9); + Assert.assertFalse(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // try non-null path + batch = getBatchThreeBooleanCols(); + batch.cols[0].noNulls = true; + batch.cols[1].noNulls = true; + batch.cols[2].noNulls = false; + outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + + // spot check + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(0, outCol.vector[0]); + Assert.assertEquals(1, outCol.vector[1]); + Assert.assertEquals(1, outCol.vector[2]); + Assert.assertEquals(1, outCol.vector[3]); + + // try isRepeating path (left input only), no nulls + batch = getBatchThreeBooleanCols(); + batch.cols[0].noNulls = true; + batch.cols[0].isRepeating = true; + batch.cols[1].noNulls = true; + batch.cols[1].isRepeating = false; + batch.cols[2].noNulls = false; + batch.cols[2].isRepeating = true; + outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + + // spot check + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(0, outCol.vector[0]); + Assert.assertEquals(1, outCol.vector[1]); + Assert.assertEquals(0, outCol.vector[2]); + Assert.assertEquals(1, outCol.vector[3]); + } + + /** + * Get a batch with three boolean (long) columns. + */ + private VectorizedRowBatch getBatchThreeBooleanCols() { + VectorizedRowBatch batch = new VectorizedRowBatch(3, VectorizedRowBatch.DEFAULT_SIZE); + LongColumnVector v0, v1, v2; + v0 = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + v1 = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + v2 = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + batch.cols[0] = v0; + batch.cols[1] = v1; + batch.cols[2] = v2; + + // add some data and nulls + int i; + i = 0; v0.vector[i] = 0; v0.isNull[i] = false; v1.vector[i] = 0; v1.isNull[i] = false; // 0 0 + i = 1; v0.vector[i] = 0; v0.isNull[i] = false; v1.vector[i] = 1; v1.isNull[i] = false; // 0 1 + i = 2; v0.vector[i] = 1; v0.isNull[i] = false; v1.vector[i] = 0; v1.isNull[i] = false; // 1 0 + i = 3; v0.vector[i] = 1; v0.isNull[i] = false; v1.vector[i] = 1; v1.isNull[i] = false; // 1 1 + i = 4; v0.vector[i] = 0; v0.isNull[i] = true; v1.vector[i] = 0; v1.isNull[i] = false; // NULL 0 + i = 5; v0.vector[i] = 0; v0.isNull[i] = true; v1.vector[i] = 1; v1.isNull[i] = false; // NULL 1 + i = 6; v0.vector[i] = 0; v0.isNull[i] = false; v1.vector[i] = 0; v1.isNull[i] = true; // 0 NULL + i = 7; v0.vector[i] = 1; v0.isNull[i] = false; v1.vector[i] = 1; v1.isNull[i] = true; // 1 NULL + i = 8; v0.vector[i] = 1; v0.isNull[i] = true; v1.vector[i] = 1; v1.isNull[i] = true; // NULL NULL + + v0.noNulls = false; + v1.noNulls = false; + v0.isRepeating = false; + v1.isRepeating = false; + + v2.isRepeating = true; // this value should get over-written with correct value + v2.noNulls = true; // ditto + + batch.size = BOOLEAN_COLUMN_TEST_SIZE; + return batch; + } + + @Test + public void testBooleanNot() { + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + NotCol expr = new NotCol(0, 2); + LongColumnVector outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + + // Case with nulls + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(1, outCol.vector[0]); + Assert.assertFalse(outCol.isNull[0]); + Assert.assertEquals(0, outCol.vector[2]); + Assert.assertFalse(outCol.isNull[0]); + Assert.assertTrue(outCol.isNull[4]); + + // No nulls case + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertFalse(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(1, outCol.vector[0]); + Assert.assertEquals(0, outCol.vector[2]); + + // isRepeating, and there are nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.isNull[0]); + + // isRepeating, and no nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(1, outCol.vector[0]); + } + + @Test + public void testIsNullExpr() { + // has nulls, not repeating + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + IsNull expr = new IsNull(0, 2); + LongColumnVector outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + Assert.assertEquals(0, outCol.vector[0]); + Assert.assertEquals(1, outCol.vector[4]); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // No nulls case, not repeating + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(0, outCol.vector[0]); + + // isRepeating, and there are nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertEquals(1, outCol.vector[0]); + Assert.assertTrue(outCol.noNulls); + + // isRepeating, and no nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(0, outCol.vector[0]); + } + + @Test + public void testIsNotNullExpr() { + // has nulls, not repeating + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + IsNotNull expr = new IsNotNull(0, 2); + LongColumnVector outCol = (LongColumnVector) batch.cols[2]; + expr.evaluate(batch); + Assert.assertEquals(1, outCol.vector[0]); + Assert.assertEquals(0, outCol.vector[4]); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // No nulls case, not repeating + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(1, outCol.vector[0]); + + // isRepeating, and there are nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertEquals(0, outCol.vector[0]); + Assert.assertTrue(outCol.noNulls); + + // isRepeating, and no nulls + batch = getBatchThreeBooleanCols(); + outCol = (LongColumnVector) batch.cols[2]; + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(1, outCol.vector[0]); + } + + @Test + public void testBooleanFiltersOnColumns() { + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr = new SelectColumnIsTrue(0); + expr.evaluate(batch); + assertEquals(3, batch.size); + assertEquals(2, batch.selected[0]); + assertEquals(3, batch.selected[1]); + assertEquals(7, batch.selected[2]); + + batch = getBatchThreeBooleanCols(); + SelectColumnIsFalse expr1 = new SelectColumnIsFalse(1); + expr1.evaluate(batch); + assertEquals(3, batch.size); + assertEquals(0, batch.selected[0]); + assertEquals(2, batch.selected[1]); + assertEquals(4, batch.selected[2]); + } + + @Test + public void testSelectColumnIsNull() { + // has nulls, not repeating + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + SelectColumnIsNull expr = new SelectColumnIsNull(0); + expr.evaluate(batch); + assertEquals(3, batch.size); + assertEquals(4, batch.selected[0]); + assertEquals(5, batch.selected[1]); + assertEquals(8, batch.selected[2]); + + // No nulls case, not repeating + batch = getBatchThreeBooleanCols(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + + // isRepeating, and there are nulls + batch = getBatchThreeBooleanCols(); + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + int initialSize = batch.size; + expr.evaluate(batch); + Assert.assertEquals(initialSize, batch.size); + + // isRepeating, and no nulls + batch = getBatchThreeBooleanCols(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + } + + @Test + public void testSelectColumnIsNotNull() { + // has nulls, not repeating + VectorizedRowBatch batch = getBatchThreeBooleanCols(); + SelectColumnIsNotNull expr = new SelectColumnIsNotNull(0); + expr.evaluate(batch); + assertEquals(6, batch.size); + assertEquals(0, batch.selected[0]); + assertEquals(1, batch.selected[1]); + assertEquals(2, batch.selected[2]); + assertEquals(3, batch.selected[3]); + assertEquals(6, batch.selected[4]); + assertEquals(7, batch.selected[5]); + + // No nulls case, not repeating + batch = getBatchThreeBooleanCols(); + batch.cols[0].noNulls = true; + int initialSize = batch.size; + expr.evaluate(batch); + Assert.assertEquals(initialSize, batch.size); + + // isRepeating, and there are nulls + batch = getBatchThreeBooleanCols(); + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + + // isRepeating, and no nulls + batch = getBatchThreeBooleanCols(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + initialSize = batch.size; + expr.evaluate(batch); + Assert.assertEquals(initialSize, batch.size); + } + + @Test + public void testFilterNotExpr() { + VectorizedRowBatch batch1 = getBatchThreeBooleanCols(); + VectorizedRowBatch batch2 = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr = new SelectColumnIsTrue(0); + FilterNotExpr notExpr = new FilterNotExpr(expr); + + notExpr.evaluate(batch1); + + notExpr.evaluate(batch2); + + assertEquals(batch1.size, batch2.size); + for (int j = 0; j < batch1.size; j++) { + assertEquals(batch1.selected[j], batch2.selected[j]); + int i = j; + assertEquals((((LongColumnVector) batch1.cols[0]).vector[i]), + (((LongColumnVector) batch2.cols[0]).vector[i])); + } + } + + @Test + public void testFilterExprOrExpr() { + VectorizedRowBatch batch1 = getBatchThreeBooleanCols(); + VectorizedRowBatch batch2 = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr1 = new SelectColumnIsTrue(0); + SelectColumnIsFalse expr2 = new SelectColumnIsFalse(1); + + FilterExprOrExpr orExpr = new FilterExprOrExpr(expr1, expr2); + + orExpr.evaluate(batch1); + orExpr.evaluate(batch2); + + assertEquals(batch1.size, batch2.size); + for (int j = 0; j < batch1.size; j++) { + assertEquals(batch1.selected[j], batch2.selected[j]); + int i = j; + assertEquals((((LongColumnVector) batch1.cols[0]).vector[i]), + (((LongColumnVector) batch2.cols[0]).vector[i])); + } + + assertEquals(5, batch1.size); + assertEquals(0, batch1.selected[0]); + assertEquals(2, batch1.selected[1]); + assertEquals(3, batch1.selected[2]); + assertEquals(4, batch1.selected[3]); + assertEquals(7, batch1.selected[4]); + + // Repeat the expression on the same batch, + // the result must be unchanged. + orExpr.evaluate(batch1); + + assertEquals(5, batch1.size); + assertEquals(0, batch1.selected[0]); + assertEquals(2, batch1.selected[1]); + assertEquals(3, batch1.selected[2]); + assertEquals(4, batch1.selected[3]); + assertEquals(7, batch1.selected[4]); + } + + @Test + public void testFilterExprOrExprWithBatchReuse() { + VectorizedRowBatch batch1 = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr1 = new SelectColumnIsTrue(0); + SelectColumnIsFalse expr2 = new SelectColumnIsFalse(1); + + FilterExprOrExpr orExpr = new FilterExprOrExpr(expr1, expr2); + + orExpr.evaluate(batch1); + + // Now re-initialize batch1 to simulate batch-object re-use. + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + batch1.selected[i] = 0; + } + batch1.size = BOOLEAN_COLUMN_TEST_SIZE; + batch1.selectedInUse = false; + + // Swap column vectors to simulate change in data + ColumnVector tmp = batch1.cols[0]; + batch1.cols[0] = batch1.cols[1]; + batch1.cols[1] = tmp; + + orExpr.evaluate(batch1); + + assertEquals(5, batch1.size); + assertEquals(0, batch1.selected[0]); + assertEquals(1, batch1.selected[1]); + assertEquals(3, batch1.selected[2]); + assertEquals(5, batch1.selected[3]); + assertEquals(6, batch1.selected[4]); + } + + @Test + public void testFilterExprOrExprWithSelectInUse() { + VectorizedRowBatch batch1 = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr1 = new SelectColumnIsTrue(0); + SelectColumnIsFalse expr2 = new SelectColumnIsFalse(1); + + FilterExprOrExpr orExpr = new FilterExprOrExpr(expr1, expr2); + + // Evaluate batch1 so that temporary arrays in the expression + // have residual values to interfere in later computation + orExpr.evaluate(batch1); + + // Swap column vectors, but keep selected vector unchanged + ColumnVector tmp = batch1.cols[0]; + batch1.cols[0] = batch1.cols[1]; + batch1.cols[1] = tmp; + // Make sure row-7 is in the output. + batch1.cols[1].isNull[7] = false; + ((LongColumnVector) batch1.cols[1]).vector[7] = 0; + + orExpr.evaluate(batch1); + + assertEquals(3, batch1.size); + assertEquals(0, batch1.selected[0]); + assertEquals(3, batch1.selected[1]); + assertEquals(7, batch1.selected[2]); + } + + @Test + public void testFilterExprAndExpr() { + VectorizedRowBatch batch1 = getBatchThreeBooleanCols(); + + SelectColumnIsTrue expr1 = new SelectColumnIsTrue(0); + SelectColumnIsFalse expr2 = new SelectColumnIsFalse(1); + + FilterExprAndExpr orExpr = new FilterExprAndExpr(expr1, expr2); + + orExpr.evaluate(batch1); + + assertEquals(1, batch1.size); + + assertEquals(2, batch1.selected[0]); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorScalarColArithmetic.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorScalarColArithmetic.java new file mode 100644 index 0000000..fa4da40 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorScalarColArithmetic.java @@ -0,0 +1,219 @@ +/** + * 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.exec.vector.expressions; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import junit.framework.Assert; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TestVectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongScalarModuloLongColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.LongScalarSubtractLongColumn; +import org.junit.Test; + +/** + * Test vectorized expression handling for the case where there is a scalar on + * the left and a column vector on the right. + */ +public class TestVectorScalarColArithmetic { + + /* Testing for equality of doubles after a math operation is + * not always reliable so use this as a tolerance. + */ + private final double EPS = 1e-7d; + + private VectorizedRowBatch getVectorizedRowBatchSingleLongVector(int size) { + VectorizedRowBatch batch = new VectorizedRowBatch(2, size); + LongColumnVector lcv = new LongColumnVector(size); + for (int i = 0; i < size; i++) { + lcv.vector[i] = i * 37; + } + batch.cols[0] = lcv; + batch.cols[1] = new LongColumnVector(size); + batch.size = size; + return batch; + } + + private VectorizedRowBatch getBatchSingleLongVectorPositiveNonZero() { + VectorizedRowBatch batch = new VectorizedRowBatch(2); + final int size = VectorizedRowBatch.DEFAULT_SIZE; + LongColumnVector lcv = new LongColumnVector(); + for (int i = 0; i < size; i++) { + lcv.vector[i] = (i + 1) * 37; + } + batch.cols[0] = lcv; + batch.cols[1] = new LongColumnVector(); + batch.size = size; + return batch; + } + + @Test + public void testLongScalarModuloLongColNoNulls() { + VectorizedRowBatch batch = getBatchSingleLongVectorPositiveNonZero(); + LongScalarModuloLongColumn expr = new LongScalarModuloLongColumn(100, 0, 1); + expr.evaluate(batch); + + // verify + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + Assert.assertEquals(100 % ((i + 1) * 37), ((LongColumnVector) batch.cols[1]).vector[i]); + } + Assert.assertTrue(((LongColumnVector)batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector)batch.cols[1]).isRepeating); + } + + @Test + public void testLongScalarSubtractLongColNoNulls() { + VectorizedRowBatch batch = getVectorizedRowBatchSingleLongVector( + VectorizedRowBatch.DEFAULT_SIZE); + LongScalarSubtractLongColumn expr = new LongScalarSubtractLongColumn(100, 0, 1); + expr.evaluate(batch); + + //verify + for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + Assert.assertEquals(100 - i * 37, ((LongColumnVector) batch.cols[1]).vector[i]); + } + Assert.assertTrue(((LongColumnVector)batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector)batch.cols[1]).isRepeating); + } + + @Test + public void testLongScalarSubtractLongColWithNulls() { + VectorizedRowBatch batch = getVectorizedRowBatchSingleLongVector( + VectorizedRowBatch.DEFAULT_SIZE); + LongColumnVector lcv = (LongColumnVector) batch.cols[0]; + TestVectorizedRowBatch.addRandomNulls(lcv); + LongScalarSubtractLongColumn expr = new LongScalarSubtractLongColumn(100, 0, 1); + expr.evaluate(batch); + + //verify + for (int i=0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) { + if (!lcv.isNull[i]) { + Assert.assertEquals(100 - i * 37, ((LongColumnVector)batch.cols[1]).vector[i]); + } else { + Assert.assertTrue(((LongColumnVector)batch.cols[1]).isNull[i]); + } + } + Assert.assertFalse(((LongColumnVector)batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector)batch.cols[1]).isRepeating); + TestVectorArithmeticExpressions.verifyLongNullDataVectorEntries( + (LongColumnVector) batch.cols[1], batch.selected, batch.selectedInUse, batch.size); + } + + @Test + public void testLongScalarSubtractLongColWithRepeating() { + LongColumnVector in, out; + VectorizedRowBatch batch; + LongScalarSubtractLongColumn expr; + + // Case 1: is repeating, no nulls + batch = getVectorizedRowBatchSingleLongVector( + VectorizedRowBatch.DEFAULT_SIZE); + in = (LongColumnVector) batch.cols[0]; + in.isRepeating = true; + out = (LongColumnVector) batch.cols[1]; + out.isRepeating = false; + expr = new LongScalarSubtractLongColumn(100, 0, 1); + expr.evaluate(batch); + + // verify + Assert.assertTrue(out.isRepeating); + Assert.assertTrue(out.noNulls); + Assert.assertEquals(out.vector[0], 100 - 0 * 37); + + // Case 2: is repeating, has nulls + batch = getVectorizedRowBatchSingleLongVector( + VectorizedRowBatch.DEFAULT_SIZE); + in = (LongColumnVector) batch.cols[0]; + in.isRepeating = true; + in.noNulls = false; + in.isNull[0] = true; + + out = (LongColumnVector) batch.cols[1]; + out.isRepeating = false; + out.isNull[0] = false; + out.noNulls = true; + expr = new LongScalarSubtractLongColumn(100, 0, 1); + expr.evaluate(batch); + + // verify + Assert.assertTrue(out.isRepeating); + Assert.assertFalse(out.noNulls); + Assert.assertEquals(true, out.isNull[0]); + TestVectorArithmeticExpressions.verifyLongNullDataVectorEntries( + out, batch.selected, batch.selectedInUse, batch.size); + } + + private boolean equalsWithinTolerance(double a, double b) { + return Math.abs(a - b) < EPS; + } + + @Test + public void testLongScalarDivide() { + VectorizedRowBatch batch = + TestVectorArithmeticExpressions.getVectorizedRowBatch2LongInDoubleOut(); + LongColDivideLongScalar expr = new LongColDivideLongScalar(0, 100, 2); + batch.cols[0].isNull[0] = true; + batch.cols[0].noNulls = false; + DoubleColumnVector out = (DoubleColumnVector) batch.cols[2]; + out.noNulls = true; // set now so we can verify it changed + out.isRepeating = true; + expr.evaluate(batch); + + // verify NULL output in entry 0 is correct + assertTrue(out.isNull[0]); + assertTrue(Double.isNaN(out.vector[0])); + + // check entries beyond first one + for (int i = 1; i != batch.size; i++) { + assertTrue(equalsWithinTolerance((i * 37) / 100d, out.vector[i])); + } + assertFalse(out.noNulls); + assertFalse(out.isRepeating); + } + + @Test + public void testScalarLongDivide() { + VectorizedRowBatch batch = + TestVectorArithmeticExpressions.getVectorizedRowBatch2LongInDoubleOut(); + LongScalarDivideLongColumn expr = new LongScalarDivideLongColumn(100, 0, 2); + batch.cols[0].isNull[1] = true; + batch.cols[0].noNulls = false; + DoubleColumnVector out = (DoubleColumnVector) batch.cols[2]; + out.noNulls = true; // set now so we can verify it changed + out.isRepeating = true; + expr.evaluate(batch); + + // verify zero-divide result for position 0 + assertTrue(Double.isInfinite(out.vector[0])); + + // verify NULL output in entry 1 is correct + assertTrue(out.isNull[1]); + assertTrue(Double.isNaN(out.vector[1])); + + // check entries beyond 2nd one + for (int i = 2; i != batch.size; i++) { + assertTrue(equalsWithinTolerance(100d / (i * 37), out.vector[i])); + } + assertFalse(out.noNulls); + assertFalse(out.isRepeating); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorStringExpressions.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorStringExpressions.java new file mode 100644 index 0000000..c94d7c5 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorStringExpressions.java @@ -0,0 +1,1493 @@ +/** + * 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.exec.vector.expressions; + +import java.io.UnsupportedEncodingException; +import java.util.Arrays; + +import junit.framework.Assert; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColEqualStringScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColGreaterEqualStringScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColLessStringColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringColLessStringScalar; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringScalarEqualStringColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringScalarGreaterStringColumn; +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.FilterStringScalarLessEqualStringColumn; +import org.apache.hadoop.io.Text; +import org.junit.Test; + +/** + * Test vectorized expression and filter evaluation for strings. + */ +public class TestVectorStringExpressions { + + private static byte[] red; + private static byte[] redred; + private static byte[] red2; // second copy of red, different object + private static byte[] green; + private static byte[] greenred; + private static byte[] redgreen; + private static byte[] greengreen; + private static byte[] blue; + private static byte[] emptyString; + private static byte[] mixedUp; + private static byte[] mixedUpLower; + private static byte[] mixedUpUpper; + private static byte[] multiByte; + private static byte[] mixPercentPattern; + private static byte[] blanksLeft; + private static byte[] blanksRight; + private static byte[] blanksBoth; + private static byte[] blankString; + + static { + try { + blue = "blue".getBytes("UTF-8"); + red = "red".getBytes("UTF-8"); + redred = "redred".getBytes("UTF-8"); + green = "green".getBytes("UTF-8"); + greenred = "greenred".getBytes("UTF-8"); + redgreen = "redgreen".getBytes("UTF-8"); + greengreen = "greengreen".getBytes("UTF-8"); + emptyString = "".getBytes("UTF-8"); + mixedUp = "mixedUp".getBytes("UTF-8"); + mixedUpLower = "mixedup".getBytes("UTF-8"); + mixedUpUpper = "MIXEDUP".getBytes("UTF-8"); + mixPercentPattern = "mix%".getBytes("UTF-8"); // for use as wildcard pattern to test LIKE + multiByte = new byte[100]; + addMultiByteChars(multiByte); + blanksLeft = " foo".getBytes("UTF-8"); + blanksRight = "foo ".getBytes("UTF-8"); + blanksBoth = " foo ".getBytes("UTF-8"); + blankString = " ".getBytes("UTF-8"); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + red2 = new byte[red.length]; + System.arraycopy(red, 0, red2, 0, red.length); + } + + // add some multi-byte characters to test length routine later. + // total characters = 4; byte length = 10 + static void addMultiByteChars(byte[] b) { + int i = 0; + b[i++] = (byte) 0x41; // letter "A" (1 byte) + b[i++] = (byte) 0xC3; // Latin capital A with grave (2 bytes) + b[i++] = (byte) 0x80; + b[i++] = (byte) 0xE2; // Euro sign (3 bytes) + b[i++] = (byte) 0x82; + b[i++] = (byte) 0xAC; + b[i++] = (byte) 0xF0; // Asian character U+24B62 (4 bytes) + b[i++] = (byte) 0xA4; + b[i++] = (byte) 0xAD; + b[i++] = (byte) 0xA2; + } + + @Test + // Load a BytesColumnVector by copying in large data, enough to force + // the buffer to expand. + public void testLoadBytesColumnVectorByValueLargeData() { + BytesColumnVector bcv = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + bcv.initBuffer(10); // initialize with estimated element size 10 + String s = "0123456789"; + while (s.length() < 500) { + s += s; + } + byte[] b = null; + try { + b = s.getBytes("UTF-8"); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + for (int i = 0; i != VectorizedRowBatch.DEFAULT_SIZE; i++) { + bcv.setVal(i, b, 0, b.length); + } + Assert.assertTrue(bcv.bufferSize() >= b.length * VectorizedRowBatch.DEFAULT_SIZE); + } + + @Test + // set values by reference, copy the data out, and verify equality + public void testLoadBytesColumnVectorByRef() { + BytesColumnVector bcv = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + String s = "red"; + byte[] b = null; + try { + b = s.getBytes("UTF-8"); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } + for (int i = 0; i != VectorizedRowBatch.DEFAULT_SIZE; i++) { + bcv.setRef(i, b, 0, b.length); + } + // verify + byte[] v = new byte[b.length]; + for (int i = 0; i != VectorizedRowBatch.DEFAULT_SIZE; i++) { + Assert.assertTrue(bcv.length[i] == b.length); + System.arraycopy(bcv.vector[i], bcv.start[i], v, 0, b.length); + Assert.assertTrue(Arrays.equals(b, v)); + } + } + + @Test + // Test string column to string literal comparison + public void testStringColCompareStringScalarFilter() { + VectorizedRowBatch batch = makeStringBatch(); + VectorExpression expr; + expr = new FilterStringColEqualStringScalar(0, red2); + expr.evaluate(batch); + + // only red qualifies, and it's in entry 0 + Assert.assertTrue(batch.size == 1); + Assert.assertTrue(batch.selected[0] == 0); + + batch = makeStringBatch(); + expr = new FilterStringColLessStringScalar(0, red2); + expr.evaluate(batch); + + // only green qualifies, and it's in entry 1 + Assert.assertTrue(batch.size == 1); + Assert.assertTrue(batch.selected[0] == 1); + + batch = makeStringBatch(); + expr = new FilterStringColGreaterEqualStringScalar(0, green); + expr.evaluate(batch); + + // green and red qualify + Assert.assertTrue(batch.size == 2); + Assert.assertTrue(batch.selected[0] == 0); + Assert.assertTrue(batch.selected[1] == 1); + } + + @Test + // Test string literal to string column comparison + public void testStringScalarCompareStringCol() { + VectorizedRowBatch batch = makeStringBatch(); + VectorExpression expr; + expr = new FilterStringScalarEqualStringColumn(0, red2); + expr.evaluate(batch); + + // only red qualifies, and it's in entry 0 + Assert.assertTrue(batch.size == 1); + Assert.assertTrue(batch.selected[0] == 0); + + batch = makeStringBatch(); + expr = new FilterStringScalarGreaterStringColumn(0, red2); + expr.evaluate(batch); + + // only green qualifies, and it's in entry 1 + Assert.assertTrue(batch.size == 1); + Assert.assertTrue(batch.selected[0] == 1); + + batch = makeStringBatch(); + expr = new FilterStringScalarLessEqualStringColumn(0, green); + expr.evaluate(batch); + + // green and red qualify + Assert.assertTrue(batch.size == 2); + Assert.assertTrue(batch.selected[0] == 0); + Assert.assertTrue(batch.selected[1] == 1); + } + + @Test + public void testStringColCompareStringColFilter() { + VectorizedRowBatch batch; + VectorExpression expr; + + /* input data + * + * col0 col1 + * =============== + * blue red + * green green + * red blue + * NULL red col0 data is empty string if we un-set NULL property + */ + + // nulls possible on left, right + batch = makeStringBatchForColColCompare(); + expr = new FilterStringColLessStringColumn(0,1); + expr.evaluate(batch); + Assert.assertEquals(1, batch.size); + Assert.assertEquals(0, batch.selected[0]); + + // no nulls possible + batch = makeStringBatchForColColCompare(); + batch.cols[0].noNulls = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(2, batch.size); + Assert.assertEquals(3, batch.selected[1]); + + // nulls on left, no nulls on right + batch = makeStringBatchForColColCompare(); + batch.cols[1].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(1, batch.size); + Assert.assertEquals(0, batch.selected[0]); + + // nulls on right, no nulls on left + batch = makeStringBatchForColColCompare(); + batch.cols[0].noNulls = true; + batch.cols[1].isNull[3] = true; + expr.evaluate(batch); + Assert.assertEquals(1, batch.size); + Assert.assertEquals(0, batch.selected[0]); + + // Now vary isRepeating + // nulls possible on left, right + + // left repeats + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertEquals(3, batch.selected[2]); + + // right repeats + batch = makeStringBatchForColColCompare(); + batch.cols[1].isRepeating = true; + expr.evaluate(batch); + Assert.assertEquals(2, batch.size); // first 2 qualify + Assert.assertEquals(1, batch.selected[1]); + + // left and right repeat + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].isRepeating = true; + expr.evaluate(batch); + Assert.assertEquals(4, batch.size); + + // Now vary isRepeating + // nulls possible only on left + + // left repeats + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertEquals(3, batch.selected[2]); + + // left repeats and is null + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].noNulls = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + + // right repeats + batch = makeStringBatchForColColCompare(); + batch.cols[1].isRepeating = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertEquals(1, batch.selected[1]); + + // left and right repeat + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].isRepeating = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(4, batch.size); + + + // Now vary isRepeating + // nulls possible only on right + + // left repeats + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + batch.cols[1].isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(2, batch.size); + Assert.assertEquals(3, batch.selected[1]); + + // right repeats + batch = makeStringBatchForColColCompare(); + batch.cols[1].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertEquals(3, batch.selected[2]); + + // right repeats and is null + batch = makeStringBatchForColColCompare(); + batch.cols[1].isRepeating = true; + batch.cols[0].noNulls = true; + batch.cols[1].isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + + // left and right repeat + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(4, batch.size); + + // left and right repeat and right is null + batch = makeStringBatchForColColCompare(); + batch.cols[0].isRepeating = true; + batch.cols[1].isRepeating = true; + batch.cols[0].noNulls = true; + batch.cols[1].isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(0, batch.size); + } + + VectorizedRowBatch makeStringBatch() { + // create a batch with one string ("Bytes") column + VectorizedRowBatch batch = new VectorizedRowBatch(2); + BytesColumnVector v = new BytesColumnVector(); + batch.cols[0] = v; + batch.cols[1] = new BytesColumnVector(); // to hold output if needed + /* + * Add these 3 values: + * + * red + * green + * NULL + */ + v.setRef(0, red, 0, red.length); + v.isNull[0] = false; + v.setRef(1, green, 0, green.length); + v.isNull[1] = false; + v.setRef(2, emptyString, 0, emptyString.length); + v.isNull[2] = true; + + v.noNulls = false; + + batch.size = 3; + return batch; + } + + VectorizedRowBatch makeStringBatchMixedCase() { + // create a batch with two string ("Bytes") columns + VectorizedRowBatch batch = new VectorizedRowBatch(2, VectorizedRowBatch.DEFAULT_SIZE); + BytesColumnVector v = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + batch.cols[0] = v; + BytesColumnVector outV = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + batch.cols[1] = outV; + /* + * Add these 3 values: + * + * mixedUp + * green + * NULL + */ + v.setRef(0, mixedUp, 0, mixedUp.length); + v.isNull[0] = false; + v.setRef(1, green, 0, green.length); + v.isNull[1] = false; + v.setRef(2, emptyString, 0, emptyString.length); + v.isNull[2] = true; + v.noNulls = false; + + batch.size = 3; + return batch; + } + + VectorizedRowBatch makeStringBatchMixedCharSize() { + + // create a new batch with one char column (for input) and one long column (for output) + VectorizedRowBatch batch = new VectorizedRowBatch(2, VectorizedRowBatch.DEFAULT_SIZE); + BytesColumnVector v = new BytesColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + batch.cols[0] = v; + LongColumnVector outV = new LongColumnVector(VectorizedRowBatch.DEFAULT_SIZE); + batch.cols[1] = outV; + + /* + * Add these 3 values: + * + * mixedUp + * green + * NULL + * <4 char string with mult-byte chars> + */ + v.setRef(0, mixedUp, 0, mixedUp.length); + v.isNull[0] = false; + v.setRef(1, green, 0, green.length); + v.isNull[1] = false; + v.setRef(2, emptyString, 0, emptyString.length); + v.isNull[2] = true; + v.noNulls = false; + v.setRef(3, multiByte, 0, 10); + v.isNull[3] = false; + + batch.size = 4; + return batch; + } + + @Test + public void testColLower() { + // has nulls, not repeating + VectorizedRowBatch batch = makeStringBatchMixedCase(); + StringLower expr = new StringLower(0, 1); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + int cmp = StringExpr.compare(mixedUpLower, 0, mixedUpLower.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isNull[2]); + int cmp2 = StringExpr.compare(green, 0, green.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + + // no nulls, not repeating + batch = makeStringBatchMixedCase(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(mixedUpLower, 0, mixedUpLower.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.noNulls); + + // has nulls, is repeating + batch = makeStringBatchMixedCase(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(mixedUpLower, 0, mixedUpLower.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertFalse(outCol.noNulls); + + // no nulls, is repeating + batch = makeStringBatchMixedCase(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(mixedUpLower, 0, mixedUpLower.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + } + + @Test + public void testColUpper() { + + // no nulls, not repeating + + /* We don't test all the combinations because (at least currently) + * the logic is inherited to be the same as testColLower, which checks all the cases). + */ + VectorizedRowBatch batch = makeStringBatchMixedCase(); + StringUpper expr = new StringUpper(0, 1); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + int cmp = StringExpr.compare(mixedUpUpper, 0, mixedUpUpper.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.noNulls); + } + + @Test + public void testStringLength() { + + // has nulls, not repeating + VectorizedRowBatch batch = makeStringBatchMixedCharSize(); + StringLength expr = new StringLength(0, 1); + expr.evaluate(batch); + LongColumnVector outCol = (LongColumnVector) batch.cols[1]; + Assert.assertEquals(5, outCol.vector[1]); // length of green is 5 + Assert.assertTrue(outCol.isNull[2]); + Assert.assertEquals(4, outCol.vector[3]); // this one has the mixed-size chars + + // no nulls, not repeating + batch = makeStringBatchMixedCharSize(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (LongColumnVector) batch.cols[1]; + Assert.assertTrue(outCol.noNulls); + Assert.assertEquals(4, outCol.vector[3]); // this one has the mixed-size chars + + // has nulls, is repeating + batch = makeStringBatchMixedCharSize(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + outCol = (LongColumnVector) batch.cols[1]; + Assert.assertTrue(outCol.isRepeating); + Assert.assertFalse(outCol.noNulls); + Assert.assertEquals(7, outCol.vector[0]); // length of "mixedUp" + + // no nulls, is repeating + batch = makeStringBatchMixedCharSize(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (LongColumnVector) batch.cols[1]; + Assert.assertEquals(7, outCol.vector[0]); // length of "mixedUp" + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + } + + private VectorizedRowBatch makeStringBatch2In1Out() { + VectorizedRowBatch batch = new VectorizedRowBatch(3); + BytesColumnVector v = new BytesColumnVector(); + batch.cols[0] = v; + BytesColumnVector v2 = new BytesColumnVector(); + batch.cols[1] = v2; + batch.cols[2] = new BytesColumnVector(); + + v.setRef(0, red, 0, red.length); + v.isNull[0] = false; + v.setRef(1, green, 0, green.length); + v.isNull[1] = false; + v.setRef(2, emptyString, 0, emptyString.length); + v.isNull[2] = true; + v.noNulls = false; + + v2.setRef(0, red, 0, red.length); + v2.isNull[0] = false; + v2.setRef(1, green, 0, green.length); + v2.isNull[1] = false; + v2.setRef(2, emptyString, 0, emptyString.length); + v2.isNull[2] = true; + v2.noNulls = false; + + batch.size = 3; + return batch; + } + + private VectorizedRowBatch makeStringBatchForColColCompare() { + VectorizedRowBatch batch = new VectorizedRowBatch(3); + BytesColumnVector v = new BytesColumnVector(); + batch.cols[0] = v; + BytesColumnVector v2 = new BytesColumnVector(); + batch.cols[1] = v2; + batch.cols[2] = new BytesColumnVector(); + + v.setRef(0, blue, 0, blue.length); + v.isNull[0] = false; + v.setRef(1, green, 0, green.length); + v.isNull[1] = false; + v.setRef(2, red, 0, red.length); + v.isNull[2] = false; + v.setRef(3, emptyString, 0, emptyString.length); + v.isNull[3] = true; + v.noNulls = false; + + v2.setRef(0, red, 0, red.length); + v2.isNull[0] = false; + v2.setRef(1, green, 0, green.length); + v2.isNull[1] = false; + v2.setRef(2, blue, 0, blue.length); + v2.isNull[2] = false; + v2.setRef(3, red, 0, red.length); + v2.isNull[3] = false; + v2.noNulls = false; + + batch.size = 4; + return batch; + } + + @Test + public void testStringLike() { + + // has nulls, not repeating + VectorizedRowBatch batch; + Text pattern; + int initialBatchSize; + batch = makeStringBatchMixedCharSize(); + pattern = new Text(mixPercentPattern); + FilterStringColLikeStringScalar expr = new FilterStringColLikeStringScalar(0, pattern); + expr.evaluate(batch); + + // verify that the beginning entry is the only one that matches + Assert.assertEquals(1, batch.size); + Assert.assertEquals(0, batch.selected[0]); + + // no nulls, not repeating + batch = makeStringBatchMixedCharSize(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + + // verify that the beginning entry is the only one that matches + Assert.assertEquals(1, batch.size); + Assert.assertEquals(0, batch.selected[0]); + + // has nulls, is repeating + batch = makeStringBatchMixedCharSize(); + initialBatchSize = batch.size; + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + + // all rows qualify + Assert.assertEquals(initialBatchSize, batch.size); + + // same, but repeating value is null + batch = makeStringBatchMixedCharSize(); + batch.cols[0].isRepeating = true; + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + + // no rows qualify + Assert.assertEquals(0, batch.size); + + // no nulls, is repeating + batch = makeStringBatchMixedCharSize(); + initialBatchSize = batch.size; + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + + // all rows qualify + Assert.assertEquals(initialBatchSize, batch.size); + } + + public void testStringLikePatternType() { + FilterStringColLikeStringScalar expr; + + // BEGIN pattern + expr = new FilterStringColLikeStringScalar(0, new Text("abc%")); + Assert.assertEquals(FilterStringColLikeStringScalar.PatternType.BEGIN, + expr.getType()); + + // END pattern + expr = new FilterStringColLikeStringScalar(0, new Text("%abc")); + Assert.assertEquals(FilterStringColLikeStringScalar.PatternType.END, + expr.getType()); + + // MIDDLE pattern + expr = new FilterStringColLikeStringScalar(0, new Text("%abc%")); + Assert.assertEquals(FilterStringColLikeStringScalar.PatternType.MIDDLE, + expr.getType()); + + // COMPLEX pattern + expr = new FilterStringColLikeStringScalar(0, new Text("%abc%de")); + Assert.assertEquals(FilterStringColLikeStringScalar.PatternType.COMPLEX, + expr.getType()); + + // NONE pattern + expr = new FilterStringColLikeStringScalar(0, new Text("abc")); + Assert.assertEquals(FilterStringColLikeStringScalar.PatternType.NONE, + expr.getType()); + } + + public void testStringLikeMultiByte() { + FilterStringColLikeStringScalar expr; + VectorizedRowBatch batch; + + // verify that a multi byte LIKE expression matches a matching string + batch = makeStringBatchMixedCharSize(); + expr = new FilterStringColLikeStringScalar(0, new Text("%" + multiByte + "%")); + expr.evaluate(batch); + Assert.assertEquals(batch.size, 1); + + // verify that a multi byte LIKE expression doesn't match a non-matching string + batch = makeStringBatchMixedCharSize(); + expr = new FilterStringColLikeStringScalar(0, new Text("%" + multiByte + "x")); + expr.evaluate(batch); + Assert.assertEquals(batch.size, 0); + } + + @Test + public void testColConcatScalar() { + + // has nulls, not repeating + VectorizedRowBatch batch = makeStringBatch(); + StringConcatColScalar expr = new StringConcatColScalar(0, 1, red); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + + int cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isNull[2]); + int cmp2 = StringExpr.compare(greenred, 0, greenred.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + Assert.assertFalse(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // no nulls, not repeating + batch = makeStringBatch(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + + cmp2 = StringExpr.compare(greenred, 0, greenred.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + + int cmp3 = StringExpr.compare(red, 0, red.length, outCol.vector[2], + outCol.start[2], outCol.length[2]); + Assert.assertEquals(0, cmp3); + + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // has nulls, is repeating + batch = makeStringBatch(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertFalse(outCol.noNulls); + + // no nulls, is repeating + batch = makeStringBatch(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + } + + @Test + public void testScalarConcatCol() { + + // has nulls, not repeating + VectorizedRowBatch batch = makeStringBatch(); + StringConcatScalarCol expr = new StringConcatScalarCol(red, 0, 1); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + + int cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isNull[2]); + int cmp2 = StringExpr.compare(redgreen, 0, redgreen.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + Assert.assertFalse(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // no nulls, not repeating + batch = makeStringBatch(); + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + + cmp2 = StringExpr.compare(redgreen, 0, redgreen.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + + int cmp3 = StringExpr.compare(red, 0, red.length, outCol.vector[2], + outCol.start[2], outCol.length[2]); + Assert.assertEquals(0, cmp3); + + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // has nulls, is repeating + batch = makeStringBatch(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertFalse(outCol.noNulls); + + // no nulls, is repeating + batch = makeStringBatch(); + batch.cols[0].isRepeating = true; + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isRepeating); + Assert.assertTrue(outCol.noNulls); + } + + @Test + public void testColConcatCol() { + + // has nulls, not repeating + VectorizedRowBatch batch = makeStringBatch2In1Out(); + StringConcatColCol expr = new StringConcatColCol(0, 1, 2); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[2]; + + int cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertTrue(outCol.isNull[2]); + int cmp2 = StringExpr.compare(greengreen, 0, greengreen.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + Assert.assertFalse(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // no nulls, not repeating + batch = makeStringBatch2In1Out(); + batch.cols[0].noNulls = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + + cmp2 = StringExpr.compare(greengreen, 0, greengreen.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp2); + + int cmp3 = StringExpr.compare(emptyString, 0, emptyString.length, + outCol.vector[2], outCol.start[2], outCol.length[2]); + Assert.assertEquals(0, cmp3); + + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + // has nulls, is repeating + + batch = makeStringBatch2In1Out(); + batch.cols[0].isRepeating = true; // only left input repeating + batch.cols[0].isNull[0] = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(true, outCol.isRepeating); + Assert.assertEquals(true, outCol.isNull[0]); + + // same, but repeating input is not null + + batch = makeStringBatch2In1Out(); + batch.cols[0].isRepeating = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + Assert.assertEquals(false, outCol.isRepeating); //TEST FAILED + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + Assert.assertEquals(true, outCol.isNull[2]); + + batch = makeStringBatch2In1Out(); + batch.cols[1].isRepeating = true; // only right input repeating + batch.cols[1].isNull[0] = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(true, outCol.isRepeating); + Assert.assertEquals(true, outCol.isNull[0]); + + batch = makeStringBatch2In1Out(); + batch.cols[0].isRepeating = true; // both inputs repeat + batch.cols[0].isNull[0] = true; + batch.cols[1].isRepeating = true; + batch.cols[1].isNull[0] = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(true, outCol.isRepeating); + Assert.assertEquals(true, outCol.isNull[0]); + + // no nulls, is repeating + batch = makeStringBatch2In1Out(); + batch.cols[1].isRepeating = true; // only right input repeating and has no nulls + batch.cols[1].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(false, outCol.isRepeating); + Assert.assertEquals(false, outCol.isNull[0]); + Assert.assertEquals(false, outCol.noNulls); + Assert.assertEquals(true, outCol.isNull[2]); + cmp = StringExpr.compare(greenred, 0, greenred.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp); + + // try again with left input also having no nulls + batch.cols[0].noNulls = true; + expr.evaluate(batch); + Assert.assertEquals(false, outCol.isRepeating); + Assert.assertEquals(true, outCol.noNulls); + cmp = StringExpr.compare(red, 0, red.length, outCol.vector[2], + outCol.start[2], outCol.length[2]); + Assert.assertEquals(0, cmp); + + batch = makeStringBatch2In1Out(); + batch.cols[0].isRepeating = true; // only left input repeating and has no nulls + batch.cols[0].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(false, outCol.isRepeating); + Assert.assertEquals(false, outCol.isNull[0]); + Assert.assertEquals(false, outCol.noNulls); + Assert.assertEquals(true, outCol.isNull[2]); + cmp = StringExpr.compare(redgreen, 0, redgreen.length, outCol.vector[1], + outCol.start[1], outCol.length[1]); + Assert.assertEquals(0, cmp); + + batch = makeStringBatch2In1Out(); + batch.cols[0].isRepeating = true; // both inputs repeat + batch.cols[0].noNulls = true; + batch.cols[1].isRepeating = true; + batch.cols[1].noNulls = true; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[2]; + + Assert.assertEquals(3, batch.size); + Assert.assertEquals(true, outCol.isRepeating); + Assert.assertEquals(false, outCol.isNull[0]); + cmp = StringExpr.compare(redred, 0, redred.length, outCol.vector[0], + outCol.start[0], outCol.length[0]); + Assert.assertEquals(0, cmp); + } + + @Test + public void testSubstrStart() throws UnsupportedEncodingException { + // Testing no nulls and no repeating + VectorizedRowBatch batch = new VectorizedRowBatch(2); + BytesColumnVector v = new BytesColumnVector(); + batch.cols[0] = v; + BytesColumnVector outV = new BytesColumnVector(); + batch.cols[1] = outV; + byte[] data1 = "abcd string".getBytes("UTF-8"); + byte[] data2 = "efgh string".getBytes("UTF-8"); + byte[] data3 = "efgh".getBytes("UTF-8"); + batch.size = 3; + v.noNulls = true; + v.setRef(0, data1, 0, data1.length); + v.isNull[0] = false; + v.setRef(1, data2, 0, data2.length); + v.isNull[1] = false; + v.setRef(2, data3, 0, data3.length); + v.isNull[2] = false; + + StringSubstrColStart expr = new StringSubstrColStart(0, 6, 1); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + byte[] expected = "string".getBytes("UTF-8"); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + // This yields empty because starting idx is out of bounds. + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + outCol.noNulls = false; + outCol.isRepeating = true; + + // Testing negative substring index. + // Start index -6 should yield the last 6 characters of the string + + expr = new StringSubstrColStart(0, -6, 1); + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + outCol.noNulls = false; + outCol.isRepeating = true; + + // Testing substring starting from index 1 + + expr = new StringSubstrColStart(0, 1, 1); + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + + Assert.assertEquals(0, + StringExpr.compare( + data1, 0, data1.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + data2, 0, data2.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + data3, 0, data3.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + outV.noNulls = false; + outV.isRepeating = true; + + // Testing with nulls + + expr = new StringSubstrColStart(0, 6, 1); + v.noNulls = false; + v.isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertFalse(outV.noNulls); + Assert.assertTrue(outV.isNull[0]); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + outCol.noNulls = false; + outCol.isRepeating = false; + + // Testing with repeating and no nulls + + outV = new BytesColumnVector(); + v = new BytesColumnVector(); + v.isRepeating = true; + v.noNulls = true; + v.setRef(0, data1, 0, data1.length); + batch = new VectorizedRowBatch(2); + batch.cols[0] = v; + batch.cols[1] = outV; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + expected = "string".getBytes("UTF-8"); + Assert.assertTrue(outV.isRepeating); + Assert.assertTrue(outV.noNulls); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + // Testing multiByte string substring + + v = new BytesColumnVector(); + v.isRepeating = false; + v.noNulls = true; + v.setRef(0, multiByte, 0, 10); + batch.cols[0] = v; + batch.cols[1] = outV; + outV.isRepeating = true; + outV.noNulls = false; + expr = new StringSubstrColStart(0, 3, 1); + batch.size = 1; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertFalse(outV.isRepeating); + Assert.assertTrue(outV.noNulls); + Assert.assertEquals(0, + StringExpr.compare( + // 3nd char starts from index 3 and total length should be 7 bytes as max is 10 + multiByte, 3, 10 - 3, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + + // Testing multiByte string with reference starting mid array + + v = new BytesColumnVector(); + v.isRepeating = false; + v.noNulls = true; + + // string is 2 chars long (a 3 byte and a 4 byte char) + v.setRef(0, multiByte, 3, 7); + batch.cols[0] = v; + batch.cols[1] = outV; + outV.isRepeating = true; + outV.noNulls = false; + outCol = (BytesColumnVector) batch.cols[1]; + expr = new StringSubstrColStart(0, 2, 1); + expr.evaluate(batch); + Assert.assertFalse(outV.isRepeating); + Assert.assertTrue(outV.noNulls); + Assert.assertEquals(0, + StringExpr.compare( + // the result is the last 1 character, which occupies 4 bytes + multiByte, 6, 4, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + } + + @Test + public void testSubstrStartLen() throws UnsupportedEncodingException { + // Testing no nulls and no repeating + + VectorizedRowBatch batch = new VectorizedRowBatch(2); + BytesColumnVector v = new BytesColumnVector(); + batch.cols[0] = v; + BytesColumnVector outV = new BytesColumnVector(); + batch.cols[1] = outV; + byte[] data1 = "abcd string".getBytes("UTF-8"); + byte[] data2 = "efgh string".getBytes("UTF-8"); + byte[] data3 = "efgh".getBytes("UTF-8"); + batch.size = 3; + v.noNulls = true; + v.setRef(0, data1, 0, data1.length); + v.isNull[0] = false; + v.setRef(1, data2, 0, data2.length); + v.isNull[1] = false; + v.setRef(2, data3, 0, data3.length); + v.isNull[2] = false; + + outV.isRepeating = true; + outV.noNulls = false; + + StringSubstrColStartLen expr = new StringSubstrColStartLen(0, 6, 6, 1); + expr.evaluate(batch); + BytesColumnVector outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + byte[] expected = "string".getBytes("UTF-8"); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + // Testing negative substring index + outV.isRepeating = true; + outV.noNulls = false; + + expr = new StringSubstrColStartLen(0, -6, 6, 1); + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(3, batch.size); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + // This yields empty because starting index is out of bounds + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + //Testing substring index starting with 0 and length equal to array length + + outV.isRepeating = true; + outV.noNulls = false; + + expr = new StringSubstrColStartLen(0, 0, 11, 1); + outCol = (BytesColumnVector) batch.cols[1]; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(0, + StringExpr.compare( + data1, 0, data1.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + data2, 0, data2.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + data3, 0, data3.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + + // Testing setting length larger than array length, which should cap to the length itself + + outV.isRepeating = true; + outV.noNulls = false; + + expr = new StringSubstrColStartLen(0, 6, 10, 1); + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertEquals(3, batch.size); + Assert.assertTrue(outCol.noNulls); + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + outV.isRepeating = true; + outV.noNulls = true; + + // Testing with nulls + + v.noNulls = false; + v.isNull[0] = true; + expr.evaluate(batch); + Assert.assertEquals(3, batch.size); + Assert.assertFalse(outV.noNulls); + Assert.assertTrue(outV.isNull[0]); + Assert.assertFalse(outCol.isRepeating); + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[1], outCol.start[1], outCol.length[1] + ) + ); + + Assert.assertEquals(0, + StringExpr.compare( + emptyString, 0, emptyString.length, outCol.vector[2], outCol.start[2], outCol.length[2] + ) + ); + + + // Testing with repeating and no nulls + outV = new BytesColumnVector(); + v = new BytesColumnVector(); + outV.isRepeating = false; + outV.noNulls = true; + v.isRepeating = true; + v.noNulls = false; + v.setRef(0, data1, 0, data1.length); + batch = new VectorizedRowBatch(2); + batch.cols[0] = v; + batch.cols[1] = outV; + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertTrue(outCol.noNulls); + Assert.assertTrue(outCol.isRepeating); + + Assert.assertEquals(0, + StringExpr.compare( + expected, 0, expected.length, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + // Testing with multiByte String + v = new BytesColumnVector(); + v.isRepeating = false; + v.noNulls = true; + batch.size = 1; + v.setRef(0, multiByte, 0, 10); + batch.cols[0] = v; + batch.cols[1] = outV; + outV.isRepeating = true; + outV.noNulls = false; + expr = new StringSubstrColStartLen(0, 3, 2, 1); + expr.evaluate(batch); + Assert.assertEquals(1, batch.size); + Assert.assertFalse(outV.isRepeating); + Assert.assertTrue(outV.noNulls); + Assert.assertEquals(0, + StringExpr.compare( + // 3rd char starts at index 3, and with length 2 it is covering the rest of the array. + multiByte, 3, 10 - 3, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + + // Testing multiByte string with reference set to mid array + v = new BytesColumnVector(); + v.isRepeating = false; + v.noNulls = true; + outV = new BytesColumnVector(); + batch.size = 1; + v.setRef(0, multiByte, 3, 7); + batch.cols[0] = v; + batch.cols[1] = outV; + outV.isRepeating = true; + outV.noNulls = false; + expr = new StringSubstrColStartLen(0, 2, 2, 1); + expr.evaluate(batch); + outCol = (BytesColumnVector) batch.cols[1]; + Assert.assertEquals(1, batch.size); + Assert.assertFalse(outV.isRepeating); + Assert.assertTrue(outV.noNulls); + Assert.assertEquals(0, + StringExpr.compare( + // 2nd substring index refers to the 6th index (last char in the array) + multiByte, 6, 10 - 6, outCol.vector[0], outCol.start[0], outCol.length[0] + ) + ); + } + + @Test + public void testVectorLTrim() { + VectorizedRowBatch b = makeTrimBatch(); + VectorExpression expr = new StringLTrim(0, 1); + expr.evaluate(b); + BytesColumnVector outV = (BytesColumnVector) b.cols[1]; + Assert.assertEquals(0, + StringExpr.compare(emptyString, 0, 0, outV.vector[0], 0, 0)); + Assert.assertEquals(0, + StringExpr.compare(blanksLeft, 2, 3, outV.vector[1], outV.start[1], outV.length[1])); + Assert.assertEquals(0, + StringExpr.compare(blanksRight, 0, 5, outV.vector[2], outV.start[2], outV.length[2])); + Assert.assertEquals(0, + StringExpr.compare(blanksBoth, 2, 5, outV.vector[3], outV.start[3], outV.length[3])); + Assert.assertEquals(0, + StringExpr.compare(red, 0, 3, outV.vector[4], outV.start[4], outV.length[4])); + Assert.assertEquals(0, + StringExpr.compare(blankString, 0, 0, outV.vector[5], outV.start[5], outV.length[5])); + } + + @Test + public void testVectorRTrim() { + VectorizedRowBatch b = makeTrimBatch(); + VectorExpression expr = new StringRTrim(0, 1); + expr.evaluate(b); + BytesColumnVector outV = (BytesColumnVector) b.cols[1]; + Assert.assertEquals(0, + StringExpr.compare(emptyString, 0, 0, outV.vector[0], 0, 0)); + Assert.assertEquals(0, + StringExpr.compare(blanksLeft, 0, 5, outV.vector[1], outV.start[1], outV.length[1])); + Assert.assertEquals(0, + StringExpr.compare(blanksRight, 0, 3, outV.vector[2], outV.start[2], outV.length[2])); + Assert.assertEquals(0, + StringExpr.compare(blanksBoth, 0, 5, outV.vector[3], outV.start[3], outV.length[3])); + Assert.assertEquals(0, + StringExpr.compare(red, 0, 3, outV.vector[4], outV.start[4], outV.length[4])); + Assert.assertEquals(0, + StringExpr.compare(blankString, 0, 0, outV.vector[5], outV.start[5], outV.length[5])); + } + + @Test + public void testVectorTrim() { + VectorizedRowBatch b = makeTrimBatch(); + VectorExpression expr = new StringTrim(0, 1); + expr.evaluate(b); + BytesColumnVector outV = (BytesColumnVector) b.cols[1]; + Assert.assertEquals(0, + StringExpr.compare(emptyString, 0, 0, outV.vector[0], 0, 0)); + Assert.assertEquals(0, + StringExpr.compare(blanksLeft, 2, 3, outV.vector[1], outV.start[1], outV.length[1])); + Assert.assertEquals(0, + StringExpr.compare(blanksRight, 0, 3, outV.vector[2], outV.start[2], outV.length[2])); + Assert.assertEquals(0, + StringExpr.compare(blanksBoth, 2, 3, outV.vector[3], outV.start[3], outV.length[3])); + Assert.assertEquals(0, + StringExpr.compare(red, 0, 3, outV.vector[4], outV.start[4], outV.length[4])); + Assert.assertEquals(0, + StringExpr.compare(blankString, 0, 0, outV.vector[5], outV.start[5], outV.length[5])); + } + + // Make a batch to test the trim functions. + private VectorizedRowBatch makeTrimBatch() { + VectorizedRowBatch b = new VectorizedRowBatch(2); + BytesColumnVector inV = new BytesColumnVector(); + BytesColumnVector outV = new BytesColumnVector(); + b.cols[0] = inV; + b.cols[1] = outV; + inV.setRef(0, emptyString, 0, 0); + inV.setRef(1, blanksLeft, 0, blanksLeft.length); + inV.setRef(2, blanksRight, 0, blanksRight.length); + inV.setRef(3, blanksBoth, 0, blanksBoth.length); + inV.setRef(4, red, 0, red.length); + inV.setRef(5, blankString, 0, blankString.length); + b.size = 5; + return b; + } + } diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorTimestampExpressions.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorTimestampExpressions.java new file mode 100644 index 0000000..33a4fe5 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorTimestampExpressions.java @@ -0,0 +1,638 @@ +/** + * 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.exec.vector.expressions; + +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.List; +import java.util.Random; + +import junit.framework.Assert; + +import org.apache.commons.lang.ArrayUtils; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TestVectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.udf.UDFDayOfMonth; +import org.apache.hadoop.hive.ql.udf.UDFHour; +import org.apache.hadoop.hive.ql.udf.UDFMinute; +import org.apache.hadoop.hive.ql.udf.UDFMonth; +import org.apache.hadoop.hive.ql.udf.UDFSecond; +import org.apache.hadoop.hive.ql.udf.UDFWeekOfYear; +import org.apache.hadoop.hive.ql.udf.UDFYear; +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.io.IntWritable; +import org.apache.hadoop.io.LongWritable; +import org.junit.Test; + +/** + * Unit tests for timestamp expressions. + */ +public class TestVectorTimestampExpressions { + + /* copied over from VectorUDFTimestampFieldLong */ + private TimestampWritable toTimestampWritable(long nanos) { + long ms = (nanos / (1000 * 1000 * 1000)) * 1000; + /* the milliseconds should be kept in nanos */ + long ns = nanos % (1000*1000*1000); + if (ns < 0) { + /* + * The nano seconds are always positive, + * but the milliseconds can be negative + */ + ms -= 1000; + ns += 1000*1000*1000; + } + Timestamp ts = new Timestamp(ms); + ts.setNanos((int) ns); + return new TimestampWritable(ts); + } + + private long[] getAllBoundaries() { + List boundaries = new ArrayList(1); + Calendar c = Calendar.getInstance(); + c.setTimeInMillis(0); // c.set doesn't reset millis + for (int year = 1902; year <= 2038; year++) { + c.set(year, Calendar.JANUARY, 1, 0, 0, 0); + long exactly = c.getTimeInMillis() * 1000 * 1000; + /* one second before and after */ + long before = exactly - 1000 * 1000 * 1000; + long after = exactly + 1000 * 1000 * 1000; + boundaries.add(Long.valueOf(before)); + boundaries.add(Long.valueOf(exactly)); + boundaries.add(Long.valueOf(after)); + } + Long[] indices = boundaries.toArray(new Long[1]); + return ArrayUtils.toPrimitive(indices); + } + + private VectorizedRowBatch getVectorizedRandomRowBatchLong2(int seed, int size) { + VectorizedRowBatch batch = new VectorizedRowBatch(2, size); + LongColumnVector lcv = new LongColumnVector(size); + Random rand = new Random(seed); + for (int i = 0; i < size; i++) { + /* all 32 bit numbers qualify & multiply up to get nano-seconds */ + lcv.vector[i] = (long)(1000*1000*1000*rand.nextInt()); + } + batch.cols[0] = lcv; + batch.cols[1] = new LongColumnVector(size); + batch.size = size; + return batch; + } + + /* + * Input array is used to fill the entire size of the vector row batch + */ + private VectorizedRowBatch getVectorizedRowBatchLong2(long[] inputs, int size) { + VectorizedRowBatch batch = new VectorizedRowBatch(2, size); + LongColumnVector lcv = new LongColumnVector(size); + for (int i = 0; i < size; i++) { + lcv.vector[i] = inputs[i % inputs.length]; + } + batch.cols[0] = lcv; + batch.cols[1] = new LongColumnVector(size); + batch.size = size; + return batch; + } + + /*begin-macro*/ + private void compareToUDFYearLong(long t, int y) { + UDFYear udf = new UDFYear(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFYearLong(VectorizedRowBatch batch) { + /* col[1] = UDFYear(col[0]) */ + VectorUDFYearLong udf = new VectorUDFYearLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFYearLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFYearLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFYearLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFYearLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFYearLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFYearLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFYearLong(batch); + } + /*end-macro*/ + + + private void compareToUDFDayOfMonthLong(long t, int y) { + UDFDayOfMonth udf = new UDFDayOfMonth(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFDayOfMonthLong(VectorizedRowBatch batch) { + /* col[1] = UDFDayOfMonth(col[0]) */ + VectorUDFDayOfMonthLong udf = new VectorUDFDayOfMonthLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFDayOfMonthLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFDayOfMonthLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFDayOfMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFDayOfMonthLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFDayOfMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFDayOfMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFDayOfMonthLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFDayOfMonthLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFDayOfMonthLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFDayOfMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFDayOfMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFDayOfMonthLong(batch); + } + + private void compareToUDFHourLong(long t, int y) { + UDFHour udf = new UDFHour(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFHourLong(VectorizedRowBatch batch) { + /* col[1] = UDFHour(col[0]) */ + VectorUDFHourLong udf = new VectorUDFHourLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFHourLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFHourLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFHourLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFHourLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFHourLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFHourLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFHourLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFHourLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFHourLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFHourLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFHourLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFHourLong(batch); + } + + private void compareToUDFMinuteLong(long t, int y) { + UDFMinute udf = new UDFMinute(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFMinuteLong(VectorizedRowBatch batch) { + /* col[1] = UDFMinute(col[0]) */ + VectorUDFMinuteLong udf = new VectorUDFMinuteLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFMinuteLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFMinuteLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFMinuteLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMinuteLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFMinuteLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMinuteLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFMinuteLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFMinuteLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFMinuteLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFMinuteLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMinuteLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFMinuteLong(batch); + } + + private void compareToUDFMonthLong(long t, int y) { + UDFMonth udf = new UDFMonth(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFMonthLong(VectorizedRowBatch batch) { + /* col[1] = UDFMonth(col[0]) */ + VectorUDFMonthLong udf = new VectorUDFMonthLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFMonthLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFMonthLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMonthLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFMonthLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFMonthLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFMonthLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFMonthLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFMonthLong(batch); + } + + private void compareToUDFSecondLong(long t, int y) { + UDFSecond udf = new UDFSecond(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFSecondLong(VectorizedRowBatch batch) { + /* col[1] = UDFSecond(col[0]) */ + VectorUDFSecondLong udf = new VectorUDFSecondLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFSecondLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFSecondLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFSecondLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFSecondLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFSecondLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFSecondLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFSecondLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFSecondLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFSecondLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFSecondLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFSecondLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFSecondLong(batch); + } + + private LongWritable getLongWritable(TimestampWritable i) { + LongWritable result = new LongWritable(); + if (i == null) { + return null; + } else { + result.set(i.getSeconds()); + return result; + } + } + + private void compareToUDFUnixTimeStampLong(long t, long y) { + TimestampWritable tsw = toTimestampWritable(t); + LongWritable res = getLongWritable(tsw); + if(res.get() != y) { + System.out.printf("%d vs %d for %d, %d\n", res.get(), y, t, + tsw.getTimestamp().getTime()/1000); + } + + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFUnixTimeStampLong(VectorizedRowBatch batch) { + /* col[1] = UDFUnixTimeStamp(col[0]) */ + VectorUDFUnixTimeStampLong udf = new VectorUDFUnixTimeStampLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFUnixTimeStampLong(t, y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFUnixTimeStampLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFUnixTimeStampLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFUnixTimeStampLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFUnixTimeStampLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFUnixTimeStampLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFUnixTimeStampLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFUnixTimeStampLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFUnixTimeStampLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFUnixTimeStampLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFUnixTimeStampLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFUnixTimeStampLong(batch); + } + + private void compareToUDFWeekOfYearLong(long t, int y) { + UDFWeekOfYear udf = new UDFWeekOfYear(); + TimestampWritable tsw = toTimestampWritable(t); + IntWritable res = udf.evaluate(tsw); + Assert.assertEquals(res.get(), y); + } + + private void verifyUDFWeekOfYearLong(VectorizedRowBatch batch) { + /* col[1] = UDFWeekOfYear(col[0]) */ + VectorUDFWeekOfYearLong udf = new VectorUDFWeekOfYearLong(0, 1); + udf.evaluate(batch); + final int in = 0; + final int out = 1; + Assert.assertEquals(batch.cols[in].noNulls, batch.cols[out].noNulls); + + for (int i = 0; i < batch.size; i++) { + if (batch.cols[in].noNulls || !batch.cols[in].isNull[i]) { + if (!batch.cols[in].noNulls) { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + long t = ((LongColumnVector) batch.cols[in]).vector[i]; + long y = ((LongColumnVector) batch.cols[out]).vector[i]; + compareToUDFWeekOfYearLong(t, (int) y); + } else { + Assert.assertEquals(batch.cols[out].isNull[i], batch.cols[in].isNull[i]); + } + } + } + + @Test + public void testVectorUDFWeekOfYearLong() { + VectorizedRowBatch batch = getVectorizedRowBatchLong2(new long[] {0}, + VectorizedRowBatch.DEFAULT_SIZE); + Assert.assertTrue(((LongColumnVector) batch.cols[1]).noNulls); + Assert.assertFalse(((LongColumnVector) batch.cols[1]).isRepeating); + verifyUDFWeekOfYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFWeekOfYearLong(batch); + + long[] boundaries = getAllBoundaries(); + batch = getVectorizedRowBatchLong2(boundaries, boundaries.length); + verifyUDFWeekOfYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFWeekOfYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFWeekOfYearLong(batch); + + batch = getVectorizedRowBatchLong2(new long[] {0}, 1); + batch.cols[0].isRepeating = true; + verifyUDFWeekOfYearLong(batch); + batch.cols[0].noNulls = false; + batch.cols[0].isNull[0] = true; + verifyUDFWeekOfYearLong(batch); + + batch = getVectorizedRandomRowBatchLong2(200, VectorizedRowBatch.DEFAULT_SIZE); + verifyUDFWeekOfYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[0]); + verifyUDFWeekOfYearLong(batch); + TestVectorizedRowBatch.addRandomNulls(batch.cols[1]); + verifyUDFWeekOfYearLong(batch); + } + + public static void main(String[] args) { + TestVectorTimestampExpressions self = new TestVectorTimestampExpressions(); + self.testVectorUDFYearLong(); + self.testVectorUDFMonthLong(); + self.testVectorUDFDayOfMonthLong(); + self.testVectorUDFHourLong(); + self.testVectorUDFWeekOfYearLong(); + self.testVectorUDFUnixTimeStampLong(); + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/TestVectorUDFAdaptor.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/TestVectorUDFAdaptor.java new file mode 100644 index 0000000..a7567b7 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/TestVectorUDFAdaptor.java @@ -0,0 +1,310 @@ +/** + * 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.exec.vector.udf; + +import static org.junit.Assert.*; + +import java.util.ArrayList; +import java.util.List; +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr; +import org.apache.hadoop.hive.ql.exec.vector.udf.VectorUDFAdaptor; +import org.apache.hadoop.hive.ql.exec.vector.udf.VectorUDFArgDesc; +import org.apache.hadoop.hive.ql.exec.vector.udf.generic.GenericUDFIsNull; +import org.apache.hadoop.hive.ql.exec.vector.udf.legacy.ConcatTextLongDoubleUDF; +import org.apache.hadoop.hive.ql.exec.vector.udf.legacy.LongUDF; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeConstantDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeGenericFuncDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFBridge; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.junit.Test; + +/* + * Test the vectorized UDF adaptor to verify that custom legacy and generic + * UDFs can be run in vectorized mode. + */ + +public class TestVectorUDFAdaptor { + + static byte[] blue = null; + static byte[] red = null; + + static { + try { + blue = "blue".getBytes("UTF-8"); + red = "red".getBytes("UTF-8"); + } catch (Exception e) { + ; // do nothing + } + } + + @Test + public void testLongUDF() { + + // create a syntax tree for a simple function call "longudf(col0)" + ExprNodeGenericFuncDesc funcDesc; + TypeInfo typeInfo = TypeInfoFactory.longTypeInfo; + GenericUDFBridge genericUDFBridge = new GenericUDFBridge("longudf", false, + LongUDF.class.getName()); + List children = new ArrayList(); + ExprNodeColumnDesc colDesc + = new ExprNodeColumnDesc(typeInfo, "col0", "tablename", false); + children.add(colDesc); + VectorUDFArgDesc[] argDescs = new VectorUDFArgDesc[1]; + argDescs[0] = new VectorUDFArgDesc(); + argDescs[0].setVariable(0); + funcDesc = new ExprNodeGenericFuncDesc(typeInfo, genericUDFBridge, + genericUDFBridge.getUdfName(), children); + + // create the adaptor for this function call to work in vector mode + VectorUDFAdaptor vudf = null; + try { + vudf = new VectorUDFAdaptor(funcDesc, 1, "Long", argDescs); + } catch (HiveException e) { + + // We should never get here. + assertTrue(false); + } + + VectorizedRowBatch b = getBatchLongInLongOut(); + vudf.evaluate(b); + + // verify output + LongColumnVector out = (LongColumnVector) b.cols[1]; + assertEquals(1000, out.vector[0]); + assertEquals(1001, out.vector[1]); + assertEquals(1002, out.vector[2]); + assertTrue(out.noNulls); + assertFalse(out.isRepeating); + + // with nulls + b = getBatchLongInLongOut(); + out = (LongColumnVector) b.cols[1]; + b.cols[0].noNulls = false; + vudf.evaluate(b); + assertFalse(out.noNulls); + assertEquals(1000, out.vector[0]); + assertEquals(1001, out.vector[1]); + assertTrue(out.isNull[2]); + assertFalse(out.isRepeating); + + // with repeating + b = getBatchLongInLongOut(); + out = (LongColumnVector) b.cols[1]; + b.cols[0].isRepeating = true; + vudf.evaluate(b); + + // The implementation may or may not set output it isRepeting. + // That is implementation-defined. + assertTrue(b.cols[1].isRepeating && out.vector[0] == 1000 + || !b.cols[1].isRepeating && out.vector[2] == 1000); + assertEquals(3, b.size); + } + + @Test + public void testMultiArgumentUDF() { + + // create a syntax tree for a function call "testudf(col0, col1, col2)" + ExprNodeGenericFuncDesc funcDesc; + TypeInfo typeInfoStr = TypeInfoFactory.stringTypeInfo; + TypeInfo typeInfoLong = TypeInfoFactory.longTypeInfo; + TypeInfo typeInfoDbl = TypeInfoFactory.doubleTypeInfo; + GenericUDFBridge genericUDFBridge = new GenericUDFBridge("testudf", false, + ConcatTextLongDoubleUDF.class.getName()); + List children = new ArrayList(); + children.add(new ExprNodeColumnDesc(typeInfoStr, "col0", "tablename", false)); + children.add(new ExprNodeColumnDesc(typeInfoLong, "col1", "tablename", false)); + children.add(new ExprNodeColumnDesc(typeInfoDbl, "col2", "tablename", false)); + + VectorUDFArgDesc[] argDescs = new VectorUDFArgDesc[3]; + for (int i = 0; i < 3; i++) { + argDescs[i] = new VectorUDFArgDesc(); + argDescs[i].setVariable(i); + } + funcDesc = new ExprNodeGenericFuncDesc(typeInfoStr, genericUDFBridge, + genericUDFBridge.getUdfName(), children); + + // create the adaptor for this function call to work in vector mode + VectorUDFAdaptor vudf = null; + try { + vudf = new VectorUDFAdaptor(funcDesc, 3, "String", argDescs); + } catch (HiveException e) { + + // We should never get here. + assertTrue(false); + throw new RuntimeException(e); + } + + // with no nulls + VectorizedRowBatch b = getBatchStrDblLongWithStrOut(); + vudf.evaluate(b); + byte[] result = null; + byte[] result2 = null; + try { + result = "red:1:1.0".getBytes("UTF-8"); + result2 = "blue:0:0.0".getBytes("UTF-8"); + } catch (Exception e) { + ; + } + BytesColumnVector out = (BytesColumnVector) b.cols[3]; + int cmp = StringExpr.compare(result, 0, result.length, out.vector[1], + out.start[1], out.length[1]); + assertEquals(0, cmp); + assertTrue(out.noNulls); + + // with nulls + b = getBatchStrDblLongWithStrOut(); + b.cols[1].noNulls = false; + vudf.evaluate(b); + out = (BytesColumnVector) b.cols[3]; + assertFalse(out.noNulls); + assertTrue(out.isNull[1]); + + // with all input columns repeating + b = getBatchStrDblLongWithStrOut(); + b.cols[0].isRepeating = true; + b.cols[1].isRepeating = true; + b.cols[2].isRepeating = true; + vudf.evaluate(b); + + out = (BytesColumnVector) b.cols[3]; + assertTrue(out.isRepeating); + cmp = StringExpr.compare(result2, 0, result2.length, out.vector[0], + out.start[0], out.length[0]); + assertEquals(0, cmp); + assertTrue(out.noNulls); + } + + private VectorizedRowBatch getBatchLongInLongOut() { + VectorizedRowBatch b = new VectorizedRowBatch(2); + LongColumnVector in = new LongColumnVector(); + LongColumnVector out = new LongColumnVector(); + b.cols[0] = in; + b.cols[1] = out; + in.vector[0] = 0; + in.vector[1] = 1; + in.vector[2] = 2; + in.isNull[2] = true; + in.noNulls = true; + b.size = 3; + return b; + } + + private VectorizedRowBatch getBatchStrDblLongWithStrOut() { + VectorizedRowBatch b = new VectorizedRowBatch(4); + BytesColumnVector strCol = new BytesColumnVector(); + LongColumnVector longCol = new LongColumnVector(); + DoubleColumnVector dblCol = new DoubleColumnVector(); + BytesColumnVector outCol = new BytesColumnVector(); + b.cols[0] = strCol; + b.cols[1] = longCol; + b.cols[2] = dblCol; + b.cols[3] = outCol; + + strCol.initBuffer(); + strCol.setVal(0, blue, 0, blue.length); + strCol.setVal(1, red, 0, red.length); + longCol.vector[0] = 0; + longCol.vector[1] = 1; + dblCol.vector[0] = 0.0; + dblCol.vector[1] = 1.0; + + // set one null value for possible later use + longCol.isNull[1] = true; + + // but have no nulls initially + longCol.noNulls = true; + strCol.noNulls = true; + dblCol.noNulls = true; + outCol.initBuffer(); + b.size = 2; + return b; + } + + + // test the UDF adaptor for a generic UDF (as opposed to a legacy UDF) + @Test + public void testGenericUDF() { + + // create a syntax tree for a function call 'myisnull(col0, "UNKNOWN")' + ExprNodeGenericFuncDesc funcDesc; + GenericUDF genericUDF = new GenericUDFIsNull(); + TypeInfo typeInfoStr = TypeInfoFactory.stringTypeInfo; + + List children = new ArrayList(); + children.add(new ExprNodeColumnDesc(typeInfoStr, "col0", "tablename", false)); + children.add(new ExprNodeConstantDesc(typeInfoStr, "UNKNOWN")); + + VectorUDFArgDesc[] argDescs = new VectorUDFArgDesc[2]; + for (int i = 0; i < 2; i++) { + argDescs[i] = new VectorUDFArgDesc(); + } + argDescs[0].setVariable(0); + argDescs[1].setConstant((ExprNodeConstantDesc) children.get(1)); + funcDesc = new ExprNodeGenericFuncDesc(typeInfoStr, genericUDF, "myisnull", children); + + // create the adaptor for this function call to work in vector mode + VectorUDFAdaptor vudf = null; + try { + vudf = new VectorUDFAdaptor(funcDesc, 3, "String", argDescs); + } catch (HiveException e) { + + // We should never get here. + assertTrue(false); + } + + VectorizedRowBatch b; + + byte[] red = null; + byte[] unknown = null; + try { + red = "red".getBytes("UTF-8"); + unknown = "UNKNOWN".getBytes("UTF-8"); + } catch (Exception e) { + ; + } + BytesColumnVector out; + + // with nulls + b = getBatchStrDblLongWithStrOut(); + b.cols[0].noNulls = false; + b.cols[0].isNull[0] = true; // set 1st entry to null + vudf.evaluate(b); + out = (BytesColumnVector) b.cols[3]; + + // verify outputs + int cmp = StringExpr.compare(red, 0, red.length, + out.vector[1], out.start[1], out.length[1]); + assertEquals(0, cmp); + cmp = StringExpr.compare(unknown, 0, unknown.length, + out.vector[0], out.start[0], out.length[0]); + assertEquals(0, cmp); + + // output entry should not be null for null input for this particular generic UDF + assertTrue(out.noNulls || !out.isNull[0]); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/generic/GenericUDFIsNull.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/generic/GenericUDFIsNull.java new file mode 100644 index 0000000..0f610d6 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/generic/GenericUDFIsNull.java @@ -0,0 +1,82 @@ +/** + * 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.exec.vector.udf.generic; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.UDFArgumentException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; +import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDFUtils; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; + +@Description(name = "myisnull", +value = "_FUNC_(value,default_value) - Returns default value if value is null else returns value", +extended = "Example:\n" ++ " > SELECT _FUNC_(null,'bla') FROM src LIMIT 1;\n" + " bla") +/* + * This is a copy of GenericUDFNvl, which is built-in. We'll make it a generic + * custom UDF for test purposes. + */ +public class GenericUDFIsNull extends GenericUDF{ + private transient GenericUDFUtils.ReturnObjectInspectorResolver returnOIResolver; + private transient ObjectInspector[] argumentOIs; + + @Override + public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { + argumentOIs = arguments; + if (arguments.length != 2) { + throw new UDFArgumentLengthException( + "The operator 'MYISNULL' accepts 2 arguments."); + } + returnOIResolver = new GenericUDFUtils.ReturnObjectInspectorResolver(true); + if (!(returnOIResolver.update(arguments[0]) && returnOIResolver + .update(arguments[1]))) { + throw new UDFArgumentTypeException(2, + "The first and seconds arguments of function MYISNULL should have the same type, " + + "but they are different: \"" + arguments[0].getTypeName() + + "\" and \"" + arguments[1].getTypeName() + "\""); + } + return returnOIResolver.get(); + } + + @Override + public Object evaluate(DeferredObject[] arguments) throws HiveException { + Object retVal = returnOIResolver.convertIfNecessary(arguments[0].get(), + argumentOIs[0]); + if (retVal == null ){ + retVal = returnOIResolver.convertIfNecessary(arguments[1].get(), + argumentOIs[1]); + } + return retVal; + } + + @Override + public String getDisplayString(String[] children) { + StringBuilder sb = new StringBuilder(); + sb.append("if "); + sb.append(children[0]); + sb.append(" is null "); + sb.append("returns"); + sb.append(children[1]); + return sb.toString() ; + } + +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/ConcatTextLongDoubleUDF.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/ConcatTextLongDoubleUDF.java new file mode 100644 index 0000000..47e4e66 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/ConcatTextLongDoubleUDF.java @@ -0,0 +1,51 @@ +/** + * 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.exec.vector.udf.legacy; +import org.apache.hadoop.hive.ql.exec.UDF; +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.io.Text; + +@Description( + name = "testudf", + value = "_FUNC_(str) - combines arguments to output string", + extended = "Example:\n" + + " > SELECT testudf(name, dob, salary) FROM employee;\n" + + " Jack" + ) + +/* This is a test function that takes three different kinds + * of arguments, for use to verify vectorized UDF invocation. + */ +public class ConcatTextLongDoubleUDF extends UDF { + public Text evaluate(Text s, Long i, Double d) { + + if (s == null + || i == null + || d == null) { + return null; + } + StringBuilder sb = new StringBuilder(); + sb.append(s.toString()); + sb.append(":"); + sb.append(i); + sb.append(":"); + sb.append(d); + return new Text(sb.toString()); + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/LongUDF.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/LongUDF.java new file mode 100644 index 0000000..994da68 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/udf/legacy/LongUDF.java @@ -0,0 +1,43 @@ +/** + * 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.exec.vector.udf.legacy; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.UDF; +import org.apache.hadoop.io.LongWritable; + +/* A UDF like one a user would create, implementing the UDF interface. + * This is to be used to test the vectorized UDF adaptor for legacy-style UDFs. + */ + +@Description( + name = "longudf", + value = "_FUNC_(arg) - returns arg + 1000", + extended = "Example:\n" + + " > SELECT longudf(eno) FROM employee;\n" + ) + +public class LongUDF extends UDF { + public LongWritable evaluate(LongWritable i) { + if (i == null) { + return null; + } + return new LongWritable(i.get() + 1000); + } +} \ No newline at end of file diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/AllVectorTypesRecord.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/AllVectorTypesRecord.java new file mode 100644 index 0000000..cba1929 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/AllVectorTypesRecord.java @@ -0,0 +1,100 @@ +/** + * 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.exec.vector.util; + +import java.sql.Timestamp; + +/** + * + * AllTypesRecord. + * + */ +public class AllVectorTypesRecord { + private final Byte ctinyInt; + private final Short csmallInt; + private final Integer cint; + private final Long cbigInt; + + private final Float cfloat; + private final Double cdouble; + + private final String cstring1; + private final String cstring2; + + private final Timestamp ctimestamp1; + private final Timestamp ctimestamp2; + + private final Boolean cboolean1; + private final Boolean cboolean2; + + /** + * + * @param ctinyInt + * @param csmallInt + * @param cint + * @param cbigInt + * @param cfloat + * @param cdouble + * @param cstring1 + * @param cstring2 + * @param ctimestamp1 + * @param ctimestamp2 + * @param cboolean1 + * @param cboolean2 + */ + public AllVectorTypesRecord(Byte ctinyInt, Short csmallInt, Integer cint, Long cbigInt, + Float cfloat, Double cdouble, String cstring1, String cstring2, Timestamp ctimestamp1, + Timestamp ctimestamp2, Boolean cboolean1, Boolean cboolean2) { + + this.ctinyInt = ctinyInt; + this.csmallInt = csmallInt; + this.cint = cint; + this.cbigInt = cbigInt; + + this.cfloat = cfloat; + this.cdouble = cdouble; + + this.cstring1 = cstring1; + this.cstring2 = cstring2; + + this.ctimestamp1 = ctimestamp1; + this.ctimestamp2 = ctimestamp2; + + this.cboolean1 = cboolean1; + this.cboolean2 = cboolean2; + } + + public static final String TABLE_NAME = "alltypesorc"; + + public static final String TABLE_CREATE_COMMAND = + "CREATE TABLE " + TABLE_NAME + "(" + + "ctinyint tinyint, " + + "csmallint smallint, " + + "cint int, " + + "cbigint bigint, " + + "cfloat float, " + + "cdouble double, " + + "cstring1 string, " + + "cstring2 string, " + + "ctimestamp1 timestamp, " + + "ctimestamp2 timestamp, " + + "cboolean1 boolean, " + + "cboolean2 boolean) " + + "STORED AS ORC"; +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputDesc.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputDesc.java new file mode 100644 index 0000000..388b962 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputDesc.java @@ -0,0 +1,31 @@ +/** + * 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.exec.vector.util; + +import org.apache.hadoop.hive.ql.plan.AbstractOperatorDesc; + +/** + * Descriptor used for the FakeCaptureOutputOperator. + * Used in unit test only. + * + */ +public class FakeCaptureOutputDesc extends AbstractOperatorDesc { + private static final long serialVersionUID = 1L; +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputOperator.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputOperator.java new file mode 100644 index 0000000..43458d9 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeCaptureOutputOperator.java @@ -0,0 +1,93 @@ +/** + * 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.exec.vector.util; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; + +/** + * Operator that captures output emitted by parent. + * Used in unit test only. + */ +public class FakeCaptureOutputOperator extends Operator + implements Serializable { + private static final long serialVersionUID = 1L; + + public interface OutputInspector { + public void inspectRow(Object row, int tag) throws HiveException; + } + + private OutputInspector outputInspector; + + public void setOutputInspector(OutputInspector outputInspector) { + this.outputInspector = outputInspector; + } + + public OutputInspector getOutputInspector() { + return outputInspector; + } + + private transient List rows; + + public static FakeCaptureOutputOperator addCaptureOutputChild( + Operator op) { + FakeCaptureOutputOperator out = new FakeCaptureOutputOperator(); + List> listParents = + new ArrayList>(1); + listParents.add(op); + out.setParentOperators(listParents); + List> listChildren = + new ArrayList>(1); + listChildren.add(out); + op.setChildOperators(listChildren); + return out; + } + + + public List getCapturedRows() { + return rows; + } + + @Override + public void initializeOp(Configuration conf) throws HiveException { + rows = new ArrayList(); + } + + @Override + public void processOp(Object row, int tag) throws HiveException { + rows.add(row); + if (null != outputInspector) { + outputInspector.inspectRow(row, tag); + } + } + + @Override + public OperatorType getType() { + return null; + } + +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperator.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperator.java new file mode 100644 index 0000000..22c2ce0 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperator.java @@ -0,0 +1,77 @@ +/** + * 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.exec.vector.util; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; + +/** + * Vectorized data source operator for testing. + * Used in unit test only. + * + */ +public class FakeVectorDataSourceOperator extends Operator + implements Serializable { + private static final long serialVersionUID = 1L; + private transient Iterable source; + + public static FakeVectorDataSourceOperator addFakeVectorDataSourceParent( + Iterable source, + Operator op) { + FakeVectorDataSourceOperator parent = new FakeVectorDataSourceOperator(source); + List> listParents = + new ArrayList>(1); + listParents.add(parent); + op.setParentOperators(listParents); + List> listChildren = + new ArrayList>(1); + listChildren.add(op); + parent.setChildOperators(listChildren); + return parent; + } + + public FakeVectorDataSourceOperator( + Iterable source) { + this.source = source; + } + + @Override + public void initializeOp(Configuration conf) throws HiveException { + } + + @Override + public void processOp(Object row, int tag) throws HiveException { + for (VectorizedRowBatch unit: source) { + forward(unit, null); + } + } + + @Override + public OperatorType getType() { + return null; + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperatorDesc.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperatorDesc.java new file mode 100644 index 0000000..81cd2ad --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorDataSourceOperatorDesc.java @@ -0,0 +1,31 @@ +/** + * 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.exec.vector.util; + +import org.apache.hadoop.hive.ql.plan.AbstractOperatorDesc; + +/** + * Operator descriptor for the FakeVectorDataSourceOperator + * Used in unit test only. + * + */ +public class FakeVectorDataSourceOperatorDesc extends AbstractOperatorDesc { + private static final long serialVersionUID = 1L; +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchBase.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchBase.java new file mode 100644 index 0000000..d489ee6 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchBase.java @@ -0,0 +1,64 @@ +/** + * 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.exec.vector.util; + +import java.util.Iterator; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Base class for VectorizedRowBatch data source. + * Used in unit test only. + * + */ +public abstract class FakeVectorRowBatchBase implements Iterable { + public abstract VectorizedRowBatch produceNextBatch(); + + private boolean iteratorProduced; + public Iterator iterator() { + assert (!iteratorProduced); + return this.new BatchIterator(); + } + + private class BatchIterator implements Iterator { + private VectorizedRowBatch currentBatch; + + private VectorizedRowBatch getCurrentBatch() { + if (null == currentBatch) { + currentBatch = produceNextBatch(); + } + return currentBatch; + } + + public boolean hasNext() { + return getCurrentBatch().size > 0; + } + + public VectorizedRowBatch next() { + VectorizedRowBatch ret = getCurrentBatch(); + currentBatch = null; + return ret; + } + + public void remove() { + throw new UnsupportedOperationException(); + } + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromConcat.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromConcat.java new file mode 100644 index 0000000..e07a2d7 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromConcat.java @@ -0,0 +1,63 @@ +/** + * 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.exec.vector.util; + +import java.util.Iterator; + +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * Concatenates many arbitrary FakeVectorRowBatch sources as one single source. + * Used in unit test only. + * + */ +public class FakeVectorRowBatchFromConcat extends FakeVectorRowBatchBase { + + private Iterable[] iterables; + private Iterator iterator; + private int index; + private static VectorizedRowBatch emptyBatch = new VectorizedRowBatch(0, 0); + + public FakeVectorRowBatchFromConcat(Iterable...iterables) { + this.iterables = iterables; + } + + @Override + public VectorizedRowBatch produceNextBatch() { + VectorizedRowBatch ret = null; + + do { + if (null != iterator && iterator.hasNext()) { + ret = iterator.next(); + break; + } + + if (index >= iterables.length) { + ret = emptyBatch; + break; + } + + iterator = iterables[index].iterator(); + ++index; + } while (true); + + return ret; + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromLongIterables.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromLongIterables.java new file mode 100644 index 0000000..1ececc7 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromLongIterables.java @@ -0,0 +1,86 @@ +/** + * 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.exec.vector.util; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * VectorizedRowBatch test source from individual column values (as iterables) + * Used in unit test only. + */ +public class FakeVectorRowBatchFromLongIterables extends FakeVectorRowBatchBase { + private VectorizedRowBatch batch; + private final int numCols; + private final int batchSize; + private List> iterators; + private boolean eof; + + public FakeVectorRowBatchFromLongIterables(int batchSize, Iterable...iterables) { + numCols = iterables.length; + this.batchSize = batchSize; + iterators = new ArrayList>(); + batch = new VectorizedRowBatch(numCols, batchSize); + for (int i =0; i < numCols; i++) { + batch.cols[i] = new LongColumnVector(batchSize); + iterators.add(iterables[i].iterator()); + } + } + + @Override + public VectorizedRowBatch produceNextBatch() { + batch.size = 0; + batch.selectedInUse = false; + for (int i=0; i < numCols; ++i) { + ColumnVector col = batch.cols[i]; + col.noNulls = true; + col.isRepeating = false; + } + while (!eof && batch.size < this.batchSize){ + int r = batch.size; + for (int i=0; i < numCols; ++i) { + Iterator it = iterators.get(i); + if (!it.hasNext()) { + eof = true; + break; + } + LongColumnVector col = (LongColumnVector)batch.cols[i]; + Long value = it.next(); + if (null == value) { + col.noNulls = false; + col.isNull[batch.size] = true; + } else { + long[] vector = col.vector; + vector[r] = value; + col.isNull[batch.size] = false; + } + } + if (!eof) { + batch.size += 1; + } + } + return batch; + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromObjectIterables.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromObjectIterables.java new file mode 100644 index 0000000..c8eaea1 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromObjectIterables.java @@ -0,0 +1,182 @@ +/** + * 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.exec.vector.util; + +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.TimestampUtils; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.metadata.HiveException; + +/** + * Test helper class that creates vectorized execution batches from arbitrary type iterables. + */ +public class FakeVectorRowBatchFromObjectIterables extends FakeVectorRowBatchBase { + + private final String[] types; + private final List> iterators; + private final VectorizedRowBatch batch; + private boolean eof; + private final int batchSize; + + public String[] getTypes() { + return this.types; + } + + /** + * Helper interface for assigning values to primitive vector column types. + */ + private static interface ColumnVectorAssign { + void assign( + ColumnVector columnVector, + int row, + Object value); + } + + private final ColumnVectorAssign[] columnAssign; + + public FakeVectorRowBatchFromObjectIterables(int batchSize, String[] types, + Iterable ...iterables) throws HiveException { + this.types = types; + this.batchSize = batchSize; + iterators = new ArrayList>(types.length); + columnAssign = new ColumnVectorAssign[types.length]; + + batch = new VectorizedRowBatch(types.length, batchSize); + for(int i=0; i< types.length; ++i) { + if (types[i].equalsIgnoreCase("tinyint") || + types[i].equalsIgnoreCase("smallint")|| + types[i].equalsIgnoreCase("int")|| + types[i].equalsIgnoreCase("bigint")|| + types[i].equalsIgnoreCase("long")) { + batch.cols[i] = new LongColumnVector(batchSize); + columnAssign[i] = new ColumnVectorAssign() { + @Override + public void assign( + ColumnVector columnVector, + int row, + Object value) { + LongColumnVector lcv = (LongColumnVector) columnVector; + lcv.vector[row] = Long.valueOf(value.toString()); + } + }; + } else if (types[i].equalsIgnoreCase("boolean")) { + batch.cols[i] = new LongColumnVector(batchSize); + columnAssign[i] = new ColumnVectorAssign() { + @Override + public void assign( + ColumnVector columnVector, + int row, + Object value) { + LongColumnVector lcv = (LongColumnVector) columnVector; + lcv.vector[row] = (Boolean) value ? 1 : 0; + } + }; + } else if (types[i].equalsIgnoreCase("timestamp")) { + batch.cols[i] = new LongColumnVector(batchSize); + columnAssign[i] = new ColumnVectorAssign() { + @Override + public void assign( + ColumnVector columnVector, + int row, + Object value) { + LongColumnVector lcv = (LongColumnVector) columnVector; + Timestamp t = (Timestamp) value; + lcv.vector[row] = TimestampUtils.getTimeNanoSec(t); + } + }; + + } else if (types[i].equalsIgnoreCase("string")) { + batch.cols[i] = new BytesColumnVector(batchSize); + columnAssign[i] = new ColumnVectorAssign() { + @Override + public void assign( + ColumnVector columnVector, + int row, + Object value) { + BytesColumnVector bcv = (BytesColumnVector) columnVector; + String s = (String) value; + byte[] bytes = s.getBytes(); + bcv.vector[row] = bytes; + bcv.start[row] = 0; + bcv.length[row] = bytes.length; + } + }; + } else if (types[i].equalsIgnoreCase("double") || + types[i].equalsIgnoreCase("float")) { + batch.cols[i] = new DoubleColumnVector(batchSize); + columnAssign[i] = new ColumnVectorAssign() { + @Override + public void assign( + ColumnVector columnVector, + int row, + Object value) { + DoubleColumnVector dcv = (DoubleColumnVector) columnVector; + dcv.vector[row] = Double.valueOf(value.toString()); + } + }; + } else { + throw new HiveException("Unimplemented type " + types[i]); + } + iterators.add(iterables[i].iterator()); + } + } + + @Override + public VectorizedRowBatch produceNextBatch() { + batch.size = 0; + batch.selectedInUse = false; + for (int i=0; i < types.length; ++i) { + ColumnVector col = batch.cols[i]; + col.noNulls = true; + col.isRepeating = false; + } + while (!eof && batch.size < this.batchSize){ + int r = batch.size; + for (int i=0; i < types.length; ++i) { + Iterator it = iterators.get(i); + if (!it.hasNext()) { + eof = true; + break; + } + Object value = it.next(); + if (null == value) { + batch.cols[i].isNull[batch.size] = true; + batch.cols[i].noNulls = false; + } else { + // Must reset the isNull, could be set from prev batch use + batch.cols[i].isNull[batch.size] = false; + columnAssign[i].assign(batch.cols[i], batch.size, value); + } + } + if (!eof) { + batch.size += 1; + } + } + return batch; + } +} + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromRepeats.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromRepeats.java new file mode 100644 index 0000000..d55ba48 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/FakeVectorRowBatchFromRepeats.java @@ -0,0 +1,72 @@ +/** + * 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.exec.vector.util; + +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +/** + * VectorizedRowBatch test source from individual column values (as RLE) + * Used in unit test only. + */ +public class FakeVectorRowBatchFromRepeats extends FakeVectorRowBatchBase { + private Long[] values; + private int count; + private int batchSize; + private VectorizedRowBatch vrg; + private final int numCols; + + public FakeVectorRowBatchFromRepeats( + Long[] values, + int count, + int batchSize) { + this.values = values; + this.count = count; + this.batchSize = batchSize; + this.numCols = values.length; + vrg = new VectorizedRowBatch(numCols, batchSize); + for (int i =0; i < numCols; i++) { + vrg.cols[i] = new LongColumnVector(batchSize); + } + } + + @Override + public VectorizedRowBatch produceNextBatch() { + vrg.size = 0; + vrg.selectedInUse = false; + if (count > 0) { + vrg.size = batchSize < count ? batchSize : count; + count -= vrg.size; + for (int i=0; i { + + private final Random rand = new Random(0xfa57); + private int possibleNonRandomValueGenerated = rand.nextInt(); + private final T[] fixedPointValues; + + public BatchGenerator() { + fixedPointValues = initializeFixedPointValues(); + } + + protected abstract T[] initializeFixedPointValues(); + + protected abstract T generateRandomNonNullValue(Random rand); + + public T[] generateBatch(BatchDataDistribution dist) { + + Object[] batch = new Object[VectorizedRowBatch.DEFAULT_SIZE]; + + for (int i = 0; i < batch.length; i++) { + switch (dist) { + case AllValues: + if (possibleNonRandomValueGenerated % 73 == 0) { + batch[i] = null; + } else if (fixedPointValues != null && possibleNonRandomValueGenerated % 233 == 0) { + batch[i] = fixedPointValues[rand.nextInt(fixedPointValues.length)]; + } else { + batch[i] = generateRandomNonNullValue(rand); + } + possibleNonRandomValueGenerated++; + break; + + case NoNulls: + if (fixedPointValues != null && possibleNonRandomValueGenerated % 233 == 0) { + batch[i] = fixedPointValues[rand.nextInt(fixedPointValues.length)]; + } else { + batch[i] = generateRandomNonNullValue(rand); + } + possibleNonRandomValueGenerated++; + break; + + case RepeatingNull: + batch[i] = null; + break; + + case RepeatingValue: + if (i == 0) { + batch[i] = generateRandomNonNullValue(rand); + } else { + batch[i] = batch[0]; + } + break; + + default: + throw new UnsupportedOperationException( + dist.toString() + " data distribution is not implemented."); + } + } + + return (T[]) batch; + } + } + + private static class ByteBatchGenerator extends BatchGenerator { + + @Override + protected Byte generateRandomNonNullValue(Random rand) { + return (byte) (rand.nextInt((Byte.MAX_VALUE - Byte.MIN_VALUE) / 2) + - Math.abs(Byte.MIN_VALUE / 2)); + } + + @Override + protected Byte[] initializeFixedPointValues() { + return new Byte[] {-23, -1, 17, 33}; + } + } + + private static class ShortBatchGenerator extends BatchGenerator { + + @Override + protected Short generateRandomNonNullValue(Random rand) { + return (short) (rand.nextInt((Short.MAX_VALUE - Short.MIN_VALUE) / 2) + + (Short.MIN_VALUE / 2)); + } + + @Override + protected Short[] initializeFixedPointValues() { + return new Short[] {-257, -75, 197, 359}; + } + + } + + private static class IntegerBatchGenerator extends BatchGenerator { + @Override + protected Integer generateRandomNonNullValue(Random rand) { + return rand.nextInt(Integer.MAX_VALUE) + (Integer.MIN_VALUE / 2); + } + + @Override + protected Integer[] initializeFixedPointValues() { + return new Integer[] {-3728, -563, 762, 6981}; + } + } + + private static class LongBatchGenerator extends BatchGenerator { + + @Override + protected Long generateRandomNonNullValue(Random rand) { + return (long) rand.nextInt(); + } + + @Override + protected Long[] initializeFixedPointValues() { + return new Long[] {(long) -89010, (long) -6432, (long) 3569, (long) 988888}; + } + } + + private static class FloatBatchGenerator extends BatchGenerator { + + private final ByteBatchGenerator byteGenerator = new ByteBatchGenerator(); + + @Override + protected Float generateRandomNonNullValue(Random rand) { + return (float) byteGenerator.generateRandomNonNullValue(rand); + } + + @Override + protected Float[] initializeFixedPointValues() { + return new Float[] {(float) -26.28, (float) -1.389, (float) 10.175, (float) 79.553}; + } + + } + + private static class DoubleBatchGenerator extends BatchGenerator { + + private final ShortBatchGenerator shortGenerator = new ShortBatchGenerator(); + + @Override + protected Double generateRandomNonNullValue(Random rand) { + return (double) shortGenerator.generateRandomNonNullValue(rand); + } + + @Override + protected Double[] initializeFixedPointValues() { + return new Double[] {-5638.15, -863.257, 2563.58, 9763215.5639}; + } + + } + + private static class BooleanBatchGenerator extends BatchGenerator { + @Override + protected Boolean generateRandomNonNullValue(Random rand) { + return rand.nextBoolean(); + } + + @Override + protected Boolean[] initializeFixedPointValues() { + return null; + } + } + + private static class StringBatchGenerator extends BatchGenerator { + + @Override + protected String generateRandomNonNullValue(Random rand) { + int length = rand.nextInt(20) + 5; + char[] values = new char[length]; + for (int j = 0; j < length; j++) { + switch (rand.nextInt(3)) { + case 0: + values[j] = (char) (rand.nextInt((int) 'z' - (int) 'a') + (int) 'a'); + break; + case 1: + values[j] = (char) (rand.nextInt((int) 'Z' - (int) 'A') + (int) 'A'); + break; + case 2: + values[j] = (char) (rand.nextInt((int) '9' - (int) '0') + (int) '0'); + break; + default: + throw new UnsupportedOperationException(); + } + } + return new String(values); + } + + @Override + protected String[] initializeFixedPointValues() { + return new String[] {"a", "b", "ss", "10"}; + } + + } + + private static class TimestampBatchGenerator extends BatchGenerator { + + private final ShortBatchGenerator shortGen = new ShortBatchGenerator(); + + @Override + protected Timestamp generateRandomNonNullValue(Random rand) { + return new Timestamp(shortGen.generateRandomNonNullValue(rand)); + } + + @Override + protected Timestamp[] initializeFixedPointValues() { + // TODO Auto-generated method stub + return new Timestamp[] { + new Timestamp(-29071), + new Timestamp(-10669), + new Timestamp(16558), + new Timestamp(31808) + }; + } + } + + private static final Map TYPE_TO_BATCH_GEN_MAP; + static { + TYPE_TO_BATCH_GEN_MAP = new HashMap(); + TYPE_TO_BATCH_GEN_MAP.put(Boolean.class, new BooleanBatchGenerator()); + + TYPE_TO_BATCH_GEN_MAP.put(Byte.class, new ByteBatchGenerator()); + TYPE_TO_BATCH_GEN_MAP.put(Integer.class, new IntegerBatchGenerator()); + TYPE_TO_BATCH_GEN_MAP.put(Long.class, new LongBatchGenerator()); + TYPE_TO_BATCH_GEN_MAP.put(Short.class, new ShortBatchGenerator()); + + TYPE_TO_BATCH_GEN_MAP.put(Float.class, new FloatBatchGenerator()); + TYPE_TO_BATCH_GEN_MAP.put(Double.class, new DoubleBatchGenerator()); + + TYPE_TO_BATCH_GEN_MAP.put(String.class, new StringBatchGenerator()); + + TYPE_TO_BATCH_GEN_MAP.put(Timestamp.class, new TimestampBatchGenerator()); + } + + /** + * Generates an orc file based on the provided record class in the specified file system + * at the output path. + * + * @param conf the configuration used to initialize the orc writer + * @param fs the file system to which will contain the generated orc file + * @param outputPath the path where the generated orc will be placed + * @param recordClass a class the defines the record format for the generated orc file, this + * class must have exactly one constructor. + */ + public static void generateOrcFile(Configuration conf, FileSystem fs, Path outputPath, + Class recordClass) + throws IOException, InstantiationException, + IllegalAccessException, InvocationTargetException { + + ObjectInspector inspector; + synchronized (TestVectorizedORCReader.class) { + inspector = ObjectInspectorFactory.getReflectionObjectInspector( + recordClass, ObjectInspectorFactory.ObjectInspectorOptions.JAVA); + } + + Writer writer = OrcFile.createWriter( + fs, + outputPath, + conf, + inspector, + 100000, + CompressionKind.ZLIB, + 10000, + 10000); + + try { + Constructor[] constructors = recordClass.getConstructors(); + + if (constructors.length != 1) { + throw new UnsupportedOperationException( + "The provided recordClass must have exactly one constructor."); + } + + BatchDataDistribution[] dataDist = BatchDataDistribution.values(); + Class[] columns = constructors[0].getParameterTypes(); + for (int i = 0; i < dataDist.length * 3; i++) { + Object[][] rows = new Object[columns.length][VectorizedRowBatch.DEFAULT_SIZE]; + for (int c = 0; c < columns.length; c++) { + if (!TYPE_TO_BATCH_GEN_MAP.containsKey(columns[c])) { + throw new UnsupportedOperationException("No batch generator defined for type " + + columns[c].getName()); + } + rows[c] = TYPE_TO_BATCH_GEN_MAP.get( + columns[c]).generateBatch(dataDist[(i + c) % dataDist.length]); + } + + for (int r = 0; r < VectorizedRowBatch.DEFAULT_SIZE; r++) { + Object[] row = new Object[columns.length]; + for (int c = 0; c < columns.length; c++) { + row[c] = rows[c][r]; + } + writer.addRow( + constructors[0].newInstance(row)); + } + } + } finally { + writer.close(); + } + } +} diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java new file mode 100644 index 0000000..238d40f --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java @@ -0,0 +1,110 @@ +/** + * 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.exec.vector.util; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + +public class VectorizedRowGroupGenUtil { + + private static final long LONG_VECTOR_NULL_VALUE = 1; + private static final double DOUBLE_VECTOR_NULL_VALUE = Double.NaN; + + public static VectorizedRowBatch getVectorizedRowBatch(int size, int numCol, int seed) { + VectorizedRowBatch vrg = new VectorizedRowBatch(numCol, size); + for (int j = 0; j < numCol; j++) { + LongColumnVector lcv = new LongColumnVector(size); + for (int i = 0; i < size; i++) { + lcv.vector[i] = (i+1) * seed * (j+1); + } + vrg.cols[j] = lcv; + } + vrg.size = size; + return vrg; + } + + public static LongColumnVector generateLongColumnVector( + boolean nulls, boolean repeating, int size, Random rand) { + LongColumnVector lcv = new LongColumnVector(size); + + lcv.noNulls = !nulls; + lcv.isRepeating = repeating; + + long repeatingValue; + do{ + repeatingValue= rand.nextLong(); + }while(repeatingValue == 0); + + int nullFrequency = generateNullFrequency(rand); + + for(int i = 0; i < size; i++) { + if(nulls && (repeating || i % nullFrequency == 0)) { + lcv.isNull[i] = true; + lcv.vector[i] = LONG_VECTOR_NULL_VALUE; + + }else { + lcv.isNull[i] = false; + lcv.vector[i] = repeating ? repeatingValue : rand.nextLong(); + if(lcv.vector[i] == 0) { + i--; + } + } + } + return lcv; + } + + public static DoubleColumnVector generateDoubleColumnVector(boolean nulls, + boolean repeating, int size, Random rand) { + DoubleColumnVector dcv = new DoubleColumnVector(size); + + dcv.noNulls = !nulls; + dcv.isRepeating = repeating; + + double repeatingValue; + do{ + repeatingValue= rand.nextDouble(); + }while(repeatingValue == 0); + + int nullFrequency = generateNullFrequency(rand); + + for(int i = 0; i < size; i++) { + if(nulls && (repeating || i % nullFrequency == 0)) { + dcv.isNull[i] = true; + dcv.vector[i] = DOUBLE_VECTOR_NULL_VALUE; + + }else { + dcv.isNull[i] = false; + dcv.vector[i] = repeating ? repeatingValue : rand.nextDouble(); + + if(dcv.vector[i] == 0) { + i--; + } + } + } + return dcv; + } + + private static int generateNullFrequency(Random rand) { + return 60 + rand.nextInt(20); + } + +} diff --git ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestVectorizedORCReader.java ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestVectorizedORCReader.java new file mode 100644 index 0000000..ef9b968 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/io/orc/TestVectorizedORCReader.java @@ -0,0 +1,181 @@ +/** + * 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.io.orc; + +import java.io.File; +import java.sql.Timestamp; +import java.util.Calendar; +import java.util.Random; + +import junit.framework.Assert; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.io.BooleanWritable; +import org.apache.hadoop.io.NullWritable; +import org.junit.Before; +import org.junit.Test; + +/** +* +* Class that tests ORC reader vectorization by comparing records that are +* returned by "row by row" reader with batch reader. +* +*/ +public class TestVectorizedORCReader { + + private Configuration conf; + private FileSystem fs; + private Path testFilePath; + + @Before + public void openFileSystem() throws Exception { + conf = new Configuration(); + fs = FileSystem.getLocal(conf); + Path workDir = new Path(System.getProperty("test.tmp.dir", + "target" + File.separator + "test" + File.separator + "tmp")); + fs.setWorkingDirectory(workDir); + testFilePath = new Path("TestVectorizedORCReader.testDump.orc"); + fs.delete(testFilePath, false); + } + + static class MyRecord { + private final Boolean bo; + private final Byte by; + private final Integer i; + private final Long l; + private final Short s; + private final Double d; + private final String k; + private final Timestamp t; + + MyRecord(Boolean bo, Byte by, Integer i, Long l, Short s, Double d, String k, Timestamp t) { + this.bo = bo; + this.by = by; + this.i = i; + this.l = l; + this.s = s; + this.d = d; + this.k = k; + this.t = t; + } + } + + @Test + public void createFile() throws Exception { + ObjectInspector inspector; + synchronized (TestVectorizedORCReader.class) { + inspector = ObjectInspectorFactory.getReflectionObjectInspector + (MyRecord.class, ObjectInspectorFactory.ObjectInspectorOptions.JAVA); + } + + Writer writer = OrcFile.createWriter(fs, testFilePath, conf, inspector, + 100000, CompressionKind.ZLIB, 10000, 10000); + Random r1 = new Random(1); + String[] words = new String[] {"It", "was", "the", "best", "of", "times,", + "it", "was", "the", "worst", "of", "times,", "it", "was", "the", "age", + "of", "wisdom,", "it", "was", "the", "age", "of", "foolishness,", "it", + "was", "the", "epoch", "of", "belief,", "it", "was", "the", "epoch", + "of", "incredulity,", "it", "was", "the", "season", "of", "Light,", + "it", "was", "the", "season", "of", "Darkness,", "it", "was", "the", + "spring", "of", "hope,", "it", "was", "the", "winter", "of", "despair,", + "we", "had", "everything", "before", "us,", "we", "had", "nothing", + "before", "us,", "we", "were", "all", "going", "direct", "to", + "Heaven,", "we", "were", "all", "going", "direct", "the", "other", + "way"}; + for (int i = 0; i < 21000; ++i) { + if ((i % 7) != 0) { + writer.addRow(new MyRecord(((i % 3) == 0), (byte)(i % 5), i, (long) 200, (short) (300 + i), (double) (400 + i), + words[r1.nextInt(words.length)], new Timestamp(Calendar.getInstance().getTime().getTime()))); + } else { + writer.addRow(new MyRecord(null, null, i, (long) 200, null, null, null, null)); + } + } + writer.close(); + checkVectorizedReader(); + } + + private void checkVectorizedReader() throws Exception { + + Reader vreader = OrcFile.createReader(testFilePath.getFileSystem(conf), testFilePath); + Reader reader = OrcFile.createReader(testFilePath.getFileSystem(conf), testFilePath); + RecordReaderImpl vrr = (RecordReaderImpl) vreader.rows(null); + RecordReaderImpl rr = (RecordReaderImpl) reader.rows(null); + VectorizedRowBatch batch = null; + OrcStruct row = null; + + // Check Vectorized ORC reader against ORC row reader + while (vrr.hasNext()) { + batch = vrr.nextBatch(batch); + for (int i = 0; i < batch.size; i++) { + row = (OrcStruct) rr.next((Object) row); + for (int j = 0; j < batch.cols.length; j++) { + Object a = (row.getFieldValue(j)); + Object b = batch.cols[j].getWritableObject(i); + // Boolean values are stores a 1's and 0's, so convert and compare + if (a instanceof BooleanWritable) { + Long temp = (long) (((BooleanWritable) a).get() ? 1 : 0); + Assert.assertEquals(true, temp.toString().equals(b.toString())); + continue; + } + // Timestamps are stored as long, so convert and compare + if (a instanceof Timestamp) { + Timestamp t = ((Timestamp) a); + // Timestamp.getTime() is overriden and is + // long time = super.getTime(); + // return (time + (nanos / 1000000)); + Long timeInNanoSec = (t.getTime() * 1000000) + (t.getNanos() % 1000000); + Assert.assertEquals(true, timeInNanoSec.toString().equals(b.toString())); + continue; + } + if (null == a) { + Assert.assertEquals(true, (b == null || (b instanceof NullWritable))); + } else { + Assert.assertEquals(true, b.toString().equals(a.toString())); + } + } + } + + // Check repeating + Assert.assertEquals(false, batch.cols[0].isRepeating); + Assert.assertEquals(false, batch.cols[1].isRepeating); + Assert.assertEquals(false, batch.cols[2].isRepeating); + Assert.assertEquals(true, batch.cols[3].isRepeating); + Assert.assertEquals(false, batch.cols[4].isRepeating); + Assert.assertEquals(false, batch.cols[5].isRepeating); + Assert.assertEquals(false, batch.cols[6].isRepeating); + Assert.assertEquals(false, batch.cols[7].isRepeating); + + // Check non null + Assert.assertEquals(false, batch.cols[0].noNulls); + Assert.assertEquals(false, batch.cols[1].noNulls); + Assert.assertEquals(true, batch.cols[2].noNulls); + Assert.assertEquals(true, batch.cols[3].noNulls); + Assert.assertEquals(false, batch.cols[4].noNulls); + Assert.assertEquals(false, batch.cols[5].noNulls); + Assert.assertEquals(false, batch.cols[6].noNulls); + Assert.assertEquals(false, batch.cols[7].noNulls); + } + Assert.assertEquals(false, rr.hasNext()); + } +} diff --git ql/src/test/queries/clientpositive/vectorization_short_regress.q ql/src/test/queries/clientpositive/vectorization_short_regress.q new file mode 100644 index 0000000..adb2672 --- /dev/null +++ ql/src/test/queries/clientpositive/vectorization_short_regress.q @@ -0,0 +1,857 @@ +SET hive.vectorized.execution.enabled=true; + +-- If you look at ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/OrcFileGenerator.java +-- which is the data generation class you'll see that those values are specified in the +-- initializeFixedPointValues for each data type. When I created the queries I usedthose values +-- where I needed scalar values to ensure that when the queries executed their predicates would be +-- filtering on values that are guaranteed to exist. + +-- Beyond those values, all the other data in the alltypesorc file is random, but there is a +-- specific pattern to the data that is important for coverage. In orc and subsequently +-- vectorization there are a number of optimizations for certain data patterns: AllValues, NoNulls, +-- RepeatingValue, RepeatingNull. The data in alltypesorc is generated such that each column has +-- exactly 3 batches of each data pattern. This gives us coverage for the vector expression +-- optimizations and ensure the metadata in appropriately set on the row batch object which are +-- reused across batches. + +-- For the queries themselves in order to efficiently cover as much of the new vectorization +-- functionality as I could I used a number of different techniques to create the +-- vectorization_short_regress.q test suite, primarily equivalence classes, and pairwise +-- combinations. + +-- First I divided the search space into a number of dimensions such as type, aggregate function, +-- filter operation, arithmetic operation, etc. The types were explored as equivalence classes of +-- long, double, time, string, and bool. Also, rather than creating a very large number of small +-- queries the resulting vectors were grouped by compatible dimensions to reduce the number of +-- queries. + +-- TargetTypeClasses: Long, Timestamp, Double, String, Bool +-- Functions: Avg, Sum, StDevP, StDev, Var, Min, Count +-- ArithmeticOps: Add, Multiply, Subtract, Divide +-- FilterOps: Equal, NotEqual, GreaterThan, LessThan, LessThanOrEqual +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))); +SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))); + +-- TargetTypeClasses: Long, Bool, Double, String, Timestamp +-- Functions: Max, VarP, StDevP, Avg, Min, StDev, Var +-- ArithmeticOps: Divide, Multiply, Remainder, Subtract +-- FilterOps: LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))); +SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))); + +-- TargetTypeClasses: String, Long, Bool, Double, Timestamp +-- Functions: VarP, Count, Max, StDevP, StDev, Avg +-- ArithmeticOps: Subtract, Remainder, Multiply, Add +-- FilterOps: Equal, LessThanOrEqual, GreaterThan, Like, LessThan +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))); +SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))); + +-- TargetTypeClasses: String, Bool, Timestamp, Long, Double +-- Functions: Avg, Max, StDev, VarP +-- ArithmeticOps: Add, Divide, Remainder, Multiply +-- FilterOps: LessThanOrEqual, NotEqual, GreaterThanOrEqual, LessThan, Equal +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)); +SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)); + +-- TargetTypeClasses: Timestamp, String, Long, Double, Bool +-- Functions: Max, Avg, Min, Var, StDev, Count, StDevP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide +-- FilterOps: Like, NotEqual, LessThan, GreaterThanOrEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))); +SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))); + +-- TargetTypeClasses: Long, String, Double, Bool, Timestamp +-- Functions: VarP, Var, StDev, StDevP, Max, Sum +-- ArithmeticOps: Divide, Remainder, Subtract, Multiply +-- FilterOps: Equal, LessThanOrEqual, LessThan, Like, GreaterThanOrEqual, NotEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))); +SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))); + +-- TargetTypeClasses: String, Bool, Double, Long, Timestamp +-- Functions: Sum, Max, Avg, Var, StDevP, VarP +-- ArithmeticOps: Add, Subtract, Divide, Multiply, Remainder +-- FilterOps: NotEqual, GreaterThanOrEqual, Like, LessThanOrEqual, Equal, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble; +SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble; + +-- TargetTypeClasses: Long, String, Double, Timestamp +-- Functions: Avg, Min, StDevP, Sum, Var +-- ArithmeticOps: Divide, Subtract, Multiply, Remainder +-- FilterOps: GreaterThan, LessThan, LessThanOrEqual, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble; +SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble; + +-- TargetTypeClasses: Double, String, Long +-- Functions: StDev, Sum, VarP, Count +-- ArithmeticOps: Remainder, Divide, Subtract +-- FilterOps: GreaterThanOrEqual, Equal, LessThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint; +SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint; + +-- TargetTypeClasses: Long, Double, Timestamp +-- Functions: Var, Count, Sum, VarP, StDevP +-- ArithmeticOps: Multiply, Add, Subtract, Remainder +-- FilterOps: GreaterThan, LessThan, Equal, LessThanOrEqual, GreaterThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble; +SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble; + +-- TargetTypeClasses: Bool, Timestamp, String, Double, Long +-- Functions: StDevP, Avg, Count, Min, Var, VarP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide, Remainder +-- FilterOps: NotEqual, LessThan, Like, Equal +-- GroupBy: GroupBy +EXPLAIN SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1; +SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1; + +-- TargetTypeClasses: Double, Long, String, Timestamp, Bool +-- Functions: Max, Sum, Var, Avg, Min, VarP, StDev, StDevP +-- ArithmeticOps: Divide, Subtract, Remainder, Add, Multiply +-- FilterOps: GreaterThan, LessThanOrEqual, Equal, LessThan, GreaterThanOrEqual, NotEqual, Like +-- GroupBy: GroupBy +EXPLAIN SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1; +SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1; + diff --git ql/src/test/queries/clientpositive/vectorized_rcfile_columnar.q ql/src/test/queries/clientpositive/vectorized_rcfile_columnar.q new file mode 100644 index 0000000..660442f --- /dev/null +++ ql/src/test/queries/clientpositive/vectorized_rcfile_columnar.q @@ -0,0 +1,18 @@ +--This query must pass even when vectorized reader is not available for +--RC files. The query must fall back to the non-vector mode and run successfully. + +CREATE table columnTable (key STRING, value STRING) +ROW FORMAT SERDE + 'org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe' +STORED AS + INPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileInputFormat' + OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileOutputFormat'; + +FROM src +INSERT OVERWRITE TABLE columnTable SELECT src.key, src.value LIMIT 10; +describe columnTable; + +SET hive.vectorized.execution.enabled=true; + +SELECT key, value FROM columnTable; + diff --git ql/src/test/results/clientpositive/add_part_exist.q.out ql/src/test/results/clientpositive/add_part_exist.q.out index e64cc3c..559cb26 100644 --- ql/src/test/results/clientpositive/add_part_exist.q.out +++ ql/src/test/results/clientpositive/add_part_exist.q.out @@ -75,6 +75,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter1.q.out ql/src/test/results/clientpositive/alter1.q.out index a944b29..ae17dcd 100644 --- ql/src/test/results/clientpositive/alter1.q.out +++ ql/src/test/results/clientpositive/alter1.q.out @@ -168,6 +168,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter2.q.out ql/src/test/results/clientpositive/alter2.q.out index 82c78ad..c90a189 100644 --- ql/src/test/results/clientpositive/alter2.q.out +++ ql/src/test/results/clientpositive/alter2.q.out @@ -172,6 +172,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter3.q.out ql/src/test/results/clientpositive/alter3.q.out index 43064f7..aeb366e 100644 --- ql/src/test/results/clientpositive/alter3.q.out +++ ql/src/test/results/clientpositive/alter3.q.out @@ -184,6 +184,7 @@ POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES POSTHOOK: Lineage: alter3 PARTITION(pcol1=test_part:,pcol2=test_part:).col1 SIMPLE [(alter3_src)alter3_src.FieldSchema(name:col1, type:string, comment:null), ] POSTHOOK: Lineage: alter3_like PARTITION(pcol1=test_part:,pcol2=test_part:).col1 SIMPLE [(alter3_src)alter3_src.FieldSchema(name:col1, type:string, comment:null), ] +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter4.q.out ql/src/test/results/clientpositive/alter4.q.out index ed8b4f6..ee8dd06 100644 --- ql/src/test/results/clientpositive/alter4.q.out +++ ql/src/test/results/clientpositive/alter4.q.out @@ -41,6 +41,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter5.q.out ql/src/test/results/clientpositive/alter5.q.out index c1df0c8..2af1cd3 100644 --- ql/src/test/results/clientpositive/alter5.q.out +++ ql/src/test/results/clientpositive/alter5.q.out @@ -115,6 +115,7 @@ PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES POSTHOOK: Lineage: alter5 PARTITION(dt=a).col1 SIMPLE [(alter5_src)alter5_src.FieldSchema(name:col1, type:string, comment:null), ] +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter_index.q.out ql/src/test/results/clientpositive/alter_index.q.out index a1738ad..b7786ce 100644 --- ql/src/test/results/clientpositive/alter_index.q.out +++ ql/src/test/results/clientpositive/alter_index.q.out @@ -37,6 +37,7 @@ PREHOOK: query: show tables PREHOOK: type: SHOWTABLES POSTHOOK: query: show tables POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/alter_rename_partition.q.out ql/src/test/results/clientpositive/alter_rename_partition.q.out index c6fa3f9..35474c9 100644 --- ql/src/test/results/clientpositive/alter_rename_partition.q.out +++ ql/src/test/results/clientpositive/alter_rename_partition.q.out @@ -12,6 +12,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json @@ -130,6 +131,7 @@ PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES POSTHOOK: Lineage: alter_rename_partition PARTITION(pcol1=old_part1:,pcol2=old_part2:).col1 SIMPLE [(alter_rename_partition_src)alter_rename_partition_src.FieldSchema(name:col1, type:string, comment:null), ] +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/describe_table_json.q.out ql/src/test/results/clientpositive/describe_table_json.q.out index d4f497f..31225f2 100644 --- ql/src/test/results/clientpositive/describe_table_json.q.out +++ ql/src/test/results/clientpositive/describe_table_json.q.out @@ -7,7 +7,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES -{"tables":["jsontable","src","src1","src_json","src_sequencefile","src_thrift","srcbucket","srcbucket2","srcpart"]} +{"tables":["alltypesorc","jsontable","src","src1","src_json","src_sequencefile","src_thrift","srcbucket","srcbucket2","srcpart"]} PREHOOK: query: SHOW TABLES LIKE 'json*' PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES LIKE 'json*' diff --git ql/src/test/results/clientpositive/index_creation.q.out ql/src/test/results/clientpositive/index_creation.q.out index bddaa35..fbca8d3 100644 --- ql/src/test/results/clientpositive/index_creation.q.out +++ ql/src/test/results/clientpositive/index_creation.q.out @@ -306,6 +306,7 @@ POSTHOOK: Lineage: default___t_x2__._offsets EXPRESSION [(_t)_t.FieldSchema(name POSTHOOK: Lineage: default___t_x__._bucketname SIMPLE [(_t)_t.FieldSchema(name:INPUT__FILE__NAME, type:string, comment:), ] POSTHOOK: Lineage: default___t_x__._j SIMPLE [(_t)_t.FieldSchema(name:_j, type:int, comment:null), ] POSTHOOK: Lineage: default___t_x__._offsets EXPRESSION [(_t)_t.FieldSchema(name:BLOCK__OFFSET__INSIDE__FILE, type:bigint, comment:), ] +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/input2.q.out ql/src/test/results/clientpositive/input2.q.out index e99d405..66be1a8 100644 --- ql/src/test/results/clientpositive/input2.q.out +++ ql/src/test/results/clientpositive/input2.q.out @@ -31,6 +31,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json @@ -53,6 +54,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/input3.q.out ql/src/test/results/clientpositive/input3.q.out index be091ea..fffaf2e 100644 --- ql/src/test/results/clientpositive/input3.q.out +++ ql/src/test/results/clientpositive/input3.q.out @@ -25,6 +25,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json @@ -114,6 +115,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/input4.q.out ql/src/test/results/clientpositive/input4.q.out index 8717143..d0b271b 100644 --- ql/src/test/results/clientpositive/input4.q.out +++ ql/src/test/results/clientpositive/input4.q.out @@ -48,7 +48,7 @@ PREHOOK: type: QUERY POSTHOOK: query: EXPLAIN FORMATTED SELECT Input4Alias.VALUE, Input4Alias.KEY FROM INPUT4 AS Input4Alias POSTHOOK: type: QUERY -{"STAGE PLANS":{"Stage-1":{"Map Reduce":{"Map:":{"Split Sample:":{},"Alias -> Map Operator Tree:":{"input4alias":{"TS_0":{"SEL_1":{"FS_2":{"File Output Operator":{"GlobalTableId:":"0","compressed:":"false","table:":{"input format:":"org.apache.hadoop.mapred.TextInputFormat","output format:":"org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"}}}}}}}}}},"Stage-0":{"Fetch Operator":{"limit:":"-1"}}},"STAGE DEPENDENCIES":{"Stage-1":{"ROOT STAGE":"TRUE"},"Stage-0":{"ROOT STAGE":"TRUE"}},"ABSTRACT SYNTAX TREE":"(TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME INPUT4) Input4Alias)) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (. (TOK_TABLE_OR_COL Input4Alias) VALUE)) (TOK_SELEXPR (. (TOK_TABLE_OR_COL Input4Alias) KEY)))))"} +{"STAGE PLANS":{"Stage-1":{"Map Reduce":{"Vectorized execution:":"false","Map:":{"Vectorized execution:":"false","Split Sample:":{},"Alias -> Map Operator Tree:":{"input4alias":{"TS_0":{"SEL_1":{"FS_2":{"File Output Operator":{"Vectorized execution:":"false","GlobalTableId:":"0","compressed:":"false","table:":{"input format:":"org.apache.hadoop.mapred.TextInputFormat","output format:":"org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"}}}}}}}}}},"Stage-0":{"Fetch Operator":{"limit:":"-1"}}},"STAGE DEPENDENCIES":{"Stage-1":{"ROOT STAGE":"TRUE"},"Stage-0":{"ROOT STAGE":"TRUE"}},"ABSTRACT SYNTAX TREE":"(TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME INPUT4) Input4Alias)) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (. (TOK_TABLE_OR_COL Input4Alias) VALUE)) (TOK_SELEXPR (. (TOK_TABLE_OR_COL Input4Alias) KEY)))))"} PREHOOK: query: SELECT Input4Alias.VALUE, Input4Alias.KEY FROM INPUT4 AS Input4Alias PREHOOK: type: QUERY PREHOOK: Input: default@input4 diff --git ql/src/test/results/clientpositive/plan_json.q.out ql/src/test/results/clientpositive/plan_json.q.out index b68dc06..462b07b 100644 --- ql/src/test/results/clientpositive/plan_json.q.out +++ ql/src/test/results/clientpositive/plan_json.q.out @@ -6,4 +6,4 @@ POSTHOOK: query: -- explain plan json: the query gets the formatted json output EXPLAIN FORMATTED SELECT count(1) FROM src POSTHOOK: type: QUERY -{"STAGE PLANS":{"Stage-1":{"Map Reduce":{"Map:":{"Split Sample:":{},"Alias -> Map Operator Tree:":{"src":{"TS_0":{"SEL_1":{"GBY_2":{"RS_3":{"Reduce Output Operator":{"Map-reduce partition columns:":[],"sort order:":"","tag:":"-1","value expressions:":[{"type:":"bigint","expr:":"_col0"}],"key expressions:":[]}}}}}}}},"Reduce:":{"Reduce Operator Tree:":{"GBY_4":{"SEL_5":{"FS_6":{"File Output Operator":{"GlobalTableId:":"0","compressed:":"false","table:":{"input format:":"org.apache.hadoop.mapred.TextInputFormat","output format:":"org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"}}}}}}}}},"Stage-0":{"Fetch Operator":{"limit:":"-1"}}},"STAGE DEPENDENCIES":{"Stage-1":{"ROOT STAGE":"TRUE"},"Stage-0":{"ROOT STAGE":"TRUE"}},"ABSTRACT SYNTAX TREE":"(TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME src))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION count 1)))))"} +{"STAGE PLANS":{"Stage-1":{"Map Reduce":{"Vectorized execution:":"false","Map:":{"Vectorized execution:":"false","Split Sample:":{},"Alias -> Map Operator Tree:":{"src":{"TS_0":{"SEL_1":{"GBY_2":{"RS_3":{"Reduce Output Operator":{"Vectorized execution:":"false","Map-reduce partition columns:":[],"sort order:":"","tag:":"-1","value expressions:":[{"type:":"bigint","expr:":"_col0"}],"key expressions:":[]}}}}}}}},"Reduce:":{"Vectorized execution:":"false","Reduce Operator Tree:":{"GBY_4":{"SEL_5":{"FS_6":{"File Output Operator":{"Vectorized execution:":"false","GlobalTableId:":"0","compressed:":"false","table:":{"input format:":"org.apache.hadoop.mapred.TextInputFormat","output format:":"org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat"}}}}}}}}},"Stage-0":{"Fetch Operator":{"limit:":"-1"}}},"STAGE DEPENDENCIES":{"Stage-1":{"ROOT STAGE":"TRUE"},"Stage-0":{"ROOT STAGE":"TRUE"}},"ABSTRACT SYNTAX TREE":"(TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME src))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION count 1)))))"} diff --git ql/src/test/results/clientpositive/rename_column.q.out ql/src/test/results/clientpositive/rename_column.q.out index 34b70eb..3627264 100644 --- ql/src/test/results/clientpositive/rename_column.q.out +++ ql/src/test/results/clientpositive/rename_column.q.out @@ -127,6 +127,7 @@ PREHOOK: query: SHOW TABLES PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES POSTHOOK: type: SHOWTABLES +alltypesorc src src1 src_json diff --git ql/src/test/results/clientpositive/show_tables.q.out ql/src/test/results/clientpositive/show_tables.q.out index d434c0e..fb25c77 100644 --- ql/src/test/results/clientpositive/show_tables.q.out +++ ql/src/test/results/clientpositive/show_tables.q.out @@ -112,6 +112,7 @@ PREHOOK: query: SHOW TABLES FROM default PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES FROM default POSTHOOK: type: SHOWTABLES +alltypesorc shtb_test1 shtb_test2 src @@ -133,6 +134,7 @@ PREHOOK: query: SHOW TABLES IN default PREHOOK: type: SHOWTABLES POSTHOOK: query: SHOW TABLES IN default POSTHOOK: type: SHOWTABLES +alltypesorc shtb_test1 shtb_test2 src diff --git ql/src/test/results/clientpositive/vectorization_short_regress.q.out ql/src/test/results/clientpositive/vectorization_short_regress.q.out new file mode 100644 index 0000000..4f00806 --- /dev/null +++ ql/src/test/results/clientpositive/vectorization_short_regress.q.out @@ -0,0 +1,9345 @@ +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- If you look at ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/OrcFileGenerator.java +-- which is the data generation class you'll see that those values are specified in the +-- initializeFixedPointValues for each data type. When I created the queries I usedthose values +-- where I needed scalar values to ensure that when the queries executed their predicates would be +-- filtering on values that are guaranteed to exist. + +-- Beyond those values, all the other data in the alltypesorc file is random, but there is a +-- specific pattern to the data that is important for coverage. In orc and subsequently +-- vectorization there are a number of optimizations for certain data patterns: AllValues, NoNulls, +-- RepeatingValue, RepeatingNull. The data in alltypesorc is generated such that each column has +-- exactly 3 batches of each data pattern. This gives us coverage for the vector expression +-- optimizations and ensure the metadata in appropriately set on the row batch object which are +-- reused across batches. + +-- For the queries themselves in order to efficiently cover as much of the new vectorization +-- functionality as I could I used a number of different techniques to create the +-- vectorization_short_regress.q test suite, primarily equivalence classes, and pairwise +-- combinations. + +-- First I divided the search space into a number of dimensions such as type, aggregate function, +-- filter operation, arithmetic operation, etc. The types were explored as equivalence classes of +-- long, double, time, string, and bool. Also, rather than creating a very large number of small +-- queries the resulting vectors were grouped by compatible dimensions to reduce the number of +-- queries. + +-- TargetTypeClasses: Long, Timestamp, Double, String, Bool +-- Functions: Avg, Sum, StDevP, StDev, Var, Min, Count +-- ArithmeticOps: Add, Multiply, Subtract, Divide +-- FilterOps: Equal, NotEqual, GreaterThan, LessThan, LessThanOrEqual +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))) +PREHOOK: type: QUERY +POSTHOOK: query: -- If you look at ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/OrcFileGenerator.java +-- which is the data generation class you'll see that those values are specified in the +-- initializeFixedPointValues for each data type. When I created the queries I usedthose values +-- where I needed scalar values to ensure that when the queries executed their predicates would be +-- filtering on values that are guaranteed to exist. + +-- Beyond those values, all the other data in the alltypesorc file is random, but there is a +-- specific pattern to the data that is important for coverage. In orc and subsequently +-- vectorization there are a number of optimizations for certain data patterns: AllValues, NoNulls, +-- RepeatingValue, RepeatingNull. The data in alltypesorc is generated such that each column has +-- exactly 3 batches of each data pattern. This gives us coverage for the vector expression +-- optimizations and ensure the metadata in appropriately set on the row batch object which are +-- reused across batches. + +-- For the queries themselves in order to efficiently cover as much of the new vectorization +-- functionality as I could I used a number of different techniques to create the +-- vectorization_short_regress.q test suite, primarily equivalence classes, and pairwise +-- combinations. + +-- First I divided the search space into a number of dimensions such as type, aggregate function, +-- filter operation, arithmetic operation, etc. The types were explored as equivalence classes of +-- long, double, time, string, and bool. Also, rather than creating a very large number of small +-- queries the resulting vectors were grouped by compatible dimensions to reduce the number of +-- queries. + +-- TargetTypeClasses: Long, Timestamp, Double, String, Bool +-- Functions: Avg, Sum, StDevP, StDev, Var, Min, Count +-- ArithmeticOps: Add, Multiply, Subtract, Divide +-- FilterOps: Equal, NotEqual, GreaterThan, LessThan, LessThanOrEqual +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728))) (TOK_SELEXPR (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728))))) (TOK_SELEXPR (* (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))) (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (* (* (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))) (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728))) (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)) (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728)))))) (TOK_SELEXPR (* (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)) (- (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (- 3728))))) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- 10.175 (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (- (- 10.175 (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint))))) (TOK_SELEXPR (/ (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- 563))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (- (/ (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- 563)))) (TOK_SELEXPR (/ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cdouble)))) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (TOK_FUNCTION COUNT (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (/ (TOK_FUNCTION MIN (TOK_TABLE_OR_COL ctinyint)) (/ (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- 563)))) (TOK_SELEXPR (- (/ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cdouble)))))) (TOK_WHERE (OR (OR (OR (= 762 (TOK_TABLE_OR_COL cbigint)) (AND (< (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL cfloat)) (AND (> (TOK_TABLE_OR_COL ctimestamp2) (- 10669)) (!= (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cint))))) (= (TOK_TABLE_OR_COL cstring1) 'a')) (AND (<= (TOK_TABLE_OR_COL cbigint) (- 1.389)) (AND (!= (TOK_TABLE_OR_COL cstring2) 'a') (AND (!= 79.553 (TOK_TABLE_OR_COL cint)) (!= (TOK_TABLE_OR_COL cboolean2) (TOK_TABLE_OR_COL cboolean1))))))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((((762 = cbigint) or ((csmallint < cfloat) and ((ctimestamp2 > (- 10669)) and (cdouble <> cint)))) or (cstring1 = 'a')) or ((cbigint <= (- 1.389)) and ((cstring2 <> 'a') and ((79.553 <> cint) and (cboolean2 <> cboolean1))))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cint + type: int + expr: cdouble + type: double + expr: csmallint + type: smallint + expr: cfloat + type: float + expr: ctinyint + type: tinyint + outputColumnNames: cint, cdouble, csmallint, cfloat, ctinyint + Vectorized execution: true + Group By Operator + aggregations: + expr: avg(cint) + expr: sum(cdouble) + expr: stddev_pop(cint) + expr: stddev_samp(csmallint) + expr: var_samp(cint) + expr: avg(cfloat) + expr: stddev_samp(cint) + expr: min(ctinyint) + expr: count(csmallint) + bucketGroup: false + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Vectorized execution: true + Reduce Output Operator + sort order: + tag: -1 + value expressions: + expr: _col0 + type: struct + expr: _col1 + type: double + expr: _col2 + type: struct + expr: _col3 + type: struct + expr: _col4 + type: struct + expr: _col5 + type: struct + expr: _col6 + type: struct + expr: _col7 + type: tinyint + expr: _col8 + type: bigint + Reduce Operator Tree: + Group By Operator + aggregations: + expr: avg(VALUE._col0) + expr: sum(VALUE._col1) + expr: stddev_pop(VALUE._col2) + expr: stddev_samp(VALUE._col3) + expr: var_samp(VALUE._col4) + expr: avg(VALUE._col5) + expr: stddev_samp(VALUE._col6) + expr: min(VALUE._col7) + expr: count(VALUE._col8) + bucketGroup: false + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Select Operator + expressions: + expr: _col0 + type: double + expr: (_col0 + (- 3728)) + type: double + expr: (- (_col0 + (- 3728))) + type: double + expr: (- (- (_col0 + (- 3728)))) + type: double + expr: ((- (- (_col0 + (- 3728)))) * (_col0 + (- 3728))) + type: double + expr: _col1 + type: double + expr: (- _col0) + type: double + expr: _col2 + type: double + expr: (((- (- (_col0 + (- 3728)))) * (_col0 + (- 3728))) * (- (- (_col0 + (- 3728))))) + type: double + expr: _col3 + type: double + expr: (- _col2) + type: double + expr: (_col2 - (- (- (_col0 + (- 3728))))) + type: double + expr: ((_col2 - (- (- (_col0 + (- 3728))))) * _col2) + type: double + expr: _col4 + type: double + expr: _col5 + type: double + expr: (10.175 - _col4) + type: double + expr: (- (10.175 - _col4)) + type: double + expr: ((- _col2) / (- 563)) + type: double + expr: _col6 + type: double + expr: (- ((- _col2) / (- 563))) + type: double + expr: (_col0 / _col1) + type: double + expr: _col7 + type: tinyint + expr: _col8 + type: bigint + expr: (_col7 / ((- _col2) / (- 563))) + type: double + expr: (- (_col0 / _col1)) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22, _col23, _col24 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT AVG(cint), + (AVG(cint) + -3728), + (-((AVG(cint) + -3728))), + (-((-((AVG(cint) + -3728))))), + ((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)), + SUM(cdouble), + (-(AVG(cint))), + STDDEV_POP(cint), + (((-((-((AVG(cint) + -3728))))) * (AVG(cint) + -3728)) * (-((-((AVG(cint) + -3728)))))), + STDDEV_SAMP(csmallint), + (-(STDDEV_POP(cint))), + (STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))), + ((STDDEV_POP(cint) - (-((-((AVG(cint) + -3728)))))) * STDDEV_POP(cint)), + VAR_SAMP(cint), + AVG(cfloat), + (10.175 - VAR_SAMP(cint)), + (-((10.175 - VAR_SAMP(cint)))), + ((-(STDDEV_POP(cint))) / -563), + STDDEV_SAMP(cint), + (-(((-(STDDEV_POP(cint))) / -563))), + (AVG(cint) / SUM(cdouble)), + MIN(ctinyint), + COUNT(csmallint), + (MIN(ctinyint) / ((-(STDDEV_POP(cint))) / -563)), + (-((AVG(cint) / SUM(cdouble)))) +FROM alltypesorc +WHERE ((762 = cbigint) + OR ((csmallint < cfloat) + AND ((ctimestamp2 > -10669) + AND (cdouble != cint))) + OR (cstring1 = 'a') + OR ((cbigint <= -1.389) + AND ((cstring2 != 'a') + AND ((79.553 != cint) + AND (cboolean2 != cboolean1))))) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +1.3811354728837386E8 1.3810981928837386E8 -1.3810981928837386E8 1.3810981928837386E8 1.9074322183867284E16 -7194110.964000001 -1.3811354728837386E8 5.591531911809615E8 2.6343511898621314E24 8744.962036962406 -5.591531911809615E8 4.2104337189258766E8 2.35427745019332736E17 3.1277112522199501E17 -6.505246065861778 -3.1277112522199501E17 3.1277112522199501E17 993167.3022752424 5.592594435697935E8 -993167.3022752424 -19.198139697803782 -64 1858 -6.444030109869978E-5 19.198139697803782 +PREHOOK: query: -- TargetTypeClasses: Long, Bool, Double, String, Timestamp +-- Functions: Max, VarP, StDevP, Avg, Min, StDev, Var +-- ArithmeticOps: Divide, Multiply, Remainder, Subtract +-- FilterOps: LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))) +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Long, Bool, Double, String, Timestamp +-- Functions: Max, VarP, StDevP, Avg, Min, StDev, Var +-- ArithmeticOps: Divide, Multiply, Remainder, Subtract +-- FilterOps: LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (/ (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728))) (TOK_SELEXPR (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (% (- 563) (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (/ (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint)))) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint)))) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint)) 10.175)) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (% (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint)) 10.175))) (TOK_SELEXPR (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cdouble)))) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (% (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cdouble)) (- 26.28))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (/ (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (% (- (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728))) (% (- 563) (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728))))) (TOK_SELEXPR (- (/ (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)) (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)))) (TOK_SELEXPR (- (* (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)) (- 3728)))) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint)))) (TOK_WHERE (OR (OR (OR (AND (<= (TOK_TABLE_OR_COL cbigint) 197) (< (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint))) (AND (>= (TOK_TABLE_OR_COL cdouble) (- 26.28)) (> (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL cdouble)))) (AND (> (TOK_TABLE_OR_COL ctinyint) (TOK_TABLE_OR_COL cfloat)) (LIKE (TOK_TABLE_OR_COL cstring1) '%ss%'))) (AND (> (TOK_TABLE_OR_COL cfloat) 79.553) (LIKE (TOK_TABLE_OR_COL cstring2) '10%')))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (((((cbigint <= 197) and (cint < cbigint)) or ((cdouble >= (- 26.28)) and (csmallint > cdouble))) or ((ctinyint > cfloat) and (cstring1 like '%ss%'))) or ((cfloat > 79.553) and (cstring2 like '10%'))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cint + type: int + expr: cbigint + type: bigint + expr: csmallint + type: smallint + expr: cdouble + type: double + expr: ctinyint + type: tinyint + outputColumnNames: cint, cbigint, csmallint, cdouble, ctinyint + Vectorized execution: true + Group By Operator + aggregations: + expr: max(cint) + expr: var_pop(cbigint) + expr: stddev_pop(csmallint) + expr: max(cdouble) + expr: avg(ctinyint) + expr: min(cint) + expr: min(cdouble) + expr: stddev_samp(csmallint) + expr: var_samp(cint) + bucketGroup: false + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Vectorized execution: true + Reduce Output Operator + sort order: + tag: -1 + value expressions: + expr: _col0 + type: int + expr: _col1 + type: struct + expr: _col2 + type: struct + expr: _col3 + type: double + expr: _col4 + type: struct + expr: _col5 + type: int + expr: _col6 + type: double + expr: _col7 + type: struct + expr: _col8 + type: struct + Reduce Operator Tree: + Group By Operator + aggregations: + expr: max(VALUE._col0) + expr: var_pop(VALUE._col1) + expr: stddev_pop(VALUE._col2) + expr: max(VALUE._col3) + expr: avg(VALUE._col4) + expr: min(VALUE._col5) + expr: min(VALUE._col6) + expr: stddev_samp(VALUE._col7) + expr: var_samp(VALUE._col8) + bucketGroup: false + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Select Operator + expressions: + expr: _col0 + type: int + expr: (_col0 / (- 3728)) + type: double + expr: (_col0 * (- 3728)) + type: int + expr: _col1 + type: double + expr: (- (_col0 * (- 3728))) + type: int + expr: _col2 + type: double + expr: ((- 563) % (_col0 * (- 3728))) + type: int + expr: (_col1 / _col2) + type: double + expr: (- _col2) + type: double + expr: _col3 + type: double + expr: _col4 + type: double + expr: (_col2 - 10.175) + type: double + expr: _col5 + type: int + expr: ((_col0 * (- 3728)) % (_col2 - 10.175)) + type: double + expr: (- _col3) + type: double + expr: _col6 + type: double + expr: (_col3 % (- 26.28)) + type: double + expr: _col7 + type: double + expr: (- (_col0 / (- 3728))) + type: double + expr: ((- (_col0 * (- 3728))) % ((- 563) % (_col0 * (- 3728)))) + type: int + expr: ((_col0 / (- 3728)) - _col4) + type: double + expr: (- (_col0 * (- 3728))) + type: int + expr: _col8 + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT MAX(cint), + (MAX(cint) / -3728), + (MAX(cint) * -3728), + VAR_POP(cbigint), + (-((MAX(cint) * -3728))), + STDDEV_POP(csmallint), + (-563 % (MAX(cint) * -3728)), + (VAR_POP(cbigint) / STDDEV_POP(csmallint)), + (-(STDDEV_POP(csmallint))), + MAX(cdouble), + AVG(ctinyint), + (STDDEV_POP(csmallint) - 10.175), + MIN(cint), + ((MAX(cint) * -3728) % (STDDEV_POP(csmallint) - 10.175)), + (-(MAX(cdouble))), + MIN(cdouble), + (MAX(cdouble) % -26.28), + STDDEV_SAMP(csmallint), + (-((MAX(cint) / -3728))), + ((-((MAX(cint) * -3728))) % (-563 % (MAX(cint) * -3728))), + ((MAX(cint) / -3728) - AVG(ctinyint)), + (-((MAX(cint) * -3728))), + VAR_SAMP(cint) +FROM alltypesorc +WHERE (((cbigint <= 197) + AND (cint < cbigint)) + OR ((cdouble >= -26.28) + AND (csmallint > cdouble)) + OR ((ctinyint > cfloat) + AND (cstring1 LIKE '%ss%')) + OR ((cfloat > 79.553) + AND (cstring2 LIKE '10%'))) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +-20301111 5445.576984978541 -1626869520 7.9684972882908944E16 1626869520 NULL -563 NULL NULL NULL -8.935323383084578 NULL -1069736047 NULL NULL NULL NULL NULL -5445.576984978541 511 5454.512308361625 1626869520 7.2647256545687792E16 +PREHOOK: query: -- TargetTypeClasses: String, Long, Bool, Double, Timestamp +-- Functions: VarP, Count, Max, StDevP, StDev, Avg +-- ArithmeticOps: Subtract, Remainder, Multiply, Add +-- FilterOps: Equal, LessThanOrEqual, GreaterThan, Like, LessThan +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))) +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: String, Long, Bool, Double, Timestamp +-- Functions: VarP, Count, Max, StDevP, StDev, Avg +-- ArithmeticOps: Subtract, Remainder, Multiply, Add +-- FilterOps: Equal, LessThanOrEqual, GreaterThan, Like, LessThan +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)) (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (TOK_FUNCTIONSTAR COUNT)) (TOK_SELEXPR (% (TOK_FUNCTIONSTAR COUNT) 79.553)) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (- (TOK_FUNCTIONSTAR COUNT) (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (- (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (% (- 1) (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (TOK_FUNCTIONSTAR COUNT)) (TOK_SELEXPR (- (TOK_FUNCTIONSTAR COUNT))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (- (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)))))) (TOK_SELEXPR (* 762 (- (TOK_FUNCTIONSTAR COUNT)))) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (+ (TOK_FUNCTION MAX (TOK_TABLE_OR_COL ctinyint)) (* 762 (- (TOK_FUNCTIONSTAR COUNT))))) (TOK_SELEXPR (+ (- (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))) (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (% (- (TOK_FUNCTIONSTAR COUNT)) (TOK_FUNCTIONSTAR COUNT))) (TOK_SELEXPR (TOK_FUNCTION COUNT (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (% (- 3728) (+ (TOK_FUNCTION MAX (TOK_TABLE_OR_COL ctinyint)) (* 762 (- (TOK_FUNCTIONSTAR COUNT))))))) (TOK_WHERE (OR (OR (OR (OR (= (TOK_TABLE_OR_COL ctimestamp1) (TOK_TABLE_OR_COL ctimestamp2)) (= 762 (TOK_TABLE_OR_COL cfloat))) (= (TOK_TABLE_OR_COL cstring1) 'ss')) (AND (<= (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL cbigint)) (= 1 (TOK_TABLE_OR_COL cboolean2)))) (AND (TOK_FUNCTION TOK_ISNOTNULL (TOK_TABLE_OR_COL cboolean1)) (AND (TOK_FUNCTION TOK_ISNOTNULL (TOK_TABLE_OR_COL ctimestamp2)) (> (TOK_TABLE_OR_COL cstring2) 'a'))))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (((((ctimestamp1 = ctimestamp2) or (762.0 = cfloat)) or (cstring1 = 'ss')) or ((csmallint <= cbigint) and (1 = cboolean2))) or (cboolean1 is not null and (ctimestamp2 is not null and (cstring2 > 'a')))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cbigint + type: bigint + expr: ctinyint + type: tinyint + expr: csmallint + type: smallint + expr: cint + type: int + expr: cdouble + type: double + outputColumnNames: cbigint, ctinyint, csmallint, cint, cdouble + Vectorized execution: true + Group By Operator + aggregations: + expr: var_pop(cbigint) + expr: count() + expr: max(ctinyint) + expr: stddev_pop(csmallint) + expr: max(cint) + expr: stddev_samp(cdouble) + expr: count(ctinyint) + expr: avg(ctinyint) + bucketGroup: false + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Vectorized execution: true + Reduce Output Operator + sort order: + tag: -1 + value expressions: + expr: _col0 + type: struct + expr: _col1 + type: bigint + expr: _col2 + type: tinyint + expr: _col3 + type: struct + expr: _col4 + type: int + expr: _col5 + type: struct + expr: _col6 + type: bigint + expr: _col7 + type: struct + Reduce Operator Tree: + Group By Operator + aggregations: + expr: var_pop(VALUE._col0) + expr: count(VALUE._col1) + expr: max(VALUE._col2) + expr: stddev_pop(VALUE._col3) + expr: max(VALUE._col4) + expr: stddev_samp(VALUE._col5) + expr: count(VALUE._col6) + expr: avg(VALUE._col7) + bucketGroup: false + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Select Operator + expressions: + expr: _col0 + type: double + expr: (- _col0) + type: double + expr: (_col0 - (- _col0)) + type: double + expr: _col1 + type: bigint + expr: (_col1 % 79.553) + type: double + expr: _col2 + type: tinyint + expr: (_col1 - (- _col0)) + type: double + expr: (- (- _col0)) + type: double + expr: ((- 1) % (- _col0)) + type: double + expr: _col1 + type: bigint + expr: (- _col1) + type: bigint + expr: _col3 + type: double + expr: (- (- (- _col0))) + type: double + expr: (762 * (- _col1)) + type: bigint + expr: _col4 + type: int + expr: (_col2 + (762 * (- _col1))) + type: bigint + expr: ((- _col0) + _col4) + type: double + expr: _col5 + type: double + expr: ((- _col1) % _col1) + type: bigint + expr: _col6 + type: bigint + expr: _col7 + type: double + expr: ((- 3728) % (_col2 + (762 * (- _col1)))) + type: bigint + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT VAR_POP(cbigint), + (-(VAR_POP(cbigint))), + (VAR_POP(cbigint) - (-(VAR_POP(cbigint)))), + COUNT(*), + (COUNT(*) % 79.553), + MAX(ctinyint), + (COUNT(*) - (-(VAR_POP(cbigint)))), + (-((-(VAR_POP(cbigint))))), + (-1 % (-(VAR_POP(cbigint)))), + COUNT(*), + (-(COUNT(*))), + STDDEV_POP(csmallint), + (-((-((-(VAR_POP(cbigint))))))), + (762 * (-(COUNT(*)))), + MAX(cint), + (MAX(ctinyint) + (762 * (-(COUNT(*))))), + ((-(VAR_POP(cbigint))) + MAX(cint)), + STDDEV_SAMP(cdouble), + ((-(COUNT(*))) % COUNT(*)), + COUNT(ctinyint), + AVG(ctinyint), + (-3728 % (MAX(ctinyint) + (762 * (-(COUNT(*)))))) +FROM alltypesorc +WHERE ((ctimestamp1 = ctimestamp2) + OR (762 = cfloat) + OR (cstring1 = 'ss') + OR ((csmallint <= cbigint) + AND (1 = cboolean2)) + OR ((cboolean1 IS NOT NULL) + AND ((ctimestamp2 IS NOT NULL) + AND (cstring2 > 'a')))) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +2.5109214708345636E18 -2.5109214708345636E18 5.0218429416691272E18 2780 75.19800000000009 62 2.5109214708345661E18 2.5109214708345636E18 -1.0 2780 -2780 9460.675803068349 -2.5109214708345636E18 -2118360 1072872630 -2118298 -2.5109214697616911E18 185935.34910862707 0 758 -1.733509234828496 -3728 +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- TargetTypeClasses: String, Bool, Timestamp, Long, Double +-- Functions: Avg, Max, StDev, VarP +-- ArithmeticOps: Add, Divide, Remainder, Multiply +-- FilterOps: LessThanOrEqual, NotEqual, GreaterThanOrEqual, LessThan, Equal +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)) +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: String, Bool, Timestamp, Long, Double +-- Functions: Avg, Max, StDev, VarP +-- ArithmeticOps: Add, Divide, Remainder, Multiply +-- FilterOps: LessThanOrEqual, NotEqual, GreaterThanOrEqual, LessThan, Equal +-- GroupBy: NoGroupByProjectAggs +EXPLAIN SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) 6981)) (TOK_SELEXPR (+ (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) 6981) (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)))) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (/ (+ (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) 6981) (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint))) (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)))) (TOK_SELEXPR (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) 6981))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (% (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) (- (+ (TOK_FUNCTION AVG (TOK_TABLE_OR_COL ctinyint)) 6981)))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (/ (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cbigint))) (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (* (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)) (- 26.28)))) (TOK_WHERE (OR (OR (AND (<= (TOK_TABLE_OR_COL ctimestamp2) (TOK_TABLE_OR_COL ctimestamp1)) (AND (!= (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL cdouble)) (<= 'ss' (TOK_TABLE_OR_COL cstring1)))) (AND (< (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL ctinyint)) (>= (TOK_TABLE_OR_COL ctimestamp1) 0))) (= (TOK_TABLE_OR_COL cfloat) 17))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((((ctimestamp2 <= ctimestamp1) and ((cbigint <> cdouble) and ('ss' <= cstring1))) or ((csmallint < ctinyint) and (ctimestamp1 >= 0))) or (cfloat = 17.0)) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: ctinyint + type: tinyint + expr: cbigint + type: bigint + expr: cint + type: int + expr: cfloat + type: float + outputColumnNames: ctinyint, cbigint, cint, cfloat + Vectorized execution: true + Group By Operator + aggregations: + expr: avg(ctinyint) + expr: max(cbigint) + expr: stddev_samp(cint) + expr: var_pop(cint) + expr: var_pop(cbigint) + expr: max(cfloat) + bucketGroup: false + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Vectorized execution: true + Reduce Output Operator + sort order: + tag: -1 + value expressions: + expr: _col0 + type: struct + expr: _col1 + type: bigint + expr: _col2 + type: struct + expr: _col3 + type: struct + expr: _col4 + type: struct + expr: _col5 + type: float + Reduce Operator Tree: + Group By Operator + aggregations: + expr: avg(VALUE._col0) + expr: max(VALUE._col1) + expr: stddev_samp(VALUE._col2) + expr: var_pop(VALUE._col3) + expr: var_pop(VALUE._col4) + expr: max(VALUE._col5) + bucketGroup: false + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Operator + expressions: + expr: _col0 + type: double + expr: (_col0 + 6981) + type: double + expr: ((_col0 + 6981) + _col0) + type: double + expr: _col1 + type: bigint + expr: (((_col0 + 6981) + _col0) / _col0) + type: double + expr: (- (_col0 + 6981)) + type: double + expr: _col2 + type: double + expr: (_col0 % (- (_col0 + 6981))) + type: double + expr: _col3 + type: double + expr: _col4 + type: double + expr: (- _col1) + type: bigint + expr: ((- _col1) / _col2) + type: double + expr: _col5 + type: float + expr: (_col4 * (- 26.28)) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT AVG(ctinyint), + (AVG(ctinyint) + 6981), + ((AVG(ctinyint) + 6981) + AVG(ctinyint)), + MAX(cbigint), + (((AVG(ctinyint) + 6981) + AVG(ctinyint)) / AVG(ctinyint)), + (-((AVG(ctinyint) + 6981))), + STDDEV_SAMP(cint), + (AVG(ctinyint) % (-((AVG(ctinyint) + 6981)))), + VAR_POP(cint), + VAR_POP(cbigint), + (-(MAX(cbigint))), + ((-(MAX(cbigint))) / STDDEV_SAMP(cint)), + MAX(cfloat), + (VAR_POP(cbigint) * -26.28) +FROM alltypesorc +WHERE (((ctimestamp2 <= ctimestamp1) + AND ((cbigint != cdouble) + AND ('ss' <= cstring1))) + OR ((csmallint < ctinyint) + AND (ctimestamp1 >= 0)) + OR (cfloat = 17)) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +-0.5934409161894847 6980.406559083811 6979.813118167622 2141851355 -11761.597368421053 -6980.406559083811 1.5852855222071937E8 -0.5934409161894847 2.5099887741860852E16 1.52140608502098816E18 -2141851355 -13.510823917813237 79.553 -3.998255191435157E19 +PREHOOK: query: -- TargetTypeClasses: Timestamp, String, Long, Double, Bool +-- Functions: Max, Avg, Min, Var, StDev, Count, StDevP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide +-- FilterOps: Like, NotEqual, LessThan, GreaterThanOrEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))) +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Timestamp, String, Long, Double, Bool +-- Functions: Max, Avg, Min, Var, StDev, Count, StDevP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide +-- FilterOps: Like, NotEqual, LessThan, GreaterThanOrEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL cint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cdouble)) (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp2)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean2)) (TOK_SELEXPR (TOK_TABLE_OR_COL ctinyint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cfloat)) (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp1)) (TOK_SELEXPR (TOK_TABLE_OR_COL csmallint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cbigint)) (TOK_SELEXPR (* (- 3728) (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (- (- 863.257) (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL csmallint) (- (TOK_TABLE_OR_COL csmallint)))) (TOK_SELEXPR (+ (- (TOK_TABLE_OR_COL csmallint) (- (TOK_TABLE_OR_COL csmallint))) (- (TOK_TABLE_OR_COL csmallint)))) (TOK_SELEXPR (/ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (- (- (- 863.257) (TOK_TABLE_OR_COL cint)) (- 26.28))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (* (TOK_TABLE_OR_COL cdouble) (- 89010))) (TOK_SELEXPR (/ (TOK_TABLE_OR_COL ctinyint) 988888)) (TOK_SELEXPR (- (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (/ 79.553 (TOK_TABLE_OR_COL ctinyint)))) (TOK_WHERE (OR (OR (OR (AND (LIKE (TOK_TABLE_OR_COL cstring1) 'a%') (LIKE (TOK_TABLE_OR_COL cstring2) '%ss%')) (AND (!= 1 (TOK_TABLE_OR_COL cboolean2)) (AND (< (TOK_TABLE_OR_COL csmallint) 79.553) (!= (- 257) (TOK_TABLE_OR_COL ctinyint))))) (AND (> (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL ctinyint)) (>= (TOK_TABLE_OR_COL cfloat) (TOK_TABLE_OR_COL cint)))) (AND (< (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint)) (> (TOK_TABLE_OR_COL ctinyint) (TOK_TABLE_OR_COL cbigint))))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (((((cstring1 like 'a%') and (cstring2 like '%ss%')) or ((1 <> cboolean2) and ((csmallint < 79.553) and ((- 257) <> ctinyint)))) or ((cdouble > ctinyint) and (cfloat >= cint))) or ((cint < cbigint) and (ctinyint > cbigint))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cint + type: int + expr: cdouble + type: double + expr: ctimestamp2 + type: timestamp + expr: cstring1 + type: string + expr: cboolean2 + type: boolean + expr: ctinyint + type: tinyint + expr: cfloat + type: float + expr: ctimestamp1 + type: timestamp + expr: csmallint + type: smallint + expr: cbigint + type: bigint + expr: ((- 3728) * cbigint) + type: bigint + expr: (- cint) + type: int + expr: ((- 863.257) - cint) + type: double + expr: (- csmallint) + type: smallint + expr: (csmallint - (- csmallint)) + type: smallint + expr: ((csmallint - (- csmallint)) + (- csmallint)) + type: smallint + expr: (cint / cint) + type: double + expr: (((- 863.257) - cint) - (- 26.28)) + type: double + expr: (- cfloat) + type: float + expr: (cdouble * (- 89010)) + type: double + expr: (ctinyint / 988888) + type: double + expr: (- ctinyint) + type: tinyint + expr: (79.553 / ctinyint) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22 + Vectorized execution: true + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + Vectorized execution: true + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT cint, + cdouble, + ctimestamp2, + cstring1, + cboolean2, + ctinyint, + cfloat, + ctimestamp1, + csmallint, + cbigint, + (-3728 * cbigint), + (-(cint)), + (-863.257 - cint), + (-(csmallint)), + (csmallint - (-(csmallint))), + ((csmallint - (-(csmallint))) + (-(csmallint))), + (cint / cint), + ((-863.257 - cint) - -26.28), + (-(cfloat)), + (cdouble * -89010), + (ctinyint / 988888), + (-(ctinyint)), + (79.553 / ctinyint) +FROM alltypesorc +WHERE (((cstring1 LIKE 'a%') + AND (cstring2 LIKE '%ss%')) + OR ((1 != cboolean2) + AND ((csmallint < 79.553) + AND (-257 != ctinyint))) + OR ((cdouble > ctinyint) + AND (cfloat >= cint)) + OR ((cint < cbigint) + AND (ctinyint > cbigint))) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 16:00:05.478 -200 -1090414113 4065063813264 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 8 8.0 1969-12-31 15:59:46.007 -200 -1236645308 4610213708224 NULL NULL 200 -400 -200 NULL NULL -8.0 1.7802E7 8.08989491226509E-6 -8 9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 15:59:44.842 -200 -815881183 3041605050224 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 24 24.0 1969-12-31 15:59:44.55 -200 -499521357 1862215618896 NULL NULL 200 -400 -200 NULL NULL -24.0 1.7802E7 2.426968473679527E-5 -24 3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.0 1969-12-31 16:00:14.985 -200 384222326 -1432380831328 NULL NULL 200 -400 -200 NULL NULL 1.0 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -39 -39.0 1969-12-31 16:00:13.092 -200 -1111142796 4142340343488 NULL NULL 200 -400 -200 NULL NULL 39.0 1.7802E7 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:10.436 -200 -998574307 3722685016496 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 16:00:02.208 -200 1043214022 -3889101874016 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -12 -12.0 1969-12-31 15:59:58.305 -200 -997940806 3720323324768 NULL NULL 200 -400 -200 NULL NULL 12.0 1.7802E7 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 46 46.0 1969-12-31 15:59:54.016 -200 -517349302 1928678197856 NULL NULL 200 -400 -200 NULL NULL -46.0 1.7802E7 4.651689574552426E-5 -46 1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 15:59:57.847 -200 1819421386 -6782802927008 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -20 -20.0 1969-12-31 15:59:49.764 -200 1115401141 -4158215453648 NULL NULL 200 -400 -200 NULL NULL 20.0 1.7802E7 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -17 -17.0 1969-12-31 15:59:51.417 -200 1806593648 -6734981119744 NULL NULL 200 -400 -200 NULL NULL 17.0 1.7802E7 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 60 60.0 1969-12-31 15:59:51.342 -200 1981140540 -7385691933120 NULL NULL 200 -400 -200 NULL NULL -60.0 1.7802E7 6.0674211841988174E-5 -60 1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -55 -55.0 1969-12-31 16:00:08.896 -200 862778898 -3216439731744 NULL NULL 200 -400 -200 NULL NULL 55.0 1.7802E7 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 15:59:47.263 -200 -1100744431 4103575238768 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 16:00:11.883 -200 -1874590290 6988472601120 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 16:00:01.901 -200 1026696124 -3827523150272 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -22 -22.0 1969-12-31 15:59:53.476 -200 150711504 -561852486912 NULL NULL 200 -400 -200 NULL NULL 22.0 1.7802E7 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 16:00:15.861 -200 254419828 -948477118784 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:05.562 -200 -859908363 3205738377264 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 6 6.0 1969-12-31 16:00:07.713 -200 -605449705 2257116500240 NULL NULL 200 -400 -200 NULL NULL -6.0 1.7802E7 6.067421184198818E-6 -6 13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 15:59:44.289 -200 1713733703 -6388799244784 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 15:59:56.217 -200 -1595717723 5948835671344 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -13 -13.0 1969-12-31 15:59:50.858 -200 -519278910 1935871776480 NULL NULL 200 -400 -200 NULL NULL 13.0 1.7802E7 -1.314607923243077E-5 13 -6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 16:00:01.27 -200 -1116511205 4162353772240 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -47 -47.0 1969-12-31 16:00:08.091 -200 1769663274 -6597304685472 NULL NULL 200 -400 -200 NULL NULL 47.0 1.7802E7 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 19 19.0 1969-12-31 15:59:56.099 -200 1490159561 -5555314843408 NULL NULL 200 -400 -200 NULL NULL -19.0 1.7802E7 1.921350041662959E-5 -19 4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 15:59:52.751 -200 1918188607 -7151007126896 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 25 25.0 1969-12-31 15:59:53.743 -200 1861913153 -6941212234384 NULL NULL 200 -400 -200 NULL NULL -25.0 1.7802E7 2.5280921600828406E-5 -25 3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 18 18.0 1969-12-31 16:00:15.89 -200 1994361829 -7434980898512 NULL NULL 200 -400 -200 NULL NULL -18.0 1.7802E7 1.820226355259645E-5 -18 4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -29 -29.0 1969-12-31 15:59:57.882 -200 1896458939 -7069998924592 NULL NULL 200 -400 -200 NULL NULL 29.0 1.7802E7 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -22 -22.0 1969-12-31 16:00:05.218 -200 929143703 -3463847724784 NULL NULL 200 -400 -200 NULL NULL 22.0 1.7802E7 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 16:00:04.024 -200 741404204 -2763954872512 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 15:59:44.453 -200 -1624098865 6054640568720 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -55 -55.0 1969-12-31 16:00:08.229 -200 -1238304032 4616397431296 NULL NULL 200 -400 -200 NULL NULL 55.0 1.7802E7 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 16:00:12.574 -200 593383941 -2212135332048 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -14 -14.0 1969-12-31 15:59:58.148 -200 -1449446580 5403536850240 NULL NULL 200 -400 -200 NULL NULL 14.0 1.7802E7 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -29 -29.0 1969-12-31 15:59:46.536 -200 1674924283 -6244117727024 NULL NULL 200 -400 -200 NULL NULL 29.0 1.7802E7 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 16:00:10.953 -200 -483910982 1804020140896 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 46 46.0 1969-12-31 16:00:09.883 -200 -436888437 1628720093136 NULL NULL 200 -400 -200 NULL NULL -46.0 1.7802E7 4.651689574552426E-5 -46 1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 15:59:51.43 -200 818800198 -3052487138144 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -33 -33.0 1969-12-31 15:59:55.755 -200 -567292357 2114865906896 NULL NULL 200 -400 -200 NULL NULL 33.0 1.7802E7 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -38 -38.0 1969-12-31 15:59:56.769 -200 450485340 -1679409347520 NULL NULL 200 -400 -200 NULL NULL 38.0 1.7802E7 -3.842700083325918E-5 38 -2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 15:59:46.449 -200 -689001045 2568595895760 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -50 -50.0 1969-12-31 16:00:13.253 -200 594977020 -2218074330560 NULL NULL 200 -400 -200 NULL NULL 50.0 1.7802E7 -5.056184320165681E-5 50 -1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 39 39.0 1969-12-31 15:59:46.368 -200 112950540 -421079613120 NULL NULL 200 -400 -200 NULL NULL -39.0 1.7802E7 3.9438237697292314E-5 -39 2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 15:59:53.592 -200 1922447714 -7166885077792 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:13.411 -200 -915644003 3413520843184 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 16:00:15.143 -200 -2109772858 7865233214624 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 12 12.0 1969-12-31 16:00:08.34 -200 -860934589 3209564147792 NULL NULL 200 -400 -200 NULL NULL -12.0 1.7802E7 1.2134842368397635E-5 -12 6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 24 24.0 1969-12-31 15:59:58.788 -200 805287817 -3002112981776 NULL NULL 200 -400 -200 NULL NULL -24.0 1.7802E7 2.426968473679527E-5 -24 3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:08.346 -200 -1635566862 6097393261536 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.0 1969-12-31 15:59:57.901 -200 -250915199 935411861872 NULL NULL 200 -400 -200 NULL NULL 1.0 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -38 -38.0 1969-12-31 16:00:14.118 -200 1741347818 -6491744665504 NULL NULL 200 -400 -200 NULL NULL 38.0 1.7802E7 -3.842700083325918E-5 38 -2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -46 -46.0 1969-12-31 15:59:57.646 -200 -624367772 2327643054016 NULL NULL 200 -400 -200 NULL NULL 46.0 1.7802E7 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 16:00:06.777 -200 -836004666 3116625394848 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:12.112 -200 1395869317 -5203800813776 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 15:59:45.722 -200 -2069085175 7713549532400 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 46 46.0 1969-12-31 15:59:56.163 -200 -1275647301 4755613138128 NULL NULL 200 -400 -200 NULL NULL -46.0 1.7802E7 4.651689574552426E-5 -46 1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:11.15 -200 -834308521 3110302166288 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 15:59:53.06 -200 -1958596195 7301646614960 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -45 -45.0 1969-12-31 16:00:00.287 -200 -1919463631 7155760416368 NULL NULL 200 -400 -200 NULL NULL 45.0 1.7802E7 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 37 37.0 1969-12-31 15:59:58.129 -200 1838442362 -6853713125536 NULL NULL 200 -400 -200 NULL NULL -37.0 1.7802E7 3.741576396922604E-5 -37 2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -41 -41.0 1969-12-31 15:59:44.38 -200 -688353943 2566183499504 NULL NULL 200 -400 -200 NULL NULL 41.0 1.7802E7 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -44 -44.0 1969-12-31 16:00:00.835 -200 1814766708 -6765450287424 NULL NULL 200 -400 -200 NULL NULL 44.0 1.7802E7 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 16:00:03.571 -200 953305450 -3553922717600 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 13 13.0 1969-12-31 16:00:03.794 -200 894634621 -3335197867088 NULL NULL 200 -400 -200 NULL NULL -13.0 1.7802E7 1.314607923243077E-5 -13 6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 19 19.0 1969-12-31 16:00:10.723 -200 1604152041 -5980278808848 NULL NULL 200 -400 -200 NULL NULL -19.0 1.7802E7 1.921350041662959E-5 -19 4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 62 62.0 1969-12-31 15:59:46.137 -200 -1332297900 4966806571200 NULL NULL 200 -400 -200 NULL NULL -62.0 1.7802E7 6.269668557005445E-5 -62 1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -46 -46.0 1969-12-31 15:59:49.331 -200 -2034715106 7585417915168 NULL NULL 200 -400 -200 NULL NULL 46.0 1.7802E7 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -25 -25.0 1969-12-31 15:59:48.372 -200 1516831554 -5654748033312 NULL NULL 200 -400 -200 NULL NULL 25.0 1.7802E7 -2.5280921600828406E-5 25 -3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 39 39.0 1969-12-31 16:00:00.395 -200 -899658844 3353928170432 NULL NULL 200 -400 -200 NULL NULL -39.0 1.7802E7 3.9438237697292314E-5 -39 2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 43 43.0 1969-12-31 16:00:01.097 -200 -781919048 2914994210944 NULL NULL 200 -400 -200 NULL NULL -43.0 1.7802E7 4.3483185153424856E-5 -43 1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -42 -42.0 1969-12-31 15:59:54.349 -200 -390050457 1454108103696 NULL NULL 200 -400 -200 NULL NULL 42.0 1.7802E7 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 15:59:47.952 -200 -449401470 1675368680160 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 10 10.0 1969-12-31 16:00:07.365 -200 120165080 -447975418240 NULL NULL 200 -400 -200 NULL NULL -10.0 1.7802E7 1.0112368640331362E-5 -10 7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 15:59:47.828 -200 -715660733 2667983212624 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 16:00:00.951 -200 454239730 -1693405713440 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 15:59:48.367 -200 1709812289 -6374180213392 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -57 -57.0 1969-12-31 16:00:02.707 -200 1382057278 -5152309532384 NULL NULL 200 -400 -200 NULL NULL 57.0 1.7802E7 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -25 -25.0 1969-12-31 15:59:49.293 -200 -776497113 2894781237264 NULL NULL 200 -400 -200 NULL NULL 25.0 1.7802E7 -2.5280921600828406E-5 25 -3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 16:00:15.609 -200 -1775354211 6618520498608 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -51 -51.0 1969-12-31 16:00:12.494 -200 -413063757 1539901686096 NULL NULL 200 -400 -200 NULL NULL 51.0 1.7802E7 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:14.071 -200 -378947821 1412717476688 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 41 41.0 1969-12-31 16:00:08.408 -200 696650264 -2597112184192 NULL NULL 200 -400 -200 NULL NULL -41.0 1.7802E7 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 39 39.0 1969-12-31 16:00:07.541 -200 260798405 -972256453840 NULL NULL 200 -400 -200 NULL NULL -39.0 1.7802E7 3.9438237697292314E-5 -39 2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:10.211 -200 -885770465 3302152293520 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -24 -24.0 1969-12-31 15:59:54.075 -200 191358485 -713384432080 NULL NULL 200 -400 -200 NULL NULL 24.0 1.7802E7 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 56 56.0 1969-12-31 15:59:57.56 -200 951463637 -3547056438736 NULL NULL 200 -400 -200 NULL NULL -56.0 1.7802E7 5.6629264385855625E-5 -56 1.4205892857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -21 -21.0 1969-12-31 16:00:09.182 -200 1367877440 -5099447096320 NULL NULL 200 -400 -200 NULL NULL 21.0 1.7802E7 -2.123597414469586E-5 21 -3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 58 58.0 1969-12-31 15:59:45.489 -200 1300104054 -4846787913312 NULL NULL 200 -400 -200 NULL NULL -58.0 1.7802E7 5.86517381139219E-5 -58 1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 41 41.0 1969-12-31 16:00:07.175 -200 1542568556 -5750695576768 NULL NULL 200 -400 -200 NULL NULL -41.0 1.7802E7 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.0 1969-12-31 16:00:04.836 -200 480523197 -1791390478416 NULL NULL 200 -400 -200 NULL NULL 1.0 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 21 21.0 1969-12-31 16:00:08.048 -200 261543399 -975033791472 NULL NULL 200 -400 -200 NULL NULL -21.0 1.7802E7 2.123597414469586E-5 -21 3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -61 -61.0 1969-12-31 16:00:04.165 -200 -1313743110 4897634314080 NULL NULL 200 -400 -200 NULL NULL 61.0 1.7802E7 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 35 35.0 1969-12-31 16:00:09.892 -200 -197916286 737831914208 NULL NULL 200 -400 -200 NULL NULL -35.0 1.7802E7 3.5393290241159765E-5 -35 2.272942857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -48 -48.0 1969-12-31 15:59:55.023 -200 17520444 -65316215232 NULL NULL 200 -400 -200 NULL NULL 48.0 1.7802E7 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -14 -14.0 1969-12-31 15:59:44.457 -200 1678325085 -6256795916880 NULL NULL 200 -400 -200 NULL NULL 14.0 1.7802E7 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 54 54.0 1969-12-31 16:00:10.187 -200 829351969 -3091824140432 NULL NULL 200 -400 -200 NULL NULL -54.0 1.7802E7 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 15:59:57.245 -200 1713760992 -6388900978176 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 53 53.0 1969-12-31 16:00:15.401 -200 -549903001 2050038387728 NULL NULL 200 -400 -200 NULL NULL -53.0 1.7802E7 5.359555379375622E-5 -53 1.501 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -58 -58.0 1969-12-31 15:59:54.484 -200 1126209929 -4198510615312 NULL NULL 200 -400 -200 NULL NULL 58.0 1.7802E7 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 15:59:53.898 -200 -1597851253 5956789471184 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 16:00:02 -200 678949554 -2531123937312 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -26 -26.0 1969-12-31 16:00:14.191 -200 1050415040 -3915947269120 NULL NULL 200 -400 -200 NULL NULL 26.0 1.7802E7 -2.629215846486154E-5 26 -3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -5 -5.0 1969-12-31 15:59:57.794 -200 205645723 -766647255344 NULL NULL 200 -400 -200 NULL NULL 5.0 1.7802E7 -5.056184320165681E-6 5 -15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 16:00:09.364 -200 -291569870 1086972475360 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 15:59:57.543 -200 1053538728 -3927592377984 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 20 20.0 1969-12-31 15:59:55.056 -200 -1403730664 5233107915392 NULL NULL 200 -400 -200 NULL NULL -20.0 1.7802E7 2.0224737280662725E-5 -20 3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 26 26.0 1969-12-31 16:00:00.923 -200 -1387364200 5172093737600 NULL NULL 200 -400 -200 NULL NULL -26.0 1.7802E7 2.629215846486154E-5 -26 3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -49 -49.0 1969-12-31 16:00:01.458 -200 -658701811 2455640351408 NULL NULL 200 -400 -200 NULL NULL 49.0 1.7802E7 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 15:59:44.297 -200 2120344258 -7904643393824 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -58 -58.0 1969-12-31 15:59:47.24 -200 1257221099 -4686920257072 NULL NULL 200 -400 -200 NULL NULL 58.0 1.7802E7 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -14 -14.0 1969-12-31 16:00:08.704 -200 1471532162 -5485871899936 NULL NULL 200 -400 -200 NULL NULL 14.0 1.7802E7 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 45 45.0 1969-12-31 16:00:04.572 -200 612900585 -2284893380880 NULL NULL 200 -400 -200 NULL NULL -45.0 1.7802E7 4.550565888149113E-5 -45 1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -63 -63.0 1969-12-31 16:00:01.843 -200 -1999307539 7453418505392 NULL NULL 200 -400 -200 NULL NULL 63.0 1.7802E7 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:01.764 -200 -2020595716 7532780829248 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -26 -26.0 1969-12-31 15:59:50.573 -200 -1087207614 4053109984992 NULL NULL 200 -400 -200 NULL NULL 26.0 1.7802E7 -2.629215846486154E-5 26 -3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 16:00:06.3 -200 57986729 -216174525712 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 46 46.0 1969-12-31 15:59:46.028 -200 14115102 -52621100256 NULL NULL 200 -400 -200 NULL NULL -46.0 1.7802E7 4.651689574552426E-5 -46 1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 15:59:57.953 -200 -30844955 114989992240 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 6 6.0 1969-12-31 16:00:13.132 -200 883917228 -3295243425984 NULL NULL 200 -400 -200 NULL NULL -6.0 1.7802E7 6.067421184198818E-6 -6 13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 2 2.0 1969-12-31 15:59:46.893 -200 1767035977 -6587510122256 NULL NULL 200 -400 -200 NULL NULL -2.0 1.7802E7 2.0224737280662724E-6 -2 39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:10.701 -200 142612225 -531658374800 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 15:59:47.921 -200 505653702 -1885077001056 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 15:59:48.452 -200 -899919510 3354899933280 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 41 41.0 1969-12-31 16:00:09.951 -200 -1973152486 7355912467808 NULL NULL 200 -400 -200 NULL NULL -41.0 1.7802E7 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 2 2.0 1969-12-31 16:00:02.752 -200 1107543828 -4128923390784 NULL NULL 200 -400 -200 NULL NULL -2.0 1.7802E7 2.0224737280662724E-6 -2 39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 6 6.0 1969-12-31 15:59:57.568 -200 559133030 -2084447935840 NULL NULL 200 -400 -200 NULL NULL -6.0 1.7802E7 6.067421184198818E-6 -6 13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 39 39.0 1969-12-31 16:00:12.557 -200 -1811991294 6755103544032 NULL NULL 200 -400 -200 NULL NULL -39.0 1.7802E7 3.9438237697292314E-5 -39 2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -33 -33.0 1969-12-31 16:00:08.046 -200 281060243 -1047792585904 NULL NULL 200 -400 -200 NULL NULL 33.0 1.7802E7 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 40 40.0 1969-12-31 15:59:55.197 -200 1958187727 -7300123846256 NULL NULL 200 -400 -200 NULL NULL -40.0 1.7802E7 4.044947456132545E-5 -40 1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 15:59:57.528 -200 1172431520 -4370824706560 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -61 -61.0 1969-12-31 15:59:52.066 -200 623787602 -2325480180256 NULL NULL 200 -400 -200 NULL NULL 61.0 1.7802E7 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 45 45.0 1969-12-31 15:59:56.055 -200 -1251321575 4664926831600 NULL NULL 200 -400 -200 NULL NULL -45.0 1.7802E7 4.550565888149113E-5 -45 1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:16.07 -200 1778714378 -6631047201184 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 58 58.0 1969-12-31 16:00:11.449 -200 -2045923021 7627201022288 NULL NULL 200 -400 -200 NULL NULL -58.0 1.7802E7 5.86517381139219E-5 -58 1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:00.621 -200 930659178 -3469497415584 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -52 -52.0 1969-12-31 16:00:01.289 -200 -1407220579 5246118318512 NULL NULL 200 -400 -200 NULL NULL 52.0 1.7802E7 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 15:59:51.788 -200 1394914812 -5200242419136 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 56 56.0 1969-12-31 16:00:16.056 -200 -72311778 269578308384 NULL NULL 200 -400 -200 NULL NULL -56.0 1.7802E7 5.6629264385855625E-5 -56 1.4205892857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -22 -22.0 1969-12-31 16:00:12.901 -200 486263371 -1812789847088 NULL NULL 200 -400 -200 NULL NULL 22.0 1.7802E7 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 24 24.0 1969-12-31 16:00:01.369 -200 -1719521942 6410377799776 NULL NULL 200 -400 -200 NULL NULL -24.0 1.7802E7 2.426968473679527E-5 -24 3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 53 53.0 1969-12-31 15:59:45.074 -200 -1405259747 5238808336816 NULL NULL 200 -400 -200 NULL NULL -53.0 1.7802E7 5.359555379375622E-5 -53 1.501 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -44 -44.0 1969-12-31 16:00:03.357 -200 1980863657 -7384659713296 NULL NULL 200 -400 -200 NULL NULL 44.0 1.7802E7 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 15:59:55.043 -200 82971673 -309318396944 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 16:00:00.019 -200 1070083402 -3989270922656 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -33 -33.0 1969-12-31 15:59:45.1 -200 -375567961 1400117358608 NULL NULL 200 -400 -200 NULL NULL 33.0 1.7802E7 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -42 -42.0 1969-12-31 16:00:09.72 -200 -75032821 279722356688 NULL NULL 200 -400 -200 NULL NULL 42.0 1.7802E7 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 21 21.0 1969-12-31 16:00:12.52 -200 -1063757589 3965688291792 NULL NULL 200 -400 -200 NULL NULL -21.0 1.7802E7 2.123597414469586E-5 -21 3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 16:00:08.234 -200 -1455850339 5427410063792 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 16:00:04.997 -200 -1166027011 4346948697008 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 16:00:00.563 -200 2051685271 -7648682690288 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -27 -27.0 1969-12-31 15:59:53.546 -200 -499602601 1862518496528 NULL NULL 200 -400 -200 NULL NULL 27.0 1.7802E7 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:09.842 -200 615107644 -2293121296832 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 16:00:05.495 -200 377656757 -1407904390096 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -15 -15.0 1969-12-31 16:00:13.438 -200 1702277036 -6346088790208 NULL NULL 200 -400 -200 NULL NULL 15.0 1.7802E7 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 16:00:00.158 -200 -1439705824 5367223311872 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -45 -45.0 1969-12-31 16:00:02.814 -200 771908206 -2877673791968 NULL NULL 200 -400 -200 NULL NULL 45.0 1.7802E7 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 55 55.0 1969-12-31 16:00:14.709 -200 529159242 -1972705654176 NULL NULL 200 -400 -200 NULL NULL -55.0 1.7802E7 5.561802752182249E-5 -55 1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 6 6.0 1969-12-31 15:59:57.47 -200 -1169269094 4359035182432 NULL NULL 200 -400 -200 NULL NULL -6.0 1.7802E7 6.067421184198818E-6 -6 13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -55 -55.0 1969-12-31 16:00:03.737 -200 -955056279 3560449808112 NULL NULL 200 -400 -200 NULL NULL 55.0 1.7802E7 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 60 60.0 1969-12-31 15:59:47.019 -200 -2132232110 7948961306080 NULL NULL 200 -400 -200 NULL NULL -60.0 1.7802E7 6.0674211841988174E-5 -60 1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 15:59:44.922 -200 -596995850 2225600528800 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -7 -7.0 1969-12-31 16:00:15.593 -200 -337718648 1259015119744 NULL NULL 200 -400 -200 NULL NULL 7.0 1.7802E7 -7.078658048231953E-6 7 -11.364714285714285 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 45 45.0 1969-12-31 16:00:11.443 -200 -122450 456493600 NULL NULL 200 -400 -200 NULL NULL -45.0 1.7802E7 4.550565888149113E-5 -45 1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 51 51.0 1969-12-31 16:00:00.147 -200 908074420 -3385301437760 NULL NULL 200 -400 -200 NULL NULL -51.0 1.7802E7 5.157308006568995E-5 -51 1.5598627450980391 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 16:00:07.675 -200 99645480 -371478349440 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 15:59:47.066 -200 1361253497 -5074753036816 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 1 1.0 1969-12-31 15:59:46.29 -200 1968356628 -7338033509184 NULL NULL 200 -400 -200 NULL NULL -1.0 1.7802E7 1.0112368640331362E-6 -1 79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 42 42.0 1969-12-31 16:00:00.11 -200 1303413031 -4859123779568 NULL NULL 200 -400 -200 NULL NULL -42.0 1.7802E7 4.247194828939172E-5 -42 1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 15:59:54.522 -200 -1369228515 5104483903920 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -61 -61.0 1969-12-31 15:59:47.034 -200 1399483216 -5217273429248 NULL NULL 200 -400 -200 NULL NULL 61.0 1.7802E7 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 11 11.0 1969-12-31 16:00:14.569 -200 -62618517 233441831376 NULL NULL 200 -400 -200 NULL NULL -11.0 1.7802E7 1.1123605504364498E-5 -11 7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:13.835 -200 -139835037 521305017936 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 21 21.0 1969-12-31 16:00:13.153 -200 1469053701 -5476632197328 NULL NULL 200 -400 -200 NULL NULL -21.0 1.7802E7 2.123597414469586E-5 -21 3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 15:59:43.952 -200 -753159604 2807779003712 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 16:00:08.882 -200 -1036428824 3863806655872 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:13.008 -200 -1570844365 5856107792720 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -32 -32.0 1969-12-31 15:59:47.69 -200 -679776976 2534208566528 NULL NULL 200 -400 -200 NULL NULL 32.0 1.7802E7 -3.235957964906036E-5 32 -2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 35 35.0 1969-12-31 16:00:08.37 -200 -258891336 965146900608 NULL NULL 200 -400 -200 NULL NULL -35.0 1.7802E7 3.5393290241159765E-5 -35 2.272942857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -26 -26.0 1969-12-31 15:59:54.866 -200 -281746185 1050349777680 NULL NULL 200 -400 -200 NULL NULL 26.0 1.7802E7 -2.629215846486154E-5 26 -3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -50 -50.0 1969-12-31 16:00:04.696 -200 -144798360 539808286080 NULL NULL 200 -400 -200 NULL NULL 50.0 1.7802E7 -5.056184320165681E-5 50 -1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -36 -36.0 1969-12-31 16:00:15.111 -200 -817680514 3048312956192 NULL NULL 200 -400 -200 NULL NULL 36.0 1.7802E7 -3.64045271051929E-5 36 -2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 15:59:58.298 -200 927442664 -3457506251392 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 15:59:44.052 -200 -74396507 277350178096 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.0 1969-12-31 15:59:58.26 -200 -830447528 3095908384384 NULL NULL 200 -400 -200 NULL NULL 1.0 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:02.234 -200 1539182778 -5738073396384 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 24 24.0 1969-12-31 15:59:53.052 -200 821428066 -3062283830048 NULL NULL 200 -400 -200 NULL NULL -24.0 1.7802E7 2.426968473679527E-5 -24 3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 16:00:05.369 -200 1700360415 -6338943627120 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 16:00:06.256 -200 -1558297670 5809333713760 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 16:00:04.228 -200 977627069 -3644593713232 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 16:00:15.296 -200 165384922 -616554989216 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -12 -12.0 1969-12-31 16:00:15.749 -200 -1476740834 5505289829152 NULL NULL 200 -400 -200 NULL NULL 12.0 1.7802E7 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 15:59:44.289 -200 -1197793261 4465373277008 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 37 37.0 1969-12-31 15:59:51.566 -200 1829107401 -6818912390928 NULL NULL 200 -400 -200 NULL NULL -37.0 1.7802E7 3.741576396922604E-5 -37 2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 15:59:45.107 -200 1565121976 -5834774726528 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 15:59:49.489 -200 1531926845 -5711023278160 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 8 8.0 1969-12-31 15:59:57.063 -200 1430481343 -5332834446704 NULL NULL 200 -400 -200 NULL NULL -8.0 1.7802E7 8.08989491226509E-6 -8 9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 15:59:48.017 -200 428518739 -1597517858992 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -63 -63.0 1969-12-31 16:00:10.205 -200 -997946077 3720342975056 NULL NULL 200 -400 -200 NULL NULL 63.0 1.7802E7 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 3 3.0 1969-12-31 16:00:00.074 -200 162573978 -606075789984 NULL NULL 200 -400 -200 NULL NULL -3.0 1.7802E7 3.033710592099409E-6 -3 26.517666666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -31 -31.0 1969-12-31 15:59:48.152 -200 -1690447990 6301990106720 NULL NULL 200 -400 -200 NULL NULL 31.0 1.7802E7 -3.134834278502722E-5 31 -2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 23 23.0 1969-12-31 15:59:44.772 -200 752628842 -2805800322976 NULL NULL 200 -400 -200 NULL NULL -23.0 1.7802E7 2.325844787276213E-5 -23 3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -26 -26.0 1969-12-31 15:59:56.426 -200 -240265414 895709463392 NULL NULL 200 -400 -200 NULL NULL 26.0 1.7802E7 -2.629215846486154E-5 26 -3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 15:59:57.269 -200 1170453302 -4363449909856 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -52 -52.0 1969-12-31 15:59:45.644 -200 116461878 -434169881184 NULL NULL 200 -400 -200 NULL NULL 52.0 1.7802E7 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 39 39.0 1969-12-31 16:00:02.804 -200 1368309884 -5101059247552 NULL NULL 200 -400 -200 NULL NULL -39.0 1.7802E7 3.9438237697292314E-5 -39 2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 62 62.0 1969-12-31 15:59:48.815 -200 -701191108 2614040450624 NULL NULL 200 -400 -200 NULL NULL -62.0 1.7802E7 6.269668557005445E-5 -62 1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -2 -2.0 1969-12-31 16:00:11.181 -200 -925105543 3448793464304 NULL NULL 200 -400 -200 NULL NULL 2.0 1.7802E7 -2.0224737280662724E-6 2 -39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 60 60.0 1969-12-31 15:59:55.035 -200 1810792403 -6750634078384 NULL NULL 200 -400 -200 NULL NULL -60.0 1.7802E7 6.0674211841988174E-5 -60 1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -37 -37.0 1969-12-31 16:00:14.662 -200 980008876 -3653473089728 NULL NULL 200 -400 -200 NULL NULL 37.0 1.7802E7 -3.741576396922604E-5 37 -2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 16:00:10.485 -200 325025905 -1211696573840 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -14 -14.0 1969-12-31 16:00:16.274 -200 -1448350434 5399450417952 NULL NULL 200 -400 -200 NULL NULL 14.0 1.7802E7 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -2 -2.0 1969-12-31 16:00:11.494 -200 841969908 -3138863817024 NULL NULL 200 -400 -200 NULL NULL 2.0 1.7802E7 -2.0224737280662724E-6 2 -39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -3 -3.0 1969-12-31 15:59:57.237 -200 -780159920 2908436181760 NULL NULL 200 -400 -200 NULL NULL 3.0 1.7802E7 -3.033710592099409E-6 3 -26.517666666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -36 -36.0 1969-12-31 15:59:53.817 -200 1599879000 -5964348912000 NULL NULL 200 -400 -200 NULL NULL 36.0 1.7802E7 -3.64045271051929E-5 36 -2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -40 -40.0 1969-12-31 15:59:46.148 -200 -1741735436 6493189705408 NULL NULL 200 -400 -200 NULL NULL 40.0 1.7802E7 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -50 -50.0 1969-12-31 15:59:52.202 -200 68053173 -253702228944 NULL NULL 200 -400 -200 NULL NULL 50.0 1.7802E7 -5.056184320165681E-5 50 -1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -15 -15.0 1969-12-31 15:59:45.322 -200 -1289952980 4808944709440 NULL NULL 200 -400 -200 NULL NULL 15.0 1.7802E7 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -48 -48.0 1969-12-31 16:00:00.96 -200 -2095298312 7811272107136 NULL NULL 200 -400 -200 NULL NULL 48.0 1.7802E7 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -40 -40.0 1969-12-31 15:59:57.942 -200 1122556805 -4184891769040 NULL NULL 200 -400 -200 NULL NULL 40.0 1.7802E7 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 16:00:06.776 -200 -1242610289 4632451157392 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 16:00:02.58 -200 1380986666 -5148318290848 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 15:59:47.712 -200 -60966612 227283529536 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 79.553 1969-12-31 16:00:04.568 -200 -787452001 2935621059728 NULL NULL 200 -400 -200 NULL NULL -79.553 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 16:00:01.515 -200 1221804187 -4554886009136 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -44 -44.0 1969-12-31 16:00:14.848 -200 1075499932 -4009463746496 NULL NULL 200 -400 -200 NULL NULL 44.0 1.7802E7 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 12 12.0 1969-12-31 16:00:12.772 -200 987273431 -3680555350768 NULL NULL 200 -400 -200 NULL NULL -12.0 1.7802E7 1.2134842368397635E-5 -12 6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -11 -11.0 1969-12-31 15:59:48.368 -200 -1894580211 7062995026608 NULL NULL 200 -400 -200 NULL NULL 11.0 1.7802E7 -1.1123605504364498E-5 11 -7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -8 -8.0 1969-12-31 16:00:08.007 -200 1525511816 -5687108050048 NULL NULL 200 -400 -200 NULL NULL 8.0 1.7802E7 -8.08989491226509E-6 8 -9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 40 40.0 1969-12-31 16:00:01.356 -200 1778581609 -6630552238352 NULL NULL 200 -400 -200 NULL NULL -40.0 1.7802E7 4.044947456132545E-5 -40 1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 15:59:50.905 -200 681143255 -2539302054640 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 15:59:48.698 -200 1546508645 -5765384228560 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -32 -32.0 1969-12-31 15:59:45.137 -200 684628920 -2552296613760 NULL NULL 200 -400 -200 NULL NULL 32.0 1.7802E7 -3.235957964906036E-5 32 -2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -5 -5.0 1969-12-31 16:00:02.021 -200 1129692328 -4211492998784 NULL NULL 200 -400 -200 NULL NULL 5.0 1.7802E7 -5.056184320165681E-6 5 -15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:07.243 -200 237649242 -885956374176 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 61 61.0 1969-12-31 15:59:56.14 -200 1648986748 -6147422596544 NULL NULL 200 -400 -200 NULL NULL -61.0 1.7802E7 6.16854487060213E-5 -61 1.3041475409836065 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 13 13.0 1969-12-31 16:00:07.723 -200 -213003637 794077558736 NULL NULL 200 -400 -200 NULL NULL -13.0 1.7802E7 1.314607923243077E-5 -13 6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 16:00:00.026 -200 1152448197 -4296326878416 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -3 -3.0 1969-12-31 16:00:11.059 -200 1792567380 -6682691192640 NULL NULL 200 -400 -200 NULL NULL 3.0 1.7802E7 -3.033710592099409E-6 3 -26.517666666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 9 9.0 1969-12-31 15:59:50.611 -200 -1955716983 7290912912624 NULL NULL 200 -400 -200 NULL NULL -9.0 1.7802E7 9.101131776298225E-6 -9 8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 16:00:00.916 -200 555349603 -2070343319984 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -18 -18.0 1969-12-31 16:00:06.015 -200 -810783273 3022600041744 NULL NULL 200 -400 -200 NULL NULL 18.0 1.7802E7 -1.820226355259645E-5 18 -4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 7 7.0 1969-12-31 16:00:06.018 -200 1855542831 -6917463673968 NULL NULL 200 -400 -200 NULL NULL -7.0 1.7802E7 7.078658048231953E-6 -7 11.364714285714285 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 16:00:06.264 -200 -251902026 939090752928 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 16:00:08.386 -200 -505638328 1885019686784 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -51 -51.0 1969-12-31 16:00:07.536 -200 -1534321710 5719951334880 NULL NULL 200 -400 -200 NULL NULL 51.0 1.7802E7 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 15:59:48.341 -200 -621136047 2315595183216 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -15 -15.0 1969-12-31 16:00:07.485 -200 -1422147400 5301765507200 NULL NULL 200 -400 -200 NULL NULL 15.0 1.7802E7 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -40 -40.0 1969-12-31 15:59:56.555 -200 -906495924 3379416804672 NULL NULL 200 -400 -200 NULL NULL 40.0 1.7802E7 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 16:00:08 -200 1358421585 -5064195668880 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 12 12.0 1969-12-31 15:59:57.794 -200 -1949450483 7267551400624 NULL NULL 200 -400 -200 NULL NULL -12.0 1.7802E7 1.2134842368397635E-5 -12 6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -37 -37.0 1969-12-31 16:00:09.111 -200 243907290 -909286377120 NULL NULL 200 -400 -200 NULL NULL 37.0 1.7802E7 -3.741576396922604E-5 37 -2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 29 29.0 1969-12-31 16:00:08.001 -200 338519290 -1261999913120 NULL NULL 200 -400 -200 NULL NULL -29.0 1.7802E7 2.932586905696095E-5 -29 2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -36 -36.0 1969-12-31 15:59:56.174 -200 1728430174 -6443587688672 NULL NULL 200 -400 -200 NULL NULL 36.0 1.7802E7 -3.64045271051929E-5 36 -2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 27 27.0 1969-12-31 16:00:15.909 -200 -1965813035 7328550994480 NULL NULL 200 -400 -200 NULL NULL -27.0 1.7802E7 2.7303395328894677E-5 -27 2.946407407407407 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -5 -5.0 1969-12-31 15:59:56.319 -200 2112230777 -7874396336656 NULL NULL 200 -400 -200 NULL NULL 5.0 1.7802E7 -5.056184320165681E-6 5 -15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 16:00:09.65 -200 1990585322 -7420902080416 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 16:00:14.247 -200 1443417260 -5381059545280 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -34 -34.0 1969-12-31 15:59:44.559 -200 -831359851 3099309524528 NULL NULL 200 -400 -200 NULL NULL 34.0 1.7802E7 -3.438205337712663E-5 34 -2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 2 2.0 1969-12-31 16:00:10.198 -200 449588215 -1676064865520 NULL NULL 200 -400 -200 NULL NULL -2.0 1.7802E7 2.0224737280662724E-6 -2 39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -2 -2.0 1969-12-31 16:00:00.574 -200 1490979298 -5558370822944 NULL NULL 200 -400 -200 NULL NULL 2.0 1.7802E7 -2.0224737280662724E-6 2 -39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -21 -21.0 1969-12-31 15:59:56.109 -200 -1835568160 6842998100480 NULL NULL 200 -400 -200 NULL NULL 21.0 1.7802E7 -2.123597414469586E-5 21 -3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -54 -54.0 1969-12-31 15:59:57.369 -200 534194176 -1991475888128 NULL NULL 200 -400 -200 NULL NULL 54.0 1.7802E7 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 30 30.0 1969-12-31 15:59:55.204 -200 -501815954 1870769876512 NULL NULL 200 -400 -200 NULL NULL -30.0 1.7802E7 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 57 57.0 1969-12-31 15:59:58.455 -200 735056642 -2740291161376 NULL NULL 200 -400 -200 NULL NULL -57.0 1.7802E7 5.764050124988876E-5 -57 1.3956666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -18 -18.0 1969-12-31 15:59:44.301 -200 1945048831 -7251142041968 NULL NULL 200 -400 -200 NULL NULL 18.0 1.7802E7 -1.820226355259645E-5 18 -4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:10.452 -200 1693637019 -6313878806832 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 15:59:50.822 -200 -1860186661 6934775872208 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -56 -56.0 1969-12-31 15:59:47.897 -200 -388818510 1449515405280 NULL NULL 200 -400 -200 NULL NULL 56.0 1.7802E7 -5.6629264385855625E-5 56 -1.4205892857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 10 10.0 1969-12-31 16:00:15.298 -200 508896666 -1897166770848 NULL NULL 200 -400 -200 NULL NULL -10.0 1.7802E7 1.0112368640331362E-5 -10 7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -44 -44.0 1969-12-31 16:00:10.131 -200 -1576454990 5877024202720 NULL NULL 200 -400 -200 NULL NULL 44.0 1.7802E7 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -29 -29.0 1969-12-31 15:59:52.316 -200 -1367099579 5096547230512 NULL NULL 200 -400 -200 NULL NULL 29.0 1.7802E7 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -3 -3.0 1969-12-31 16:00:11.642 -200 -1747413995 6514359373360 NULL NULL 200 -400 -200 NULL NULL 3.0 1.7802E7 -3.033710592099409E-6 3 -26.517666666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -24 -24.0 1969-12-31 16:00:07.302 -200 -828408534 3088307014752 NULL NULL 200 -400 -200 NULL NULL 24.0 1.7802E7 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -13 -13.0 1969-12-31 16:00:05.24 -200 -871078831 3247381881968 NULL NULL 200 -400 -200 NULL NULL 13.0 1.7802E7 -1.314607923243077E-5 13 -6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 28 28.0 1969-12-31 15:59:47.977 -200 -145664633 543037751824 NULL NULL 200 -400 -200 NULL NULL -28.0 1.7802E7 2.8314632192927813E-5 -28 2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -17 -17.0 1969-12-31 16:00:06.738 -200 -1623682545 6053088527760 NULL NULL 200 -400 -200 NULL NULL 17.0 1.7802E7 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 15:59:48.678 -200 -1201695086 4479919280608 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 16:00:11.028 -200 -359106650 1338749591200 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 15:59:57.957 -200 1845320008 -6879352989824 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 15:59:45.015 -200 -433242847 1615129333616 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 16:00:16.165 -200 -1012580949 3774901777872 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:07.651 -200 670871256 -2501008042368 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 16:00:12.581 -200 -1764738986 6578946939808 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 15:59:56.414 -200 2073630240 -7730493534720 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 16:00:11.102 -200 -1501917393 5599148041104 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -11 -11.0 1969-12-31 15:59:46.878 -200 -1926901193 7183487647504 NULL NULL 200 -400 -200 NULL NULL 11.0 1.7802E7 -1.1123605504364498E-5 11 -7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 16:00:10.394 -200 -917626258 3420910689824 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 16:00:08.584 -200 -1920594326 7159975647328 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 16:00:00.072 -200 -1118623392 4170228005376 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -38 -38.0 1969-12-31 16:00:09.402 -200 -1524310263 5682628660464 NULL NULL 200 -400 -200 NULL NULL 38.0 1.7802E7 -3.842700083325918E-5 38 -2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 26 26.0 1969-12-31 15:59:52.563 -200 1609051854 -5998545311712 NULL NULL 200 -400 -200 NULL NULL -26.0 1.7802E7 2.629215846486154E-5 -26 3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 16:00:11.333 -200 -133846959 498981463152 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 20 20.0 1969-12-31 15:59:48.468 -200 855930073 -3190907312144 NULL NULL 200 -400 -200 NULL NULL -20.0 1.7802E7 2.0224737280662725E-5 -20 3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -5 -5.0 1969-12-31 16:00:03.52 -200 797790274 -2974162141472 NULL NULL 200 -400 -200 NULL NULL 5.0 1.7802E7 -5.056184320165681E-6 5 -15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 16:00:15.193 -200 -793559875 2958391214000 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:00.767 -200 1281550221 -4777619223888 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -41 -41.0 1969-12-31 15:59:57.604 -200 -1030234300 3840713470400 NULL NULL 200 -400 -200 NULL NULL 41.0 1.7802E7 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 54 54.0 1969-12-31 16:00:08.793 -200 -163820010 610720997280 NULL NULL 200 -400 -200 NULL NULL -54.0 1.7802E7 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 53 53.0 1969-12-31 15:59:48.451 -200 -1501172121 5596369667088 NULL NULL 200 -400 -200 NULL NULL -53.0 1.7802E7 5.359555379375622E-5 -53 1.501 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 23 23.0 1969-12-31 15:59:44.456 -200 488663894 -1821738996832 NULL NULL 200 -400 -200 NULL NULL -23.0 1.7802E7 2.325844787276213E-5 -23 3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 12 12.0 1969-12-31 15:59:46.762 -200 -901884078 3362223842784 NULL NULL 200 -400 -200 NULL NULL -12.0 1.7802E7 1.2134842368397635E-5 -12 6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 16:00:05.63 -200 397130878 -1480503913184 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 16:00:12.291 -200 -1455816525 5427284005200 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 16:00:12.183 -200 1577520702 -5880997177056 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 25 25.0 1969-12-31 15:59:57.127 -200 -1484913293 5535756756304 NULL NULL 200 -400 -200 NULL NULL -25.0 1.7802E7 2.5280921600828406E-5 -25 3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -40 -40.0 1969-12-31 15:59:54.952 -200 1496680212 -5579623830336 NULL NULL 200 -400 -200 NULL NULL 40.0 1.7802E7 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 9 9.0 1969-12-31 15:59:57.048 -200 191354420 -713369277760 NULL NULL 200 -400 -200 NULL NULL -9.0 1.7802E7 9.101131776298225E-6 -9 8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -52 -52.0 1969-12-31 16:00:05.377 -200 1867766093 -6963031994704 NULL NULL 200 -400 -200 NULL NULL 52.0 1.7802E7 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -29 -29.0 1969-12-31 15:59:48.102 -200 481032605 -1793289551440 NULL NULL 200 -400 -200 NULL NULL 29.0 1.7802E7 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -45 -45.0 1969-12-31 16:00:10.036 -200 -153597470 572611368160 NULL NULL 200 -400 -200 NULL NULL 45.0 1.7802E7 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -51 -51.0 1969-12-31 15:59:46.506 -200 57827239 -215579946992 NULL NULL 200 -400 -200 NULL NULL 51.0 1.7802E7 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 18 18.0 1969-12-31 15:59:48.188 -200 -834070259 3109413925552 NULL NULL 200 -400 -200 NULL NULL -18.0 1.7802E7 1.820226355259645E-5 -18 4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 36 36.0 1969-12-31 16:00:14.011 -200 -1301030543 4850241864304 NULL NULL 200 -400 -200 NULL NULL -36.0 1.7802E7 3.64045271051929E-5 -36 2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 15:59:45.198 -200 326580052 -1217490433856 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 40 40.0 1969-12-31 16:00:06.827 -200 -1879142590 7005443575520 NULL NULL 200 -400 -200 NULL NULL -40.0 1.7802E7 4.044947456132545E-5 -40 1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 13 13.0 1969-12-31 15:59:45.517 -200 522219886 -1946835735008 NULL NULL 200 -400 -200 NULL NULL -13.0 1.7802E7 1.314607923243077E-5 -13 6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -40 -40.0 1969-12-31 15:59:50.074 -200 247085875 -921136142000 NULL NULL 200 -400 -200 NULL NULL 40.0 1.7802E7 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 15:59:52.343 -200 309905338 -1155327100064 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 42 42.0 1969-12-31 16:00:05.092 -200 1057329243 -3941723417904 NULL NULL 200 -400 -200 NULL NULL -42.0 1.7802E7 4.247194828939172E-5 -42 1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 61 61.0 1969-12-31 16:00:01.091 -200 -2141583722 7983824115616 NULL NULL 200 -400 -200 NULL NULL -61.0 1.7802E7 6.16854487060213E-5 -61 1.3041475409836065 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 44 44.0 1969-12-31 16:00:03.89 -200 -72955181 271976914768 NULL NULL 200 -400 -200 NULL NULL -44.0 1.7802E7 4.449442201745799E-5 -44 1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 58 58.0 1969-12-31 15:59:54.562 -200 -649143670 2420007601760 NULL NULL 200 -400 -200 NULL NULL -58.0 1.7802E7 5.86517381139219E-5 -58 1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 22 22.0 1969-12-31 16:00:00.073 -200 872463931 -3252545534768 NULL NULL 200 -400 -200 NULL NULL -22.0 1.7802E7 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -3 -3.0 1969-12-31 15:59:53.28 -200 -1413849836 5270832188608 NULL NULL 200 -400 -200 NULL NULL 3.0 1.7802E7 -3.033710592099409E-6 3 -26.517666666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 62 62.0 1969-12-31 15:59:54.762 -200 1011458748 -3770718212544 NULL NULL 200 -400 -200 NULL NULL -62.0 1.7802E7 6.269668557005445E-5 -62 1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:02.075 -200 -1090697524 4066120369472 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 19 19.0 1969-12-31 16:00:03.44 -200 -699116745 2606307225360 NULL NULL 200 -400 -200 NULL NULL -19.0 1.7802E7 1.921350041662959E-5 -19 4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 29 29.0 1969-12-31 16:00:05.944 -200 1721739533 -6418644979024 NULL NULL 200 -400 -200 NULL NULL -29.0 1.7802E7 2.932586905696095E-5 -29 2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -38 -38.0 1969-12-31 16:00:09.644 -200 -5729887 21361018736 NULL NULL 200 -400 -200 NULL NULL 38.0 1.7802E7 -3.842700083325918E-5 38 -2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 11 11.0 1969-12-31 16:00:08.745 -200 1185396861 -4419159497808 NULL NULL 200 -400 -200 NULL NULL -11.0 1.7802E7 1.1123605504364498E-5 -11 7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -8 -8.0 1969-12-31 15:59:53.246 -200 371982429 -1386750495312 NULL NULL 200 -400 -200 NULL NULL 8.0 1.7802E7 -8.08989491226509E-6 8 -9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 31 31.0 1969-12-31 15:59:55.508 -200 322893623 -1203747426544 NULL NULL 200 -400 -200 NULL NULL -31.0 1.7802E7 3.134834278502722E-5 -31 2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 16:00:11.457 -200 -836056903 3116820134384 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -21 -21.0 1969-12-31 15:59:51.083 -200 1386823242 -5170077046176 NULL NULL 200 -400 -200 NULL NULL 21.0 1.7802E7 -2.123597414469586E-5 21 -3.788238095238095 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -31 -31.0 1969-12-31 15:59:52.474 -200 -281573163 1049704751664 NULL NULL 200 -400 -200 NULL NULL 31.0 1.7802E7 -3.134834278502722E-5 31 -2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 15:59:54.955 -200 -714556097 2663865129616 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 15:59:57.334 -200 -1104704650 4118338935200 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.389 1969-12-31 16:00:11.049 -200 -2143304715 7990239977520 NULL NULL 200 -400 -200 NULL NULL 1.389 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 59 59.0 1969-12-31 15:59:50.306 -200 771123694 -2874749131232 NULL NULL 200 -400 -200 NULL NULL -59.0 1.7802E7 5.966297497795504E-5 -59 1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -18 -18.0 1969-12-31 15:59:45.372 -200 -71980111 268341853808 NULL NULL 200 -400 -200 NULL NULL 18.0 1.7802E7 -1.820226355259645E-5 18 -4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 15:59:49.383 -200 -1177584950 4390036693600 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 46 46.0 1969-12-31 15:59:55.241 -200 -170158516 634350947648 NULL NULL 200 -400 -200 NULL NULL -46.0 1.7802E7 4.651689574552426E-5 -46 1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 45 45.0 1969-12-31 16:00:11.515 -200 855920504 -3190871638912 NULL NULL 200 -400 -200 NULL NULL -45.0 1.7802E7 4.550565888149113E-5 -45 1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 0 0.0 1969-12-31 15:59:44.904 -200 2144209609 -7993613422352 NULL NULL 200 -400 -200 NULL NULL -0.0 1.7802E7 0.0 0 Infinity +NULL -200.0 1969-12-31 15:59:55.451 NULL false -15 -15.0 1969-12-31 15:59:54.883 -200 -1411964550 5263803842400 NULL NULL 200 -400 -200 NULL NULL 15.0 1.7802E7 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 57 57.0 1969-12-31 16:00:04.207 -200 -971674501 3622402539728 NULL NULL 200 -400 -200 NULL NULL -57.0 1.7802E7 5.764050124988876E-5 -57 1.3956666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 16:00:02.928 -200 -891215466 3322451257248 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 5 5.0 1969-12-31 16:00:11.083 -200 -1660234875 6189355614000 NULL NULL 200 -400 -200 NULL NULL -5.0 1.7802E7 5.056184320165681E-6 -5 15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 44 44.0 1969-12-31 16:00:06.91 -200 -2002017129 7463519856912 NULL NULL 200 -400 -200 NULL NULL -44.0 1.7802E7 4.449442201745799E-5 -44 1.8080227272727272 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 48 48.0 1969-12-31 16:00:15.548 -200 1372727646 -5117528664288 NULL NULL 200 -400 -200 NULL NULL -48.0 1.7802E7 4.853936947359054E-5 -48 1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 16:00:02.322 -200 -126921733 473164220624 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 15:59:52.431 -200 -1235100020 4604452874560 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 15:59:53.671 -200 643105282 -2397496491296 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 0 0.0 1969-12-31 16:00:13.396 -200 618557893 -2305983825104 NULL NULL 200 -400 -200 NULL NULL -0.0 1.7802E7 0.0 0 Infinity +NULL -200.0 1969-12-31 15:59:55.451 NULL false 18 18.0 1969-12-31 15:59:55.382 -200 -1505775646 5613531608288 NULL NULL 200 -400 -200 NULL NULL -18.0 1.7802E7 1.820226355259645E-5 -18 4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 15:59:56.218 -200 964506212 -3595679158336 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 9 9.0 1969-12-31 15:59:43.983 -200 1928523894 -7189537076832 NULL NULL 200 -400 -200 NULL NULL -9.0 1.7802E7 9.101131776298225E-6 -9 8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:10.227 -200 1313892161 -4898189976208 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 16:00:07.006 -200 -1897610729 7074292797712 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 36 36.0 1969-12-31 16:00:10.467 -200 1284716338 -4789422508064 NULL NULL 200 -400 -200 NULL NULL -36.0 1.7802E7 3.64045271051929E-5 -36 2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -39 -39.0 1969-12-31 16:00:13.144 -200 -589917253 2199211519184 NULL NULL 200 -400 -200 NULL NULL 39.0 1.7802E7 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 16 16.0 1969-12-31 16:00:02.582 -200 1047398909 -3904703132752 NULL NULL 200 -400 -200 NULL NULL -16.0 1.7802E7 1.617978982453018E-5 -16 4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 10 10.0 1969-12-31 15:59:57.081 -200 -1731141467 6453695388976 NULL NULL 200 -400 -200 NULL NULL -10.0 1.7802E7 1.0112368640331362E-5 -10 7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 4 4.0 1969-12-31 15:59:54.471 -200 296811522 -1106513354016 NULL NULL 200 -400 -200 NULL NULL -4.0 1.7802E7 4.044947456132545E-6 -4 19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 47 47.0 1969-12-31 15:59:52.118 -200 1683928379 -6277684996912 NULL NULL 200 -400 -200 NULL NULL -47.0 1.7802E7 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 15:59:50.023 -200 -1184913004 4417355678912 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 2 2.0 1969-12-31 15:59:58.416 -200 -516985252 1927321019456 NULL NULL 200 -400 -200 NULL NULL -2.0 1.7802E7 2.0224737280662724E-6 -2 39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 38 38.0 1969-12-31 15:59:51.77 -200 835189885 -3113587891280 NULL NULL 200 -400 -200 NULL NULL -38.0 1.7802E7 3.842700083325918E-5 -38 2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 2 2.0 1969-12-31 16:00:09.161 -200 1480384156 -5518872133568 NULL NULL 200 -400 -200 NULL NULL -2.0 1.7802E7 2.0224737280662724E-6 -2 39.7765 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 30 30.0 1969-12-31 15:59:44.101 -200 -686795969 2560375372432 NULL NULL 200 -400 -200 NULL NULL -30.0 1.7802E7 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 16:00:00.778 -200 -614444827 2290650315056 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 16:00:14.154 -200 -1113073921 4149539577488 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 16:00:12.477 -200 2128130578 -7933670794784 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 1 1.0 1969-12-31 16:00:10.364 -200 85496797 -318732059216 NULL NULL 200 -400 -200 NULL NULL -1.0 1.7802E7 1.0112368640331362E-6 -1 79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -8 -8.0 1969-12-31 15:59:54.731 -200 508093612 -1894172985536 NULL NULL 200 -400 -200 NULL NULL 8.0 1.7802E7 -8.08989491226509E-6 8 -9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -1 -1.0 1969-12-31 16:00:12.403 -200 -868641510 3238295549280 NULL NULL 200 -400 -200 NULL NULL 1.0 1.7802E7 -1.0112368640331362E-6 1 -79.553 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 15:59:46.633 -200 -167812632 625605492096 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 16:00:08.301 -200 -735058469 2740297972432 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -49 -49.0 1969-12-31 15:59:56.159 -200 1436496635 -5355259455280 NULL NULL 200 -400 -200 NULL NULL 49.0 1.7802E7 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 30 30.0 1969-12-31 16:00:08.142 -200 -1657894927 6180632287856 NULL NULL 200 -400 -200 NULL NULL -30.0 1.7802E7 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 8 8.0 1969-12-31 15:59:48.785 -200 1356532737 -5057154043536 NULL NULL 200 -400 -200 NULL NULL -8.0 1.7802E7 8.08989491226509E-6 -8 9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 15:59:45.163 -200 766974126 -2859279541728 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 15:59:48.16 -200 -395589755 1474758606640 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 29 29.0 1969-12-31 16:00:05.79 -200 1890977505 -7049564138640 NULL NULL 200 -400 -200 NULL NULL -29.0 1.7802E7 2.932586905696095E-5 -29 2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:09.792 -200 -1710271850 6375893456800 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 37 37.0 1969-12-31 16:00:06.69 -200 -1817207476 6774549470528 NULL NULL 200 -400 -200 NULL NULL -37.0 1.7802E7 3.741576396922604E-5 -37 2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 15:59:44.008 -200 -573654993 2138585813904 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 15:59:44.221 -200 1371826360 -5114168670080 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -20 -20.0 1969-12-31 15:59:48.182 -200 1406877565 -5244839562320 NULL NULL 200 -400 -200 NULL NULL 20.0 1.7802E7 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 58 58.0 1969-12-31 15:59:51.063 -200 -432105022 1610887522016 NULL NULL 200 -400 -200 NULL NULL -58.0 1.7802E7 5.86517381139219E-5 -58 1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -8 -8.0 1969-12-31 15:59:48.763 -200 1471734024 -5486624441472 NULL NULL 200 -400 -200 NULL NULL 8.0 1.7802E7 -8.08989491226509E-6 8 -9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 16:00:01.232 -200 1961389522 -7312060138016 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -32 -32.0 1969-12-31 16:00:04.577 -200 -1665914053 6210527589584 NULL NULL 200 -400 -200 NULL NULL 32.0 1.7802E7 -3.235957964906036E-5 32 -2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -58 -58.0 1969-12-31 15:59:50.681 -200 -22464308 83746940224 NULL NULL 200 -400 -200 NULL NULL 58.0 1.7802E7 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -10 -10.0 1969-12-31 15:59:58.989 -200 475712407 -1773455853296 NULL NULL 200 -400 -200 NULL NULL 10.0 1.7802E7 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 43 43.0 1969-12-31 16:00:14.685 -200 -90837843 338643478704 NULL NULL 200 -400 -200 NULL NULL -43.0 1.7802E7 4.3483185153424856E-5 -43 1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -62 -62.0 1969-12-31 16:00:00.037 -200 -2080605724 7756498139072 NULL NULL 200 -400 -200 NULL NULL 62.0 1.7802E7 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 59 59.0 1969-12-31 16:00:05.13 -200 661665098 -2466687485344 NULL NULL 200 -400 -200 NULL NULL -59.0 1.7802E7 5.966297497795504E-5 -59 1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 12 12.0 1969-12-31 16:00:09.556 -200 801119662 -2986574099936 NULL NULL 200 -400 -200 NULL NULL -12.0 1.7802E7 1.2134842368397635E-5 -12 6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 42 42.0 1969-12-31 15:59:48.292 -200 760034197 -2833407486416 NULL NULL 200 -400 -200 NULL NULL -42.0 1.7802E7 4.247194828939172E-5 -42 1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -46 -46.0 1969-12-31 16:00:00.013 -200 -1767343556 6588656776768 NULL NULL 200 -400 -200 NULL NULL 46.0 1.7802E7 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -14 -14.0 1969-12-31 16:00:08.549 -200 1340808498 -4998534080544 NULL NULL 200 -400 -200 NULL NULL 14.0 1.7802E7 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -63 -63.0 1969-12-31 15:59:57.693 -200 956380949 -3565388177872 NULL NULL 200 -400 -200 NULL NULL 63.0 1.7802E7 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -54 -54.0 1969-12-31 16:00:00.168 -200 -802752239 2992660346992 NULL NULL 200 -400 -200 NULL NULL 54.0 1.7802E7 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 32 32.0 1969-12-31 15:59:44.04 -200 -257169455 958727728240 NULL NULL 200 -400 -200 NULL NULL -32.0 1.7802E7 3.235957964906036E-5 -32 2.48603125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 15:59:45.739 -200 -1690528981 6302292041168 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 35 35.0 1969-12-31 16:00:14.084 -200 1974986508 -7362749701824 NULL NULL 200 -400 -200 NULL NULL -35.0 1.7802E7 3.5393290241159765E-5 -35 2.272942857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -42 -42.0 1969-12-31 15:59:56.197 -200 1157618085 -4315600220880 NULL NULL 200 -400 -200 NULL NULL 42.0 1.7802E7 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -11 -11.0 1969-12-31 15:59:43.783 -200 12116087 -45168772336 NULL NULL 200 -400 -200 NULL NULL 11.0 1.7802E7 -1.1123605504364498E-5 11 -7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 17 17.0 1969-12-31 16:00:10.672 -200 -1197996365 4466130448720 NULL NULL 200 -400 -200 NULL NULL -17.0 1.7802E7 1.7191026688563315E-5 -17 4.679588235294117 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 25 25.0 1969-12-31 15:59:54.072 -200 1405644908 -5240244217024 NULL NULL 200 -400 -200 NULL NULL -25.0 1.7802E7 2.5280921600828406E-5 -25 3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -8 -8.0 1969-12-31 15:59:49.986 -200 -1515410154 5649449054112 NULL NULL 200 -400 -200 NULL NULL 8.0 1.7802E7 -8.08989491226509E-6 8 -9.944125 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -57 -57.0 1969-12-31 16:00:11.883 -200 -369958251 1379204359728 NULL NULL 200 -400 -200 NULL NULL 57.0 1.7802E7 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 42 42.0 1969-12-31 15:59:30.929 -200 -578935785 2158272606480 NULL NULL 200 -400 -200 NULL NULL -42.0 1.7802E7 4.247194828939172E-5 -42 1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 11 11.0 1969-12-31 16:00:13.383 -200 1442208582 -5376553593696 NULL NULL 200 -400 -200 NULL NULL -11.0 1.7802E7 1.1123605504364498E-5 -11 7.232090909090909 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 0 0.0 1969-12-31 16:00:02.71 -200 406548885 -1515614243280 NULL NULL 200 -400 -200 NULL NULL -0.0 1.7802E7 0.0 0 Infinity +NULL -200.0 1969-12-31 15:59:55.451 NULL false -19 -19.0 1969-12-31 16:00:04.02 -200 -112652051 419966846128 NULL NULL 200 -400 -200 NULL NULL 19.0 1.7802E7 -1.921350041662959E-5 19 -4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 15:59:45.865 -200 -1014234787 3781067285936 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -55 -55.0 1969-12-31 16:00:05.793 -200 865661585 -3227186388880 NULL NULL 200 -400 -200 NULL NULL 55.0 1.7802E7 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -46 -46.0 1969-12-31 15:59:53.694 -200 -1338441335 4989709296880 NULL NULL 200 -400 -200 NULL NULL 46.0 1.7802E7 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -50 -50.0 1969-12-31 16:00:15.707 -200 -1030054242 3840042214176 NULL NULL 200 -400 -200 NULL NULL 50.0 1.7802E7 -5.056184320165681E-5 50 -1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 48 48.0 1969-12-31 16:00:00.008 -200 -949365839 3539235847792 NULL NULL 200 -400 -200 NULL NULL -48.0 1.7802E7 4.853936947359054E-5 -48 1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -47 -47.0 1969-12-31 16:00:08.884 -200 2028722791 -7563078564848 NULL NULL 200 -400 -200 NULL NULL 47.0 1.7802E7 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 20 20.0 1969-12-31 16:00:05.722 -200 1977856778 -7373450068384 NULL NULL 200 -400 -200 NULL NULL -20.0 1.7802E7 2.0224737280662725E-5 -20 3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 15:59:45.299 -200 -653439720 2436023276160 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -33 -33.0 1969-12-31 15:59:52.269 -200 -1888871661 7041713552208 NULL NULL 200 -400 -200 NULL NULL 33.0 1.7802E7 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -26 -26.0 1969-12-31 15:59:48.662 -200 -1820077302 6785248181856 NULL NULL 200 -400 -200 NULL NULL 26.0 1.7802E7 -2.629215846486154E-5 26 -3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -33 -33.0 1969-12-31 16:00:00.611 -200 2087495093 -7782181706704 NULL NULL 200 -400 -200 NULL NULL 33.0 1.7802E7 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -19 -19.0 1969-12-31 16:00:15.223 -200 -1721895877 6419227829456 NULL NULL 200 -400 -200 NULL NULL 19.0 1.7802E7 -1.921350041662959E-5 19 -4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 49 49.0 1969-12-31 16:00:08.726 -200 1233260108 -4597593682624 NULL NULL 200 -400 -200 NULL NULL -49.0 1.7802E7 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 16:00:09.498 -200 -643835673 2400219388944 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 54 54.0 1969-12-31 15:59:53.886 -200 1838082189 -6852370400592 NULL NULL 200 -400 -200 NULL NULL -54.0 1.7802E7 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -27 -27.0 1969-12-31 16:00:06.385 -200 -1446714109 5393350198352 NULL NULL 200 -400 -200 NULL NULL 27.0 1.7802E7 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 20 20.0 1969-12-31 16:00:05.147 -200 -1173894737 4376279579536 NULL NULL 200 -400 -200 NULL NULL -20.0 1.7802E7 2.0224737280662725E-5 -20 3.9776499999999997 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -64 -64.0 1969-12-31 16:00:00.199 -200 927647669 -3458270510032 NULL NULL 200 -400 -200 NULL NULL 64.0 1.7802E7 -6.471915929812072E-5 64 -1.243015625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -27 -27.0 1969-12-31 16:00:08.365 -200 -2068220951 7710327705328 NULL NULL 200 -400 -200 NULL NULL 27.0 1.7802E7 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -31 -31.0 1969-12-31 16:00:13.087 -200 -2127856621 7932649483088 NULL NULL 200 -400 -200 NULL NULL 31.0 1.7802E7 -3.134834278502722E-5 31 -2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -58 -58.0 1969-12-31 16:00:08.74 -200 765913519 -2855325598832 NULL NULL 200 -400 -200 NULL NULL 58.0 1.7802E7 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 62 62.0 1969-12-31 16:00:07.828 -200 1801868132 -6717364396096 NULL NULL 200 -400 -200 NULL NULL -62.0 1.7802E7 6.269668557005445E-5 -62 1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -60 -60.0 1969-12-31 16:00:11.641 -200 -1445021496 5387040137088 NULL NULL 200 -400 -200 NULL NULL 60.0 1.7802E7 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 34 34.0 1969-12-31 16:00:14.909 -200 26234080 -97800650240 NULL NULL 200 -400 -200 NULL NULL -34.0 1.7802E7 3.438205337712663E-5 -34 2.3397941176470587 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -4 -4.0 1969-12-31 16:00:14.04 -200 -247697712 923417070336 NULL NULL 200 -400 -200 NULL NULL 4.0 1.7802E7 -4.044947456132545E-6 4 -19.88825 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 37 37.0 1969-12-31 16:00:09.907 -200 1256255128 -4683319117184 NULL NULL 200 -400 -200 NULL NULL -37.0 1.7802E7 3.741576396922604E-5 -37 2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 16:00:09.93 -200 854529509 -3185686009552 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -50 -50.0 1969-12-31 15:59:47.233 -200 824529348 -3073845409344 NULL NULL 200 -400 -200 NULL NULL 50.0 1.7802E7 -5.056184320165681E-5 50 -1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 15:59:49.762 -200 408511379 -1522930420912 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -59 -59.0 1969-12-31 15:59:44.148 -200 -639531371 2384172951088 NULL NULL 200 -400 -200 NULL NULL 59.0 1.7802E7 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 14 14.0 1969-12-31 15:59:46.045 -200 166002385 -618856891280 NULL NULL 200 -400 -200 NULL NULL -14.0 1.7802E7 1.4157316096463906E-5 -14 5.682357142857143 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 19 19.0 1969-12-31 15:59:46.022 -200 1911972024 -7127831705472 NULL NULL 200 -400 -200 NULL NULL -19.0 1.7802E7 1.921350041662959E-5 -19 4.187 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 25 25.0 1969-12-31 16:00:06.38 -200 -1737191305 6476249185040 NULL NULL 200 -400 -200 NULL NULL -25.0 1.7802E7 2.5280921600828406E-5 -25 3.18212 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 23 23.0 1969-12-31 15:59:55.008 -200 1257490174 -4687923368672 NULL NULL 200 -400 -200 NULL NULL -23.0 1.7802E7 2.325844787276213E-5 -23 3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -37 -37.0 1969-12-31 16:00:02.112 -200 -386882321 1442297292688 NULL NULL 200 -400 -200 NULL NULL 37.0 1.7802E7 -3.741576396922604E-5 37 -2.150081081081081 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -45 -45.0 1969-12-31 16:00:05.68 -200 942202168 -3512529682304 NULL NULL 200 -400 -200 NULL NULL 45.0 1.7802E7 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 40 40.0 1969-12-31 16:00:06.346 -200 2068959120 -7713079599360 NULL NULL 200 -400 -200 NULL NULL -40.0 1.7802E7 4.044947456132545E-5 -40 1.9888249999999998 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 0 0.0 1969-12-31 16:00:15.616 -200 -1379420228 5142478609984 NULL NULL 200 -400 -200 NULL NULL -0.0 1.7802E7 0.0 0 Infinity +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 16:00:11.08 -200 607820185 -2265953649680 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -22 -22.0 1969-12-31 15:59:54.584 -200 1322101937 -4928796021136 NULL NULL 200 -400 -200 NULL NULL 22.0 1.7802E7 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:01.813 -200 -1749223037 6521103481936 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -28 -28.0 1969-12-31 15:59:51.867 -200 706927917 -2635427274576 NULL NULL 200 -400 -200 NULL NULL 28.0 1.7802E7 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -46 -46.0 1969-12-31 16:00:00.601 -200 -993366782 3703271363296 NULL NULL 200 -400 -200 NULL NULL 46.0 1.7802E7 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 43 43.0 1969-12-31 15:59:50.893 -200 1796171294 -6696126584032 NULL NULL 200 -400 -200 NULL NULL -43.0 1.7802E7 4.3483185153424856E-5 -43 1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 42 42.0 1969-12-31 16:00:15.369 -200 942676094 -3514296478432 NULL NULL 200 -400 -200 NULL NULL -42.0 1.7802E7 4.247194828939172E-5 -42 1.8941190476190475 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -58 -58.0 1969-12-31 16:00:08.05 -200 -652375883 2432057291824 NULL NULL 200 -400 -200 NULL NULL 58.0 1.7802E7 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 31 31.0 1969-12-31 15:59:58.44 -200 -742095371 2766531543088 NULL NULL 200 -400 -200 NULL NULL -31.0 1.7802E7 3.134834278502722E-5 -31 2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -26.28 1969-12-31 15:59:56.197 -200 -1899525804 7081432197312 NULL NULL 200 -400 -200 NULL NULL 26.28 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 48 48.0 1969-12-31 16:00:15.512 -200 -929558354 3465393543712 NULL NULL 200 -400 -200 NULL NULL -48.0 1.7802E7 4.853936947359054E-5 -48 1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -15 -15.0 1969-12-31 15:59:54.004 -200 -541559761 2018934789008 NULL NULL 200 -400 -200 NULL NULL 15.0 1.7802E7 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 0 0.0 1969-12-31 16:00:10.139 -200 1585496199 -5910729829872 NULL NULL 200 -400 -200 NULL NULL -0.0 1.7802E7 0.0 0 Infinity +NULL -200.0 1969-12-31 15:59:55.451 NULL false -47 -47.0 1969-12-31 15:59:56.477 -200 15932860 -59397702080 NULL NULL 200 -400 -200 NULL NULL 47.0 1.7802E7 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 13 13.0 1969-12-31 15:59:46.525 -200 -1069199891 3985977193648 NULL NULL 200 -400 -200 NULL NULL -13.0 1.7802E7 1.314607923243077E-5 -13 6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -5 -5.0 1969-12-31 16:00:08.267 -200 247154261 -921391085008 NULL NULL 200 -400 -200 NULL NULL 5.0 1.7802E7 -5.056184320165681E-6 5 -15.910599999999999 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -12 -12.0 1969-12-31 16:00:04.154 -200 -781795723 2914534455344 NULL NULL 200 -400 -200 NULL NULL 12.0 1.7802E7 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 33 33.0 1969-12-31 15:59:51.66 -200 -1537502693 5731810039504 NULL NULL 200 -400 -200 NULL NULL -33.0 1.7802E7 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -48 -48.0 1969-12-31 15:59:50.052 -200 267944536 -998897230208 NULL NULL 200 -400 -200 NULL NULL 48.0 1.7802E7 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 41 41.0 1969-12-31 15:59:45.574 -200 -2080164191 7754852104048 NULL NULL 200 -400 -200 NULL NULL -41.0 1.7802E7 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 26 26.0 1969-12-31 15:59:58.654 -200 -1384566896 5161665388288 NULL NULL 200 -400 -200 NULL NULL -26.0 1.7802E7 2.629215846486154E-5 -26 3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -56 -56.0 1969-12-31 16:00:13.958 -200 -324944949 1211394769872 NULL NULL 200 -400 -200 NULL NULL 56.0 1.7802E7 -5.6629264385855625E-5 56 -1.4205892857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:16.178 -200 -1589934514 5927275868192 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 7 7.0 1969-12-31 15:59:53.034 -200 514569296 -1918314335488 NULL NULL 200 -400 -200 NULL NULL -7.0 1.7802E7 7.078658048231953E-6 -7 11.364714285714285 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -27 -27.0 1969-12-31 15:59:58.171 -200 -1703126876 6349256993728 NULL NULL 200 -400 -200 NULL NULL 27.0 1.7802E7 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 52 52.0 1969-12-31 16:00:02.269 -200 2035546169 -7588516118032 NULL NULL 200 -400 -200 NULL NULL -52.0 1.7802E7 5.258431692972308E-5 -52 1.5298653846153845 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -16 -16.0 1969-12-31 16:00:05.487 -200 -1886601867 7033251760176 NULL NULL 200 -400 -200 NULL NULL 16.0 1.7802E7 -1.617978982453018E-5 16 -4.9720625 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -31 -31.0 1969-12-31 16:00:07.398 -200 -1461142157 5447137961296 NULL NULL 200 -400 -200 NULL NULL 31.0 1.7802E7 -3.134834278502722E-5 31 -2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -47 -47.0 1969-12-31 16:00:04.977 -200 -300022102 1118482396256 NULL NULL 200 -400 -200 NULL NULL 47.0 1.7802E7 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 35 35.0 1969-12-31 16:00:00.9 -200 880598992 -3282873042176 NULL NULL 200 -400 -200 NULL NULL -35.0 1.7802E7 3.5393290241159765E-5 -35 2.272942857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -31 -31.0 1969-12-31 16:00:15.012 -200 1399153943 -5216045899504 NULL NULL 200 -400 -200 NULL NULL 31.0 1.7802E7 -3.134834278502722E-5 31 -2.566225806451613 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -18 -18.0 1969-12-31 16:00:05.241 -200 1602304617 -5973391612176 NULL NULL 200 -400 -200 NULL NULL 18.0 1.7802E7 -1.820226355259645E-5 18 -4.419611111111111 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -9 -9.0 1969-12-31 15:59:57.965 -200 1095896876 -4085503553728 NULL NULL 200 -400 -200 NULL NULL 9.0 1.7802E7 -9.101131776298225E-6 9 -8.839222222222222 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 60 60.0 1969-12-31 15:59:51.682 -200 -1493893128 5569233581184 NULL NULL 200 -400 -200 NULL NULL -60.0 1.7802E7 6.0674211841988174E-5 -60 1.3258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 13 13.0 1969-12-31 16:00:14.548 -200 370944760 -1382882065280 NULL NULL 200 -400 -200 NULL NULL -13.0 1.7802E7 1.314607923243077E-5 -13 6.119461538461538 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 54 54.0 1969-12-31 15:59:56.345 -200 1756261895 -6547344344560 NULL NULL 200 -400 -200 NULL NULL -54.0 1.7802E7 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 55 55.0 1969-12-31 15:59:51.024 -200 4521993 -16857989904 NULL NULL 200 -400 -200 NULL NULL -55.0 1.7802E7 5.561802752182249E-5 -55 1.4464181818181818 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 36 36.0 1969-12-31 15:59:44.081 -200 -1267159917 4723972170576 NULL NULL 200 -400 -200 NULL NULL -36.0 1.7802E7 3.64045271051929E-5 -36 2.2098055555555556 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 41 41.0 1969-12-31 15:59:49.062 -200 -512762593 1911578946704 NULL NULL 200 -400 -200 NULL NULL -41.0 1.7802E7 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 24 24.0 1969-12-31 15:59:52.313 -200 1037704301 -3868561634128 NULL NULL 200 -400 -200 NULL NULL -24.0 1.7802E7 2.426968473679527E-5 -24 3.3147083333333334 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -41 -41.0 1969-12-31 16:00:02.969 -200 1295784269 -4830683754832 NULL NULL 200 -400 -200 NULL NULL 41.0 1.7802E7 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -41 -41.0 1969-12-31 16:00:11.565 -200 -1838021063 6852142522864 NULL NULL 200 -400 -200 NULL NULL 41.0 1.7802E7 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -51 -51.0 1969-12-31 16:00:02.011 -200 -595350658 2219467253024 NULL NULL 200 -400 -200 NULL NULL 51.0 1.7802E7 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -38 -38.0 1969-12-31 16:00:02.007 -200 -1627751298 6068256838944 NULL NULL 200 -400 -200 NULL NULL 38.0 1.7802E7 -3.842700083325918E-5 38 -2.0935 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -6 -6.0 1969-12-31 15:59:56.094 -200 -585807467 2183890236976 NULL NULL 200 -400 -200 NULL NULL 6.0 1.7802E7 -6.067421184198818E-6 6 -13.258833333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -29 -29.0 1969-12-31 16:00:03.116 -200 737068329 -2747790730512 NULL NULL 200 -400 -200 NULL NULL 29.0 1.7802E7 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -56 -56.0 1969-12-31 16:00:15.038 -200 1642029665 -6121486591120 NULL NULL 200 -400 -200 NULL NULL 56.0 1.7802E7 -5.6629264385855625E-5 56 -1.4205892857142857 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 62 62.0 1969-12-31 15:59:46.338 -200 175991222 -656095275616 NULL NULL 200 -400 -200 NULL NULL -62.0 1.7802E7 6.269668557005445E-5 -62 1.2831129032258064 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -47 -47.0 1969-12-31 16:00:02.508 -200 1775269950 -6618206373600 NULL NULL 200 -400 -200 NULL NULL 47.0 1.7802E7 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -43 -43.0 1969-12-31 16:00:14.536 -200 -1530962879 5707429612912 NULL NULL 200 -400 -200 NULL NULL 43.0 1.7802E7 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 50 50.0 1969-12-31 16:00:15.232 -200 -51350287 191433869936 NULL NULL 200 -400 -200 NULL NULL -50.0 1.7802E7 5.056184320165681E-5 -50 1.59106 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -23 -23.0 1969-12-31 16:00:04.124 -200 -1205825630 4495317948640 NULL NULL 200 -400 -200 NULL NULL 23.0 1.7802E7 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -7 -7.0 1969-12-31 15:59:50.845 -200 1245697310 -4643959571680 NULL NULL 200 -400 -200 NULL NULL 7.0 1.7802E7 -7.078658048231953E-6 7 -11.364714285714285 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 26 26.0 1969-12-31 16:00:05.219 -200 932710812 -3477145907136 NULL NULL 200 -400 -200 NULL NULL -26.0 1.7802E7 2.629215846486154E-5 -26 3.059730769230769 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -53 -53.0 1969-12-31 15:59:58.158 -200 1905162359 -7102445274352 NULL NULL 200 -400 -200 NULL NULL 53.0 1.7802E7 -5.359555379375622E-5 53 -1.501 +NULL -200.0 1969-12-31 15:59:55.451 NULL false 15 15.0 1969-12-31 16:00:11.15 -200 740436530 -2760347383840 NULL NULL 200 -400 -200 NULL NULL -15.0 1.7802E7 1.5168552960497044E-5 -15 5.303533333333333 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -41 -41.0 1969-12-31 15:59:45.304 -200 1972217868 -7352428211904 NULL NULL 200 -400 -200 NULL NULL 41.0 1.7802E7 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -200.0 1969-12-31 15:59:55.451 NULL false -30 -30.0 1969-12-31 16:00:12.935 -200 1429852250 -5330489188000 NULL NULL 200 -400 -200 NULL NULL 30.0 1.7802E7 -3.0337105920994087E-5 30 -2.6517666666666666 +-109813638 NULL NULL t32s57Cjt4a250qQgVNAB5T true -51 -51.0 1969-12-31 16:00:08.451 NULL -58941842 219735186976 109813638 1.09812774743E8 NULL NULL NULL 1.0 1.09812801023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-601502867 NULL NULL M152O true -51 -51.0 1969-12-31 16:00:08.451 NULL -425267321 1585396572688 601502867 6.01502003743E8 NULL NULL NULL 1.0 6.01502030023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-881630661 NULL NULL 3e27C1jTdTQPdvCWi4if true -51 -51.0 1969-12-31 16:00:08.451 NULL -309125967 1152421604976 881630661 8.81629797743E8 NULL NULL NULL 1.0 8.81629824023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-515203523 NULL NULL P2DNeo00PA7DJF0 false -51 -51.0 1969-12-31 16:00:08.451 NULL -332345391 1238983617648 515203523 5.15202659743E8 NULL NULL NULL 1.0 5.1520268602299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-916222455 NULL NULL dG8B5PQ3b85U362G6huu false -51 -51.0 1969-12-31 16:00:08.451 NULL -279202430 1040866659040 916222455 9.16221591743E8 NULL NULL NULL 1.0 9.16221618023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-885788893 NULL NULL LX6QHG6sEmBAIbA6e6Am24 false -51 -51.0 1969-12-31 16:00:08.451 NULL -324210434 1208656497952 885788893 8.85788029743E8 NULL NULL NULL 1.0 8.85788056023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1017266554 NULL NULL DU1m68i1Q7W3 false -51 -51.0 1969-12-31 16:00:08.451 NULL -145067516 540811699648 1017266554 1.017265690743E9 NULL NULL NULL 1.0 1.017265717023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-452945059 NULL NULL QbdFB1d7vfaM7 true -51 -51.0 1969-12-31 16:00:08.451 NULL -7309465 27249685520 452945059 4.52944195743E8 NULL NULL NULL 1.0 4.5294422202299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-375807166 NULL NULL K2uHR7U36540Kx6tC false -51 -51.0 1969-12-31 16:00:08.451 NULL -353931480 1319456557440 375807166 3.75806302743E8 NULL NULL NULL 1.0 3.7580632902299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-303254000 NULL NULL DHy1oyJ2887Mr5 true -51 -51.0 1969-12-31 16:00:08.451 NULL -64784934 241518233952 303254000 3.03253136743E8 NULL NULL NULL 1.0 3.0325316302299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-597089099 NULL NULL vsX2f2YM0vC5E21f1 true -51 -51.0 1969-12-31 16:00:08.451 NULL -106412768 396706799104 597089099 5.97088235743E8 NULL NULL NULL 1.0 5.97088262023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-943342622 NULL NULL 3w6XYq04J0Lb3Sv82eOV2HJ true -51 -51.0 1969-12-31 16:00:08.451 NULL -750731096 2798725525888 943342622 9.43341758743E8 NULL NULL NULL 1.0 9.43341785023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-949286785 NULL NULL XWuYuk5qpn5Khs3764E56 true -51 -51.0 1969-12-31 16:00:08.451 NULL -946341072 3527959516416 949286785 9.49285921743E8 NULL NULL NULL 1.0 9.49285948023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-833480226 NULL NULL rNGcxI3PkU2K true -51 -51.0 1969-12-31 16:00:08.451 NULL -498518747 1858477888816 833480226 8.33479362743E8 NULL NULL NULL 1.0 8.33479389023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-970918963 NULL NULL suoqdh false -51 -51.0 1969-12-31 16:00:08.451 NULL -588508542 2193959844576 970918963 9.70918099743E8 NULL NULL NULL 1.0 9.70918126023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-794175309 NULL NULL NIp47 false -51 -51.0 1969-12-31 16:00:08.451 NULL -283652605 1057456911440 794175309 7.94174445743E8 NULL NULL NULL 1.0 7.94174472023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-742561638 NULL NULL 34vL40uLcr11po3k false -51 -51.0 1969-12-31 16:00:08.451 NULL -655193302 2442560629856 742561638 7.42560774743E8 NULL NULL NULL 1.0 7.42560801023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-830610139 NULL NULL 3FD2bt1EIaA0YrK true -51 -51.0 1969-12-31 16:00:08.451 NULL -798375623 2976344322544 830610139 8.30609275743E8 NULL NULL NULL 1.0 8.30609302023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-711795817 NULL NULL 4hMaavAE false -51 -51.0 1969-12-31 16:00:08.451 NULL -578512565 2156694842320 711795817 7.11794953743E8 NULL NULL NULL 1.0 7.11794980023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-809162203 NULL NULL shMOr3b8w1F4F38D4wih0 true -51 -51.0 1969-12-31 16:00:08.451 NULL -47746898 178000435744 809162203 8.09161339743E8 NULL NULL NULL 1.0 8.09161366023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-491184664 NULL NULL u85A6B false -51 -51.0 1969-12-31 16:00:08.451 NULL -58002434 216233073952 491184664 4.91183800743E8 NULL NULL NULL 1.0 4.9118382702299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-554456306 NULL NULL 6JLTA0I2Jx60HU470LO false -51 -51.0 1969-12-31 16:00:08.451 NULL -248574679 926686403312 554456306 5.54455442743E8 NULL NULL NULL 1.0 5.54455469023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-339214974 NULL NULL UtriJV4U5N2J7M false -51 -51.0 1969-12-31 16:00:08.451 NULL -282992256 1054995130368 339214974 3.39214110743E8 NULL NULL NULL 1.0 3.3921413702299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-730289443 NULL NULL 2n2cwjWAp2R56c2GYtKHQf0i false -51 -51.0 1969-12-31 16:00:08.451 NULL -684626873 2552288982544 730289443 7.30288579743E8 NULL NULL NULL 1.0 7.30288606023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-486415983 NULL NULL 4U4HK false -51 -51.0 1969-12-31 16:00:08.451 NULL -92514745 344894969360 486415983 4.86415119743E8 NULL NULL NULL 1.0 4.8641514602299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-859482455 NULL NULL 14fnT7A11Y6fE false -51 -51.0 1969-12-31 16:00:08.451 NULL -851076402 3172812826656 859482455 8.59481591743E8 NULL NULL NULL 1.0 8.59481618023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1015510885 NULL NULL Kw7fOuw4DHeyXe2yg false -51 -51.0 1969-12-31 16:00:08.451 NULL -67812054 252803337312 1015510885 1.015510021743E9 NULL NULL NULL 1.0 1.015510048023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-919940926 NULL NULL i1P3Wlat5EnBugL24oS4I3 true -51 -51.0 1969-12-31 16:00:08.451 NULL -533395388 1988498006464 919940926 9.19940062743E8 NULL NULL NULL 1.0 9.19940089023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1039715238 NULL NULL oOt2v true -51 -51.0 1969-12-31 16:00:08.451 NULL -86361999 321957532272 1039715238 1.039714374743E9 NULL NULL NULL 1.0 1.039714401023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-733761968 NULL NULL c23S6Ky4w7Ld21lAbB true -51 -51.0 1969-12-31 16:00:08.451 NULL -713098110 2658429754080 733761968 7.33761104743E8 NULL NULL NULL 1.0 7.33761131023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-731427364 NULL NULL cb33ksHDf3lMrp0OW4dMdvos false -51 -51.0 1969-12-31 16:00:08.451 NULL -712994897 2658044976016 731427364 7.31426500743E8 NULL NULL NULL 1.0 7.31426527023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-954917203 NULL NULL 1M4eTm8OcOW2dAMV2V5slS1 true -51 -51.0 1969-12-31 16:00:08.451 NULL -710267209 2647876155152 954917203 9.54916339743E8 NULL NULL NULL 1.0 9.54916366023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-848947717 NULL NULL 34o2M3 false -51 -51.0 1969-12-31 16:00:08.451 NULL -150416216 560751653248 848947717 8.48946853743E8 NULL NULL NULL 1.0 8.48946880023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-738306196 NULL NULL NULL false -51 -51.0 1969-12-31 16:00:08.451 NULL -460430946 1716486566688 738306196 7.38305332743E8 NULL NULL NULL 1.0 7.38305359023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-647247257 NULL NULL 2C1S7MUYL5NWPARvQU false -51 -51.0 1969-12-31 16:00:08.451 NULL -450614378 1679890401184 647247257 6.47246393743E8 NULL NULL NULL 1.0 6.47246420023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-833225522 NULL NULL f448c4T81BR true -51 -51.0 1969-12-31 16:00:08.451 NULL -789796482 2944361284896 833225522 8.33224658743E8 NULL NULL NULL 1.0 8.33224685023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-413196097 NULL NULL NULL false -51 -51.0 1969-12-31 16:00:08.451 NULL -306198070 1141506404960 413196097 4.13195233743E8 NULL NULL NULL 1.0 4.1319526002299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-637509859 NULL NULL hCwu446fq4108mQ4x62Pr true -51 -51.0 1969-12-31 16:00:08.451 NULL -135810777 506302576656 637509859 6.37508995743E8 NULL NULL NULL 1.0 6.37509022023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-766298505 NULL NULL tKyw2O2N true -51 -51.0 1969-12-31 16:00:08.451 NULL -268630738 1001455391264 766298505 7.66297641743E8 NULL NULL NULL 1.0 7.66297668023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-887750610 NULL NULL ffT4cTjYf2NJ false -51 -51.0 1969-12-31 16:00:08.451 NULL -273952073 1021293328144 887750610 8.87749746743E8 NULL NULL NULL 1.0 8.87749773023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1003789565 NULL NULL dq1Ji5vGb4GVow42 false -51 -51.0 1969-12-31 16:00:08.451 NULL -505400643 1884133597104 1003789565 1.003788701743E9 NULL NULL NULL 1.0 1.003788728023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-319901788 NULL NULL q2bIHkxaKKv7uD false -51 -51.0 1969-12-31 16:00:08.451 NULL -149775876 558364465728 319901788 3.19900924743E8 NULL NULL NULL 1.0 3.1990095102299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-688179977 NULL NULL b true -51 -51.0 1969-12-31 16:00:08.451 NULL -6432 23978496 688179977 6.88179113743E8 NULL NULL NULL 1.0 6.88179140023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-460130999 NULL NULL 704TqKdO554m38WDk0W2g true -51 -51.0 1969-12-31 16:00:08.451 NULL -133397676 497306536128 460130999 4.60130135743E8 NULL NULL NULL 1.0 4.6013016202299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-435127410 NULL NULL 0CkUHn44bl6xbyYLk false -51 -51.0 1969-12-31 16:00:08.451 NULL -403415728 1503933833984 435127410 4.35126546743E8 NULL NULL NULL 1.0 4.3512657302299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-109479877 NULL NULL 4LQe2Pd4m640E58XFA true -51 -51.0 1969-12-31 16:00:08.451 NULL -17223890 64210661920 109479877 1.09479013743E8 NULL NULL NULL 1.0 1.09479040023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-316619185 NULL NULL 33cr1j true -51 -51.0 1969-12-31 16:00:08.451 NULL -223513974 833260095072 316619185 3.16618321743E8 NULL NULL NULL 1.0 3.1661834802299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-925336063 NULL NULL 060EnWLmWE4K8Pv false -51 -51.0 1969-12-31 16:00:08.451 NULL -477173411 1778902476208 925336063 9.25335199743E8 NULL NULL NULL 1.0 9.25335226023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-395475456 NULL NULL olV01YmQ01kUvC3EE85C0E false -51 -51.0 1969-12-31 16:00:08.451 NULL -12686112 47293825536 395475456 3.95474592743E8 NULL NULL NULL 1.0 3.9547461902299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-980072140 NULL NULL Jt7E0sR3X7V true -51 -51.0 1969-12-31 16:00:08.451 NULL -819889345 3056547478160 980072140 9.80071276743E8 NULL NULL NULL 1.0 9.80071303023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-726087078 NULL NULL qNaAh8CdJxxTG8y0 true -51 -51.0 1969-12-31 16:00:08.451 NULL -622509800 2320716534400 726087078 7.26086214743E8 NULL NULL NULL 1.0 7.26086241023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-239791677 NULL NULL 76Xl5E7ttiejsqcvfJmtNB0 true -51 -51.0 1969-12-31 16:00:08.451 NULL -54067111 201562189808 239791677 2.39790813743E8 NULL NULL NULL 1.0 2.39790840023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-457111770 NULL NULL F10SR3l5836pq7TCfYeGrEl1 true -51 -51.0 1969-12-31 16:00:08.451 NULL -107200626 399643933728 457111770 4.57110906743E8 NULL NULL NULL 1.0 4.5711093302299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1000804087 NULL NULL H8LCu4M2u4f1S true -51 -51.0 1969-12-31 16:00:08.451 NULL -873515594 3256466134432 1000804087 1.000803223743E9 NULL NULL NULL 1.0 1.000803250023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-1060624784 NULL NULL Das7E73 true -51 -51.0 1969-12-31 16:00:08.451 NULL -941434751 3509668751728 1060624784 1.060623920743E9 NULL NULL NULL 1.0 1.060623947023E9 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-602640740 NULL NULL s1K04o1 false -51 -51.0 1969-12-31 16:00:08.451 NULL -22423082 83593249696 602640740 6.02639876743E8 NULL NULL NULL 1.0 6.02639903023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-635141101 NULL NULL ss true -51 -51.0 1969-12-31 16:00:08.451 NULL -89010 331829280 635141101 6.35140237743E8 NULL NULL NULL 1.0 6.35140264023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-622956305 NULL NULL b4iTs false -51 -51.0 1969-12-31 16:00:08.451 NULL -485595911 1810301556208 622956305 6.22955441743E8 NULL NULL NULL 1.0 6.22955468023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-363032626 NULL NULL 0f4422CBSl true -51 -51.0 1969-12-31 16:00:08.451 NULL -73528173 274113028944 363032626 3.63031762743E8 NULL NULL NULL 1.0 3.6303178902299994E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-816457176 NULL NULL Dk6tb8PWF643qyp258O2 true -51 -51.0 1969-12-31 16:00:08.451 NULL -375462240 1399723230720 816457176 8.16456312743E8 NULL NULL NULL 1.0 8.16456339023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-264683279 NULL NULL sU7rit true -51 -51.0 1969-12-31 16:00:08.451 NULL -19844206 73979199968 264683279 2.64682415743E8 NULL NULL NULL 1.0 2.64682442023E8 51.0 NULL -5.157308006568995E-5 51 -1.5598627450980391 +-410541035 NULL NULL eDfHPeW364TY4A2Jhm true 8 8.0 1969-12-31 16:00:15.892 NULL -223774943 834232987504 410541035 4.10540171743E8 NULL NULL NULL 1.0 4.1054019802299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-436323820 NULL NULL p3DvmcsqP6xMf false 8 8.0 1969-12-31 16:00:15.892 NULL -333338916 1242687478848 436323820 4.36322956743E8 NULL NULL NULL 1.0 4.3632298302299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-932998902 NULL NULL kAr0ffWGEU7MHSKp true 8 8.0 1969-12-31 16:00:15.892 NULL -230462122 859162790816 932998902 9.32998038743E8 NULL NULL NULL 1.0 9.32998065023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-205395916 NULL NULL 2V6VBAtpi0QQD true 8 8.0 1969-12-31 16:00:15.892 NULL -8537604 31828187712 205395916 2.05395052743E8 NULL NULL NULL 1.0 2.05395079023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-617263915 NULL NULL 8IgBmN0xkLDIlj2y false 8 8.0 1969-12-31 16:00:15.892 NULL -319213460 1190027778880 617263915 6.17263051743E8 NULL NULL NULL 1.0 6.17263078023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1058897881 NULL NULL 6fPk0A false 8 8.0 1969-12-31 16:00:15.892 NULL -800997317 2986117997776 1058897881 1.058897017743E9 NULL NULL NULL 1.0 1.058897044023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-718664327 NULL NULL tm85HNL7au4na false 8 8.0 1969-12-31 16:00:15.892 NULL -142426080 530964426240 718664327 7.18663463743E8 NULL NULL NULL 1.0 7.18663490023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-799860725 NULL NULL b01GFHiSj4Yig1tk4bSex true 8 8.0 1969-12-31 16:00:15.892 NULL -87733477 327070402256 799860725 7.99859861743E8 NULL NULL NULL 1.0 7.99859888023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-752438482 NULL NULL 0rNlSy15Xy1Sx true 8 8.0 1969-12-31 16:00:15.892 NULL -407346886 1518589191008 752438482 7.52437618743E8 NULL NULL NULL 1.0 7.52437645023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-603601682 NULL NULL poE6hx8xV36vG true 8 8.0 1969-12-31 16:00:15.892 NULL -24030296 89584943488 603601682 6.03600818743E8 NULL NULL NULL 1.0 6.03600845023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-743039371 NULL NULL v5Ai3KlB6mT false 8 8.0 1969-12-31 16:00:15.892 NULL -411191076 1532920331328 743039371 7.43038507743E8 NULL NULL NULL 1.0 7.43038534023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-20301111 NULL NULL e13dNAo71UXm4Yt1u false 8 8.0 1969-12-31 16:00:15.892 NULL -19748892 73623869376 20301111 2.0300247743E7 NULL NULL NULL 1.0 2.0300274023000002E7 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-466511459 NULL NULL qny4OOT34x7XVrWp5Eh true 8 8.0 1969-12-31 16:00:15.892 NULL -228360387 851327522736 466511459 4.66510595743E8 NULL NULL NULL 1.0 4.6651062202299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-851067861 NULL NULL lD0h1L8852501n false 8 8.0 1969-12-31 16:00:15.892 NULL -294767825 1098894451600 851067861 8.51066997743E8 NULL NULL NULL 1.0 8.51067024023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-883321517 NULL NULL RJsFsi3a85svGBfT8 true 8 8.0 1969-12-31 16:00:15.892 NULL -738731063 2753989402864 883321517 8.83320653743E8 NULL NULL NULL 1.0 8.83320680023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-528897930 NULL NULL TNaUMA6If0kmHQp2xRhqr false 8 8.0 1969-12-31 16:00:15.892 NULL -438530877 1634843109456 528897930 5.28897066743E8 NULL NULL NULL 1.0 5.2889709302299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-380359762 NULL NULL bfE8u5XQPK7ie4o6wE1Tfv true 8 8.0 1969-12-31 16:00:15.892 NULL -74313673 277041372944 380359762 3.80358898743E8 NULL NULL NULL 1.0 3.8035892502299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-441306270 NULL NULL iEb04t2x333EF5wHoKRs6oKB false 8 8.0 1969-12-31 16:00:15.892 NULL -333509919 1243324978032 441306270 4.41305406743E8 NULL NULL NULL 1.0 4.4130543302299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-712811861 NULL NULL qC2BA3oYp true 8 8.0 1969-12-31 16:00:15.892 NULL -56014923 208823632944 712811861 7.12810997743E8 NULL NULL NULL 1.0 7.12811024023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-433146870 NULL NULL mw3S8 true 8 8.0 1969-12-31 16:00:15.892 NULL -410751871 1531282975088 433146870 4.33146006743E8 NULL NULL NULL 1.0 4.3314603302299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-852864663 NULL NULL bMKsgu5OdWu4vjTa1nt true 8 8.0 1969-12-31 16:00:15.892 NULL -762739286 2843492058208 852864663 8.52863799743E8 NULL NULL NULL 1.0 8.52863826023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-353397036 NULL NULL 3LWXOlGelGXQu64Lxws true 8 8.0 1969-12-31 16:00:15.892 NULL -319840080 1192363818240 353397036 3.53396172743E8 NULL NULL NULL 1.0 3.5339619902299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-596721652 NULL NULL 07Hofhidd5ClnNx8jTl1 true 8 8.0 1969-12-31 16:00:15.892 NULL -70511540 262867021120 596721652 5.96720788743E8 NULL NULL NULL 1.0 5.96720815023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-718063540 NULL NULL 1wb02g3mc true 8 8.0 1969-12-31 16:00:15.892 NULL -429105776 1599706332928 718063540 7.18062676743E8 NULL NULL NULL 1.0 7.18062703023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-616147774 NULL NULL PUjn241mg3Qfjj6nG51 true 8 8.0 1969-12-31 16:00:15.892 NULL -98989966 369034593248 616147774 6.16146910743E8 NULL NULL NULL 1.0 6.16146937023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-792520485 NULL NULL rhOWNGEuth8f875WLX false 8 8.0 1969-12-31 16:00:15.892 NULL -712238882 2655226552096 792520485 7.92519621743E8 NULL NULL NULL 1.0 7.92519648023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-863239524 NULL NULL Nr3652 false 8 8.0 1969-12-31 16:00:15.892 NULL -302672812 1128364243136 863239524 8.63238660743E8 NULL NULL NULL 1.0 8.63238687023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-767080360 NULL NULL 5dENnx6VjU14iaLFV0IR true 8 8.0 1969-12-31 16:00:15.892 NULL -725406408 2704315089024 767080360 7.67079496743E8 NULL NULL NULL 1.0 7.67079523023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-605065222 NULL NULL GciA5Y0kP true 8 8.0 1969-12-31 16:00:15.892 NULL -73703653 274767218384 605065222 6.05064358743E8 NULL NULL NULL 1.0 6.05064385023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1063164541 NULL NULL 1NydRD5y5o3 false 8 8.0 1969-12-31 16:00:15.892 NULL -74907656 279255741568 1063164541 1.063163677743E9 NULL NULL NULL 1.0 1.063163704023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-965597463 NULL NULL b0G65a66732y6yE65hQ0 false 8 8.0 1969-12-31 16:00:15.892 NULL -922745115 3439993788720 965597463 9.65596599743E8 NULL NULL NULL 1.0 9.65596626023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-286232918 NULL NULL DuLQkL6 true 8 8.0 1969-12-31 16:00:15.892 NULL -70839972 264091415616 286232918 2.86232054743E8 NULL NULL NULL 1.0 2.8623208102299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-845450039 NULL NULL HG52N6amN false 8 8.0 1969-12-31 16:00:15.892 NULL -374765565 1397126026320 845450039 8.45449175743E8 NULL NULL NULL 1.0 8.45449202023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-853693520 NULL NULL i6G060 true 8 8.0 1969-12-31 16:00:15.892 NULL -683211043 2547010768304 853693520 8.53692656743E8 NULL NULL NULL 1.0 8.53692683023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-575848794 NULL NULL H37833CDTytf1mp4 false 8 8.0 1969-12-31 16:00:15.892 NULL -510322821 1902483476688 575848794 5.75847930743E8 NULL NULL NULL 1.0 5.75847957023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-654132946 NULL NULL 1emD5WuAWePl22 true 8 8.0 1969-12-31 16:00:15.892 NULL -35916257 133895806096 654132946 6.54132082743E8 NULL NULL NULL 1.0 6.54132109023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-885777373 NULL NULL F3wAY4D4XxYt true 8 8.0 1969-12-31 16:00:15.892 NULL -582564574 2171800731872 885777373 8.85776509743E8 NULL NULL NULL 1.0 8.85776536023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-388258881 NULL NULL EjY6DSn57x1v5h false 8 8.0 1969-12-31 16:00:15.892 NULL -316801619 1181036435632 388258881 3.88258017743E8 NULL NULL NULL 1.0 3.8825804402299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1020120834 NULL NULL 6Ob80MBP350rI275 true 8 8.0 1969-12-31 16:00:15.892 NULL -100465694 374536107232 1020120834 1.020119970743E9 NULL NULL NULL 1.0 1.020119997023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-448325367 NULL NULL v0uSTRyX5A4W false 8 8.0 1969-12-31 16:00:15.892 NULL -208895713 778763218064 448325367 4.48324503743E8 NULL NULL NULL 1.0 4.4832453002299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-831468557 NULL NULL 5ealv0e6tmDnoS0bOmX false 8 8.0 1969-12-31 16:00:15.892 NULL -376760963 1404564870064 831468557 8.31467693743E8 NULL NULL NULL 1.0 8.31467720023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-993291633 NULL NULL 8reJCOg48gHGHDs true 8 8.0 1969-12-31 16:00:15.892 NULL -861531376 3211788969728 993291633 9.93290769743E8 NULL NULL NULL 1.0 9.93290796023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-448180672 NULL NULL BJTr1JVEjCQMQ0 false 8 8.0 1969-12-31 16:00:15.892 NULL -301072095 1122396770160 448180672 4.48179808743E8 NULL NULL NULL 1.0 4.4817983502299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-848015950 NULL NULL 6shc3Y true 8 8.0 1969-12-31 16:00:15.892 NULL -397174440 1480666312320 848015950 8.48015086743E8 NULL NULL NULL 1.0 8.48015113023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-928500968 NULL NULL 34oSgU32X true 8 8.0 1969-12-31 16:00:15.892 NULL -831143834 3098504213152 928500968 9.28500104743E8 NULL NULL NULL 1.0 9.28500131023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1016835101 NULL NULL Md2lY0T7reBu false 8 8.0 1969-12-31 16:00:15.892 NULL -491294009 1831544065552 1016835101 1.016834237743E9 NULL NULL NULL 1.0 1.016834264023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-173590840 NULL NULL C77Mm2Bv5tV32bB3IHK true 8 8.0 1969-12-31 16:00:15.892 NULL -8056960 30036346880 173590840 1.73589976743E8 NULL NULL NULL 1.0 1.73590003023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-221091443 NULL NULL 5EjVb30Y5 false 8 8.0 1969-12-31 16:00:15.892 NULL -121073279 451361184112 221091443 2.21090579743E8 NULL NULL NULL 1.0 2.21090606023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-660093358 NULL NULL jH7VH38C77M08h5GNPp8M false 8 8.0 1969-12-31 16:00:15.892 NULL -28334114 105629576992 660093358 6.60092494743E8 NULL NULL NULL 1.0 6.60092521023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-522373381 NULL NULL 0AkI4K24GeFC1Aa2Sr6 false 8 8.0 1969-12-31 16:00:15.892 NULL -17631238 65729255264 522373381 5.22372517743E8 NULL NULL NULL 1.0 5.2237254402299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1068247011 NULL NULL dPbX4jd1v47r1bB6506si false 8 8.0 1969-12-31 16:00:15.892 NULL -729456614 2719414256992 1068247011 1.068246147743E9 NULL NULL NULL 1.0 1.068246174023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-381027711 NULL NULL VU42OCI8nDXA0M false 8 8.0 1969-12-31 16:00:15.892 NULL -292812099 1091603505072 381027711 3.81026847743E8 NULL NULL NULL 1.0 3.8102687402299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1049984461 NULL NULL qUY8Rl34NWRg false 8 8.0 1969-12-31 16:00:15.892 NULL -247067895 921069112560 1049984461 1.049983597743E9 NULL NULL NULL 1.0 1.049983624023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-485104169 NULL NULL aecE60o4 true 8 8.0 1969-12-31 16:00:15.892 NULL -276230204 1029786200512 485104169 4.85103305743E8 NULL NULL NULL 1.0 4.8510333202299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-727158360 NULL NULL 0uA7It5CJu16eJ4JS1uuxNJ false 8 8.0 1969-12-31 16:00:15.892 NULL -89010 331829280 727158360 7.27157496743E8 NULL NULL NULL 1.0 7.27157523023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-923400421 NULL NULL MJ7Ej4tBYS8l2mK true 8 8.0 1969-12-31 16:00:15.892 NULL -67708318 252416609504 923400421 9.23399557743E8 NULL NULL NULL 1.0 9.23399584023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-980511555 NULL NULL 1TBB2v0eBqlr4c7d true 8 8.0 1969-12-31 16:00:15.892 NULL -890261594 3318895222432 980511555 9.80510691743E8 NULL NULL NULL 1.0 9.80510718023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1039495786 NULL NULL b0BEyNEe1bvQ true 8 8.0 1969-12-31 16:00:15.892 NULL -760564106 2835382987168 1039495786 1.039494922743E9 NULL NULL NULL 1.0 1.039494949023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-335475138 NULL NULL TrVt3076w4QSXF83Io true 8 8.0 1969-12-31 16:00:15.892 NULL -205461721 765961295888 335475138 3.35474274743E8 NULL NULL NULL 1.0 3.3547430102299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-937557606 NULL NULL 2251WSv5eA2l6WqesdKPM2 true 8 8.0 1969-12-31 16:00:15.892 NULL -532708003 1985935435184 937557606 9.37556742743E8 NULL NULL NULL 1.0 9.37556769023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-301678323 NULL NULL C63fh05R7De33TmqtehvIfxv true 8 8.0 1969-12-31 16:00:15.892 NULL -54080756 201613058368 301678323 3.01677459743E8 NULL NULL NULL 1.0 3.0167748602299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-914887396 NULL NULL o2IY6 true 8 8.0 1969-12-31 16:00:15.892 NULL -558119393 2080669097104 914887396 9.14886532743E8 NULL NULL NULL 1.0 9.14886559023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-188165330 NULL NULL 22RO52O0M1M01M0Uk74eGx false 8 8.0 1969-12-31 16:00:15.892 NULL -63118955 235307464240 188165330 1.88164466743E8 NULL NULL NULL 1.0 1.88164493023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-298110501 NULL NULL JKmY3010a4e false 8 8.0 1969-12-31 16:00:15.892 NULL -159906495 596131413360 298110501 2.98109637743E8 NULL NULL NULL 1.0 2.9810966402299994E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-600422927 NULL NULL A30e7a8ia36g25YQc8xTXBgB true 8 8.0 1969-12-31 16:00:15.892 NULL -478703183 1784605466224 600422927 6.00422063743E8 NULL NULL NULL 1.0 6.00422090023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-819152895 NULL NULL NULL true 8 8.0 1969-12-31 16:00:15.892 NULL -67009042 249809708576 819152895 8.19152031743E8 NULL NULL NULL 1.0 8.19152058023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1046913669 NULL NULL 40r4yyU6T0A0Mekf24k false 8 8.0 1969-12-31 16:00:15.892 NULL -90393132 336985596096 1046913669 1.046912805743E9 NULL NULL NULL 1.0 1.046912832023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-596698349 NULL NULL 142kQq4fbeX3mT false 8 8.0 1969-12-31 16:00:15.892 NULL -423275825 1577972275600 596698349 5.96697485743E8 NULL NULL NULL 1.0 5.96697512023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1039292315 NULL NULL 07488p5vb4d2 true 8 8.0 1969-12-31 16:00:15.892 NULL -432155916 1611077254848 1039292315 1.039291451743E9 NULL NULL NULL 1.0 1.039291478023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1024321144 NULL NULL CE22Wjuk7d20ouN true 8 8.0 1969-12-31 16:00:15.892 NULL -94624654 352760710112 1024321144 1.024320280743E9 NULL NULL NULL 1.0 1.024320307023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1058286942 NULL NULL R6q656btrqQM6a5nQ4GcVg true 8 8.0 1969-12-31 16:00:15.892 NULL -922041114 3437369272992 1058286942 1.058286078743E9 NULL NULL NULL 1.0 1.058286105023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-43263468 NULL NULL 2Amg22mSeD4C6OL64 false 8 8.0 1969-12-31 16:00:15.892 NULL -645672 2407065216 43263468 4.3262604743E7 NULL NULL NULL 1.0 4.3262631023E7 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-711576614 NULL NULL cb5LPuiF true 8 8.0 1969-12-31 16:00:15.892 NULL -534956316 1994317146048 711576614 7.11575750743E8 NULL NULL NULL 1.0 7.11575777023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-1063745167 NULL NULL L47nqo true 8 8.0 1969-12-31 16:00:15.892 NULL -68741114 256266872992 1063745167 1.063744303743E9 NULL NULL NULL 1.0 1.063744330023E9 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +-670908417 NULL NULL NULL false 8 8.0 1969-12-31 16:00:15.892 NULL -228957331 853552929968 670908417 6.70907553743E8 NULL NULL NULL 1.0 6.70907580023E8 -8.0 NULL 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -44 -44.0 1969-12-31 16:00:00.247 -7196 1752212736 -6532249079808 NULL NULL 7196 -14392 -7196 NULL NULL 44.0 6.4051596E8 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 15:59:55.105 -7196 -556482589 2074567091792 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 15:59:53.129 -7196 -115057207 428933267696 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 11 11.0 1969-12-31 16:00:08.857 -7196 -1887946332 7038263925696 NULL NULL 7196 -14392 -7196 NULL NULL -11.0 6.4051596E8 1.1123605504364498E-5 -11 7.232090909090909 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 18 18.0 1969-12-31 16:00:05.804 -7196 423975149 -1580579355472 NULL NULL 7196 -14392 -7196 NULL NULL -18.0 6.4051596E8 1.820226355259645E-5 -18 4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 11 11.0 1969-12-31 15:59:54.133 -7196 1182969108 -4410108834624 NULL NULL 7196 -14392 -7196 NULL NULL -11.0 6.4051596E8 1.1123605504364498E-5 -11 7.232090909090909 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 15:59:50.54 -7196 -741906438 2765827200864 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:00.754 -7196 1237005923 -4611558080944 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 10 10.0 1969-12-31 15:59:58.876 -7196 -543560979 2026395329712 NULL NULL 7196 -14392 -7196 NULL NULL -10.0 6.4051596E8 1.0112368640331362E-5 -10 7.955299999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 16:00:07.588 -7196 -2036513617 7592122764176 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 40 40.0 1969-12-31 16:00:08.06 -7196 -916017240 3414912270720 NULL NULL 7196 -14392 -7196 NULL NULL -40.0 6.4051596E8 4.044947456132545E-5 -40 1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 51 51.0 1969-12-31 16:00:10.321 -7196 1836737728 -6847358249984 NULL NULL 7196 -14392 -7196 NULL NULL -51.0 6.4051596E8 5.157308006568995E-5 -51 1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 16:00:06.132 -7196 1442623588 -5378100736064 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 15:59:57.86 -7196 -26309289 98081029392 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -15 -15.0 1969-12-31 15:59:55.626 -7196 1509584426 -5627730740128 NULL NULL 7196 -14392 -7196 NULL NULL 15.0 6.4051596E8 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 35 35.0 1969-12-31 16:00:11.356 -7196 1004273023 -3743929829744 NULL NULL 7196 -14392 -7196 NULL NULL -35.0 6.4051596E8 3.5393290241159765E-5 -35 2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -25 -25.0 1969-12-31 15:59:50.595 -7196 439358934 -1637930105952 NULL NULL 7196 -14392 -7196 NULL NULL 25.0 6.4051596E8 -2.5280921600828406E-5 25 -3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 15:59:52.31 -7196 -662490261 2469763693008 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -8 -8.0 1969-12-31 15:59:43.874 -7196 -1877568778 6999576404384 NULL NULL 7196 -14392 -7196 NULL NULL 8.0 6.4051596E8 -8.08989491226509E-6 8 -9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 31 31.0 1969-12-31 16:00:01.849 -7196 100195163 -373527567664 NULL NULL 7196 -14392 -7196 NULL NULL -31.0 6.4051596E8 3.134834278502722E-5 -31 2.566225806451613 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:11.402 -7196 2125230435 -7922859061680 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -58 -58.0 1969-12-31 15:59:47.859 -7196 -1770443874 6600214762272 NULL NULL 7196 -14392 -7196 NULL NULL 58.0 6.4051596E8 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 38 38.0 1969-12-31 15:59:57.048 -7196 806488245 -3006588177360 NULL NULL 7196 -14392 -7196 NULL NULL -38.0 6.4051596E8 3.842700083325918E-5 -38 2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:15.004 -7196 -653683931 2436933694768 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -53 -53.0 1969-12-31 16:00:11.36 -7196 -1357789899 5061840743472 NULL NULL 7196 -14392 -7196 NULL NULL 53.0 6.4051596E8 -5.359555379375622E-5 53 -1.501 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 28 28.0 1969-12-31 16:00:06.092 -7196 -776650874 2895354458272 NULL NULL 7196 -14392 -7196 NULL NULL -28.0 6.4051596E8 2.8314632192927813E-5 -28 2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -9 -9.0 1969-12-31 16:00:13.473 -7196 1650584069 -6153377409232 NULL NULL 7196 -14392 -7196 NULL NULL 9.0 6.4051596E8 -9.101131776298225E-6 9 -8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 15:59:44.947 -7196 -550152914 2050970063392 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 15:59:58.214 -7196 974109477 -3631480130256 NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -32 -32.0 1969-12-31 16:00:00.527 -7196 -408156678 1521608095584 NULL NULL 7196 -14392 -7196 NULL NULL 32.0 6.4051596E8 -3.235957964906036E-5 32 -2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 15:59:48.12 -7196 1658892440 -6184351016320 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -59 -59.0 1969-12-31 16:00:13.15 -7196 -1604890000 5983029920000 NULL NULL 7196 -14392 -7196 NULL NULL 59.0 6.4051596E8 -5.966297497795504E-5 59 -1.3483559322033898 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 15:59:48.734 -7196 1602156586 -5972839752608 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 16:00:07.333 -7196 -244388115 911078892720 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -30 -30.0 1969-12-31 15:59:44.281 -7196 1385303486 -5164411395808 NULL NULL 7196 -14392 -7196 NULL NULL 30.0 6.4051596E8 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -60 -60.0 1969-12-31 16:00:10.618 -7196 -68838726 256630770528 NULL NULL 7196 -14392 -7196 NULL NULL 60.0 6.4051596E8 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 46 46.0 1969-12-31 16:00:05.226 -7196 275575541 -1027345616848 NULL NULL 7196 -14392 -7196 NULL NULL -46.0 6.4051596E8 4.651689574552426E-5 -46 1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -38 -38.0 1969-12-31 16:00:01.282 -7196 528807212 -1971393286336 NULL NULL 7196 -14392 -7196 NULL NULL 38.0 6.4051596E8 -3.842700083325918E-5 38 -2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -6 -6.0 1969-12-31 15:59:58.329 -7196 -1416094043 5279198592304 NULL NULL 7196 -14392 -7196 NULL NULL 6.0 6.4051596E8 -6.067421184198818E-6 6 -13.258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 17 17.0 1969-12-31 16:00:02.436 -7196 -504009135 1878946055280 NULL NULL 7196 -14392 -7196 NULL NULL -17.0 6.4051596E8 1.7191026688563315E-5 -17 4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 16:00:05.43 -7196 1826915108 -6810739522624 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 15:59:55.9 -7196 1542429000 -5750175312000 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -5 -5.0 1969-12-31 16:00:16.107 -7196 1569040903 -5849384486384 NULL NULL 7196 -14392 -7196 NULL NULL 5.0 6.4051596E8 -5.056184320165681E-6 5 -15.910599999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 18 18.0 1969-12-31 15:59:55.065 -7196 667671386 -2489078927008 NULL NULL 7196 -14392 -7196 NULL NULL -18.0 6.4051596E8 1.820226355259645E-5 -18 4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -20 -20.0 1969-12-31 15:59:53.648 -7196 -304452756 1134999874368 NULL NULL 7196 -14392 -7196 NULL NULL 20.0 6.4051596E8 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -2 -2.0 1969-12-31 16:00:06.498 -7196 1604468020 -5981456778560 NULL NULL 7196 -14392 -7196 NULL NULL 2.0 6.4051596E8 -2.0224737280662724E-6 2 -39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 33 79.553 1969-12-31 16:00:00.761 -7196 514550698 -1918245002144 NULL NULL 7196 -14392 -7196 NULL NULL -79.553 6.4051596E8 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 16:00:08.171 -7196 -1216208847 4534026581616 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -5 -5.0 1969-12-31 15:59:43.948 -7196 -1556798997 5803746660816 NULL NULL 7196 -14392 -7196 NULL NULL 5.0 6.4051596E8 -5.056184320165681E-6 5 -15.910599999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 18 18.0 1969-12-31 15:59:43.854 -7196 307005585 -1144516820880 NULL NULL 7196 -14392 -7196 NULL NULL -18.0 6.4051596E8 1.820226355259645E-5 -18 4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 15:59:46.019 -7196 1086107721 -4049009583888 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 12 12.0 1969-12-31 15:59:49.316 -7196 503273510 -1876203645280 NULL NULL 7196 -14392 -7196 NULL NULL -12.0 6.4051596E8 1.2134842368397635E-5 -12 6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 26 26.0 1969-12-31 16:00:04.233 -7196 -607051573 2263088264144 NULL NULL 7196 -14392 -7196 NULL NULL -26.0 6.4051596E8 2.629215846486154E-5 -26 3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 51 51.0 1969-12-31 16:00:15.668 -7196 2091591361 -7797452593808 NULL NULL 7196 -14392 -7196 NULL NULL -51.0 6.4051596E8 5.157308006568995E-5 -51 1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -60 -60.0 1969-12-31 15:59:52.408 -7196 1516314750 -5652821388000 NULL NULL 7196 -14392 -7196 NULL NULL 60.0 6.4051596E8 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 16:00:03.506 -7196 1893922957 -7060544783696 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -33 -33.0 1969-12-31 16:00:10.959 -7196 1689322288 -6297793489664 NULL NULL 7196 -14392 -7196 NULL NULL 33.0 6.4051596E8 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 15:59:48.035 -7196 1237548317 -4613580125776 NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 48 48.0 1969-12-31 16:00:16.19 -7196 624835112 -2329385297536 NULL NULL 7196 -14392 -7196 NULL NULL -48.0 6.4051596E8 4.853936947359054E-5 -48 1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 37 37.0 1969-12-31 15:59:53.876 -7196 -1880066724 7008888747072 NULL NULL 7196 -14392 -7196 NULL NULL -37.0 6.4051596E8 3.741576396922604E-5 -37 2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:09.441 -7196 632897807 -2359443024496 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -14 -14.0 1969-12-31 16:00:11.065 -7196 -1552199500 5786599736000 NULL NULL 7196 -14392 -7196 NULL NULL 14.0 6.4051596E8 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 56 56.0 1969-12-31 15:59:55.667 -7196 -2145481991 7998356862448 NULL NULL 7196 -14392 -7196 NULL NULL -56.0 6.4051596E8 5.6629264385855625E-5 -56 1.4205892857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 15:59:46.891 -7196 -1653550667 6164436886576 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -19 -19.0 1969-12-31 16:00:03.381 -7196 733482783 -2734423815024 NULL NULL 7196 -14392 -7196 NULL NULL 19.0 6.4051596E8 -1.921350041662959E-5 19 -4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 34 34.0 1969-12-31 15:59:58.264 -7196 -624089536 2326605790208 NULL NULL 7196 -14392 -7196 NULL NULL -34.0 6.4051596E8 3.438205337712663E-5 -34 2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 15:59:52.092 -7196 1693400306 -6312996340768 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -50 -50.0 1969-12-31 15:59:52.424 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 50.0 6.4051596E8 -5.056184320165681E-5 50 -1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -47 -47.0 1969-12-31 16:00:10.274 -7196 1481273634 -5522188107552 NULL NULL 7196 -14392 -7196 NULL NULL 47.0 6.4051596E8 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:03.544 -7196 -1475373169 5500191174032 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 9 9.0 1969-12-31 15:59:48.083 -7196 153657865 -572836520720 NULL NULL 7196 -14392 -7196 NULL NULL -9.0 6.4051596E8 9.101131776298225E-6 -9 8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 15:59:51.992 -7196 -846262106 3154865131168 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -18 -18.0 1969-12-31 15:59:51.453 -7196 1088538866 -4058072892448 NULL NULL 7196 -14392 -7196 NULL NULL 18.0 6.4051596E8 -1.820226355259645E-5 18 -4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 15:59:58.615 -7196 2121169664 -7907720507392 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 59 59.0 1969-12-31 16:00:03.671 -7196 -950636550 3543973058400 NULL NULL 7196 -14392 -7196 NULL NULL -59.0 6.4051596E8 5.966297497795504E-5 -59 1.3483559322033898 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -26 -26.0 1969-12-31 15:59:46.847 -7196 -71373423 266080120944 NULL NULL 7196 -14392 -7196 NULL NULL 26.0 6.4051596E8 -2.629215846486154E-5 26 -3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 27 27.0 1969-12-31 15:59:56.31 -7196 1007177734 -3754758592352 NULL NULL 7196 -14392 -7196 NULL NULL -27.0 6.4051596E8 2.7303395328894677E-5 -27 2.946407407407407 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 33 33.0 1969-12-31 16:00:07.421 -7196 -1679016561 6259373739408 NULL NULL 7196 -14392 -7196 NULL NULL -33.0 6.4051596E8 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -24 -24.0 1969-12-31 16:00:08.839 -7196 733639253 -2735007135184 NULL NULL 7196 -14392 -7196 NULL NULL 24.0 6.4051596E8 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 15:59:45.811 -7196 -595634900 2220526907200 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 42 42.0 1969-12-31 16:00:16.251 -7196 -1981638429 7387548063312 NULL NULL 7196 -14392 -7196 NULL NULL -42.0 6.4051596E8 4.247194828939172E-5 -42 1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 7 7.0 1969-12-31 16:00:13.807 -7196 772100395 -2878390272560 NULL NULL 7196 -14392 -7196 NULL NULL -7.0 6.4051596E8 7.078658048231953E-6 -7 11.364714285714285 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -46 -46.0 1969-12-31 16:00:07.744 -7196 -1737647990 6477951706720 NULL NULL 7196 -14392 -7196 NULL NULL 46.0 6.4051596E8 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 32 32.0 1969-12-31 16:00:15.868 -7196 -1323995873 4935856614544 NULL NULL 7196 -14392 -7196 NULL NULL -32.0 6.4051596E8 3.235957964906036E-5 -32 2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 15:59:49.304 -7196 -1105725122 4122143254816 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 16:00:08.615 -7196 965505355 -3599403963440 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 55 55.0 1969-12-31 15:59:56.568 -7196 468599417 -1746938626576 NULL NULL 7196 -14392 -7196 NULL NULL -55.0 6.4051596E8 5.561802752182249E-5 -55 1.4464181818181818 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -58 -58.0 1969-12-31 15:59:55.857 -7196 -825174557 3076250748496 NULL NULL 7196 -14392 -7196 NULL NULL 58.0 6.4051596E8 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 16:00:12.454 -7196 -2175533 8110387024 NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -57 -57.0 1969-12-31 15:59:44.539 -7196 1839592407 -6858000493296 NULL NULL 7196 -14392 -7196 NULL NULL 57.0 6.4051596E8 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -42 -42.0 1969-12-31 15:59:45.244 -7196 -1235289105 4605157783440 NULL NULL 7196 -14392 -7196 NULL NULL 42.0 6.4051596E8 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -47 -47.0 1969-12-31 16:00:01.673 -7196 1013745772 -3779244238016 NULL NULL 7196 -14392 -7196 NULL NULL 47.0 6.4051596E8 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:00.951 -7196 -1533227484 5715872060352 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:12.163 -7196 1971558716 -7349970893248 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 16:00:03.134 -7196 -1101137915 4105042147120 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 38 38.0 1969-12-31 16:00:00.272 -7196 -293368494 1093677745632 NULL NULL 7196 -14392 -7196 NULL NULL -38.0 6.4051596E8 3.842700083325918E-5 -38 2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 16:00:09.519 -7196 2117650702 -7894601817056 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 9 9.0 1969-12-31 15:59:46 -7196 -2132536965 7950097805520 NULL NULL 7196 -14392 -7196 NULL NULL -9.0 6.4051596E8 9.101131776298225E-6 -9 8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 42 42.0 1969-12-31 15:59:50.19 -7196 -803379017 2994996975376 NULL NULL 7196 -14392 -7196 NULL NULL -42.0 6.4051596E8 4.247194828939172E-5 -42 1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 16:00:02.221 -7196 -1680281858 6264090766624 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 16:00:06.848 -7196 1415466231 -5276858109168 NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -16 -16.0 1969-12-31 16:00:06.481 -7196 1979538716 -7379720333248 NULL NULL 7196 -14392 -7196 NULL NULL 16.0 6.4051596E8 -1.617978982453018E-5 16 -4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -12 -12.0 1969-12-31 15:59:51.038 -7196 -1938621277 7227180120656 NULL NULL 7196 -14392 -7196 NULL NULL 12.0 6.4051596E8 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 16:00:12.388 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -8 -8.0 1969-12-31 16:00:09.994 -7196 -1313542468 4896886320704 NULL NULL 7196 -14392 -7196 NULL NULL 8.0 6.4051596E8 -8.08989491226509E-6 8 -9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 59 59.0 1969-12-31 16:00:10.956 -7196 -1137754500 4241548776000 NULL NULL 7196 -14392 -7196 NULL NULL -59.0 6.4051596E8 5.966297497795504E-5 -59 1.3483559322033898 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 34 34.0 1969-12-31 16:00:12.502 -7196 1539208529 -5738169396112 NULL NULL 7196 -14392 -7196 NULL NULL -34.0 6.4051596E8 3.438205337712663E-5 -34 2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 15:59:45.518 -7196 1726448718 -6436200820704 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 53 53.0 1969-12-31 16:00:00.557 -7196 1366995402 -5096158858656 NULL NULL 7196 -14392 -7196 NULL NULL -53.0 6.4051596E8 5.359555379375622E-5 -53 1.501 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -47 -47.0 1969-12-31 16:00:00.555 -7196 -1982329364 7390123868992 NULL NULL 7196 -14392 -7196 NULL NULL 47.0 6.4051596E8 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 5 5.0 1969-12-31 15:59:44.401 -7196 -1716824974 6400323503072 NULL NULL 7196 -14392 -7196 NULL NULL -5.0 6.4051596E8 5.056184320165681E-6 -5 15.910599999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 15:59:51.116 -7196 -1888550510 7040516301280 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 17 17.0 1969-12-31 16:00:01.235 -7196 1128808489 -4208198046992 NULL NULL 7196 -14392 -7196 NULL NULL -17.0 6.4051596E8 1.7191026688563315E-5 -17 4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -48 -48.0 1969-12-31 16:00:03.188 -7196 -1232188884 4593600159552 NULL NULL 7196 -14392 -7196 NULL NULL 48.0 6.4051596E8 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 15:59:44.646 -7196 324834827 -1210984235056 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 15:59:46.195 -7196 157777745 -588195433360 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 16:00:00.664 -7196 918027800 -3422407638400 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -55 -55.0 1969-12-31 15:59:43.932 -7196 1982381637 -7390318742736 NULL NULL 7196 -14392 -7196 NULL NULL 55.0 6.4051596E8 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -40 -40.0 1969-12-31 16:00:10.027 -7196 -1047006196 3903239098688 NULL NULL 7196 -14392 -7196 NULL NULL 40.0 6.4051596E8 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 15:59:50.544 -7196 -705285559 2629304563952 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 16:00:01.062 -7196 -1096608306 4088155764768 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 16:00:06.51 -7196 1141844958 -4256798003424 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 37 37.0 1969-12-31 16:00:00.051 -7196 -522619659 1948326088752 NULL NULL 7196 -14392 -7196 NULL NULL -37.0 6.4051596E8 3.741576396922604E-5 -37 2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 11 11.0 1969-12-31 16:00:09.984 -7196 -1071378269 3994098186832 NULL NULL 7196 -14392 -7196 NULL NULL -11.0 6.4051596E8 1.1123605504364498E-5 -11 7.232090909090909 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 40 40.0 1969-12-31 16:00:01.103 -7196 -1201471894 4479087220832 NULL NULL 7196 -14392 -7196 NULL NULL -40.0 6.4051596E8 4.044947456132545E-5 -40 1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -15 -15.0 1969-12-31 16:00:15.186 -7196 1893214187 -7057902489136 NULL NULL 7196 -14392 -7196 NULL NULL 15.0 6.4051596E8 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -6 -6.0 1969-12-31 15:59:58.625 -7196 1934144944 -7210492351232 NULL NULL 7196 -14392 -7196 NULL NULL 6.0 6.4051596E8 -6.067421184198818E-6 6 -13.258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 38 38.0 1969-12-31 16:00:16.322 -7196 -978843371 3649128087088 NULL NULL 7196 -14392 -7196 NULL NULL -38.0 6.4051596E8 3.842700083325918E-5 -38 2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -32 -32.0 1969-12-31 16:00:02.67 -7196 40974597 -152753297616 NULL NULL 7196 -14392 -7196 NULL NULL 32.0 6.4051596E8 -3.235957964906036E-5 32 -2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 12 12.0 1969-12-31 16:00:00.526 -7196 312497348 -1164990113344 NULL NULL 7196 -14392 -7196 NULL NULL -12.0 6.4051596E8 1.2134842368397635E-5 -12 6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -28 -28.0 1969-12-31 15:59:57.835 -7196 -1946174975 7255340306800 NULL NULL 7196 -14392 -7196 NULL NULL 28.0 6.4051596E8 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 15:59:50.265 -7196 -1668843486 6221448515808 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -57 -57.0 1969-12-31 16:00:12.626 -7196 248308622 -925694542816 NULL NULL 7196 -14392 -7196 NULL NULL 57.0 6.4051596E8 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -60 -60.0 1969-12-31 15:59:45.385 -7196 1775867066 -6620432422048 NULL NULL 7196 -14392 -7196 NULL NULL 60.0 6.4051596E8 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 50 50.0 1969-12-31 15:59:54.196 -7196 -1770006773 6598585249744 NULL NULL 7196 -14392 -7196 NULL NULL -50.0 6.4051596E8 5.056184320165681E-5 -50 1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -7 -7.0 1969-12-31 15:59:58.463 -7196 1855438487 -6917074679536 NULL NULL 7196 -14392 -7196 NULL NULL 7.0 6.4051596E8 -7.078658048231953E-6 7 -11.364714285714285 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -19 -19.0 1969-12-31 15:59:55.885 -7196 1794526031 -6689993043568 NULL NULL 7196 -14392 -7196 NULL NULL 19.0 6.4051596E8 -1.921350041662959E-5 19 -4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 41 41.0 1969-12-31 15:59:44.669 -7196 253244734 -944096368352 NULL NULL 7196 -14392 -7196 NULL NULL -41.0 6.4051596E8 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -20 -20.0 1969-12-31 16:00:11.847 -7196 2093900791 -7806062148848 NULL NULL 7196 -14392 -7196 NULL NULL 20.0 6.4051596E8 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 15:59:50.281 -7196 -468548182 1746747622496 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 7 7.0 1969-12-31 15:59:56.024 -7196 -2036800429 7593191999312 NULL NULL 7196 -14392 -7196 NULL NULL -7.0 6.4051596E8 7.078658048231953E-6 -7 11.364714285714285 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 16:00:14.192 -7196 -2114172148 7881633767744 NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -17 -17.0 1969-12-31 15:59:54.962 -7196 183828953 -685314336784 NULL NULL 7196 -14392 -7196 NULL NULL 17.0 6.4051596E8 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 15:59:45.764 -7196 -661707540 2466845709120 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -44 -44.0 1969-12-31 15:59:43.637 -7196 1100294255 -4101896982640 NULL NULL 7196 -14392 -7196 NULL NULL 44.0 6.4051596E8 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -35 -35.0 1969-12-31 16:00:14.819 -7196 1853093959 -6908334279152 NULL NULL 7196 -14392 -7196 NULL NULL 35.0 6.4051596E8 -3.5393290241159765E-5 35 -2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -55 -55.0 1969-12-31 16:00:13.249 -7196 -685064281 2553919639568 NULL NULL 7196 -14392 -7196 NULL NULL 55.0 6.4051596E8 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -30 -30.0 1969-12-31 16:00:00.434 -7196 554514485 -2067230000080 NULL NULL 7196 -14392 -7196 NULL NULL 30.0 6.4051596E8 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 15:59:51.357 -7196 1943312510 -7244669037280 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -9 -9.0 1969-12-31 15:59:58.061 -7196 123461184 -460263293952 NULL NULL 7196 -14392 -7196 NULL NULL 9.0 6.4051596E8 -9.101131776298225E-6 9 -8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -49 -49.0 1969-12-31 15:59:54.686 -7196 -1715657876 6395972561728 NULL NULL 7196 -14392 -7196 NULL NULL 49.0 6.4051596E8 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -25 -25.0 1969-12-31 16:00:03.328 -7196 -423373826 1578337623328 NULL NULL 7196 -14392 -7196 NULL NULL 25.0 6.4051596E8 -2.5280921600828406E-5 25 -3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -40 -40.0 1969-12-31 15:59:58.544 -7196 1510874931 -5632541742768 NULL NULL 7196 -14392 -7196 NULL NULL 40.0 6.4051596E8 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -4 -4.0 1969-12-31 15:59:51.539 -7196 -421581540 1571655981120 NULL NULL 7196 -14392 -7196 NULL NULL 4.0 6.4051596E8 -4.044947456132545E-6 4 -19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 15:59:49.913 -7196 -862213799 3214333042672 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 15:59:52.405 -7196 1483839864 -5531755012992 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -26.28 1969-12-31 16:00:03.695 -7196 -1967465307 7334710664496 NULL NULL 7196 -14392 -7196 NULL NULL 26.28 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 16:00:03.395 -7196 750423835 -2797580056880 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:01.111 -7196 -1370314889 5108533906192 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -20 -20.0 1969-12-31 16:00:02.91 -7196 806729927 -3007489167856 NULL NULL 7196 -14392 -7196 NULL NULL 20.0 6.4051596E8 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -43 -43.0 1969-12-31 15:59:51.433 -7196 -1328837124 4953904798272 NULL NULL 7196 -14392 -7196 NULL NULL 43.0 6.4051596E8 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 9 9.0 1969-12-31 15:59:55.795 -7196 1649886580 -6150777170240 NULL NULL 7196 -14392 -7196 NULL NULL -9.0 6.4051596E8 9.101131776298225E-6 -9 8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -8 -8.0 1969-12-31 16:00:03.136 -7196 -1849991500 6896768312000 NULL NULL 7196 -14392 -7196 NULL NULL 8.0 6.4051596E8 -8.08989491226509E-6 8 -9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -17 -17.0 1969-12-31 15:59:51.104 -7196 -506132968 1886863704704 NULL NULL 7196 -14392 -7196 NULL NULL 17.0 6.4051596E8 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -19 -19.0 1969-12-31 15:59:49.909 -7196 1384643377 -5161950509456 NULL NULL 7196 -14392 -7196 NULL NULL 19.0 6.4051596E8 -1.921350041662959E-5 19 -4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -24 -24.0 1969-12-31 16:00:10.682 -7196 -774383855 2886903011440 NULL NULL 7196 -14392 -7196 NULL NULL 24.0 6.4051596E8 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 15:59:51.442 -7196 11734243 -43745257904 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -54 -54.0 1969-12-31 16:00:06.484 -7196 1605976008 -5987078557824 NULL NULL 7196 -14392 -7196 NULL NULL 54.0 6.4051596E8 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -4 -4.0 1969-12-31 15:59:52.956 -7196 1577367122 -5880424630816 NULL NULL 7196 -14392 -7196 NULL NULL 4.0 6.4051596E8 -4.044947456132545E-6 4 -19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 51 51.0 1969-12-31 15:59:43.782 -7196 -1607347015 5992189671920 NULL NULL 7196 -14392 -7196 NULL NULL -51.0 6.4051596E8 5.157308006568995E-5 -51 1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -49 -49.0 1969-12-31 15:59:51.009 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 49.0 6.4051596E8 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 16:00:06.688 -7196 1904598029 -7100341452112 NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 16:00:11.856 -7196 -366443186 1366100197408 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 27 27.0 1969-12-31 16:00:13.951 -7196 -806775664 3007659675392 NULL NULL 7196 -14392 -7196 NULL NULL -27.0 6.4051596E8 2.7303395328894677E-5 -27 2.946407407407407 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 15:59:58.479 -7196 -1379694191 5143499944048 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 30 30.0 1969-12-31 15:59:48.038 -7196 1053149934 -3926142953952 NULL NULL 7196 -14392 -7196 NULL NULL -30.0 6.4051596E8 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:00.148 -7196 1839707228 -6858428545984 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -53 -53.0 1969-12-31 15:59:48.882 -7196 -1560660031 5818140595568 NULL NULL 7196 -14392 -7196 NULL NULL 53.0 6.4051596E8 -5.359555379375622E-5 53 -1.501 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 37 37.0 1969-12-31 16:00:12.728 -7196 -415980890 1550776757920 NULL NULL 7196 -14392 -7196 NULL NULL -37.0 6.4051596E8 3.741576396922604E-5 -37 2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:04.827 -7196 1667038451 -6214719345328 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 16:00:02.32 -7196 -1354302203 5048838612784 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 15:59:51.901 -7196 763896882 -2847807576096 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 15:59:53.458 -7196 867823537 -3235246145936 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 35 35.0 1969-12-31 16:00:07.763 -7196 -854036780 3183849115840 NULL NULL 7196 -14392 -7196 NULL NULL -35.0 6.4051596E8 3.5393290241159765E-5 -35 2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 48 48.0 1969-12-31 16:00:05.616 -7196 -449170614 1674508048992 NULL NULL 7196 -14392 -7196 NULL NULL -48.0 6.4051596E8 4.853936947359054E-5 -48 1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 32 32.0 1969-12-31 15:59:45.572 -7196 -1337167441 4984960220048 NULL NULL 7196 -14392 -7196 NULL NULL -32.0 6.4051596E8 3.235957964906036E-5 -32 2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 15:59:43.749 -7196 396428880 -1477886864640 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -35 -35.0 1969-12-31 16:00:12.966 -7196 -211004760 786625745280 NULL NULL 7196 -14392 -7196 NULL NULL 35.0 6.4051596E8 -3.5393290241159765E-5 35 -2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -7 -7.0 1969-12-31 15:59:47.031 -7196 752265217 -2804444728976 NULL NULL 7196 -14392 -7196 NULL NULL 7.0 6.4051596E8 -7.078658048231953E-6 7 -11.364714285714285 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 42 42.0 1969-12-31 16:00:11.591 -7196 873176558 -3255202208224 NULL NULL 7196 -14392 -7196 NULL NULL -42.0 6.4051596E8 4.247194828939172E-5 -42 1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -14 -14.0 1969-12-31 16:00:07.6 -7196 818794014 -3052464084192 NULL NULL 7196 -14392 -7196 NULL NULL 14.0 6.4051596E8 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -24 -24.0 1969-12-31 16:00:07.857 -7196 -1199756482 4472692164896 NULL NULL 7196 -14392 -7196 NULL NULL 24.0 6.4051596E8 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -49 -49.0 1969-12-31 16:00:14.208 -7196 -65650667 244745686576 NULL NULL 7196 -14392 -7196 NULL NULL 49.0 6.4051596E8 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:08.011 -7196 702204680 -2617819047040 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:01.811 -7196 1371995065 -5114797602320 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 15:59:58.578 -7196 -1887367961 7036107758608 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 15:59:44.512 -7196 -398822457 1486810119696 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -31 -31.0 1969-12-31 16:00:13.868 -7196 1337237884 -4985222831552 NULL NULL 7196 -14392 -7196 NULL NULL 31.0 6.4051596E8 -3.134834278502722E-5 31 -2.566225806451613 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 16:00:03.256 -7196 -2123641234 7916934520352 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 16:00:16.19 -7196 1811651302 -6753836053856 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 16:00:09.961 -7196 -1759441703 6559198668784 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:06.243 -7196 -88860257 331271038096 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -4 -4.0 1969-12-31 15:59:57.932 -7196 345912243 -1289560841904 NULL NULL 7196 -14392 -7196 NULL NULL 4.0 6.4051596E8 -4.044947456132545E-6 4 -19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 53 53.0 1969-12-31 15:59:50.996 -7196 1897312309 -7073180287952 NULL NULL 7196 -14392 -7196 NULL NULL -53.0 6.4051596E8 5.359555379375622E-5 -53 1.501 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -2 -2.0 1969-12-31 16:00:07.711 -7196 128320480 -478378749440 NULL NULL 7196 -14392 -7196 NULL NULL 2.0 6.4051596E8 -2.0224737280662724E-6 2 -39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 15:59:52.699 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 16:00:11.132 -7196 1652808422 -6161669797216 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 16:00:09.911 -7196 1869210375 -6968416278000 NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:12.977 -7196 -1687110423 6289547656944 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 16:00:16.065 -7196 -473766733 1766202380624 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 16:00:04.518 -7196 -1658319459 6182214943152 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 15:59:45.978 -7196 -2128720310 7935869315680 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -48 -48.0 1969-12-31 15:59:52.507 -7196 -822146744 3064963061632 NULL NULL 7196 -14392 -7196 NULL NULL 48.0 6.4051596E8 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 26 26.0 1969-12-31 15:59:51.43 -7196 1902876353 -7093923043984 NULL NULL 7196 -14392 -7196 NULL NULL -26.0 6.4051596E8 2.629215846486154E-5 -26 3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -35 -35.0 1969-12-31 15:59:46.585 -7196 -990632641 3693078485648 NULL NULL 7196 -14392 -7196 NULL NULL 35.0 6.4051596E8 -3.5393290241159765E-5 35 -2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -55 -55.0 1969-12-31 16:00:01.138 -7196 888532643 -3312449693104 NULL NULL 7196 -14392 -7196 NULL NULL 55.0 6.4051596E8 -5.561802752182249E-5 55 -1.4464181818181818 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -6 -6.0 1969-12-31 16:00:06.4 -7196 687081709 -2561440611152 NULL NULL 7196 -14392 -7196 NULL NULL 6.0 6.4051596E8 -6.067421184198818E-6 6 -13.258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:12.006 -7196 1143654535 -4263544106480 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -34 -34.0 1969-12-31 16:00:06.405 -7196 347395524 -1295090513472 NULL NULL 7196 -14392 -7196 NULL NULL 34.0 6.4051596E8 -3.438205337712663E-5 34 -2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 16:00:05.162 -7196 -2140316424 7979099628672 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -44 -44.0 1969-12-31 16:00:00.289 -7196 524734261 -1956209325008 NULL NULL 7196 -14392 -7196 NULL NULL 44.0 6.4051596E8 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -64 -64.0 1969-12-31 16:00:11.912 -7196 -1615920595 6024151978160 NULL NULL 7196 -14392 -7196 NULL NULL 64.0 6.4051596E8 -6.471915929812072E-5 64 -1.243015625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 16:00:00.546 -7196 -2133897574 7955170155872 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -9 -9.0 1969-12-31 15:59:57.687 -7196 -1097778251 4092517319728 NULL NULL 7196 -14392 -7196 NULL NULL 9.0 6.4051596E8 -9.101131776298225E-6 9 -8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -35 -35.0 1969-12-31 15:59:48.408 -7196 1199675481 -4472390193168 NULL NULL 7196 -14392 -7196 NULL NULL 35.0 6.4051596E8 -3.5393290241159765E-5 35 -2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 31 31.0 1969-12-31 16:00:13.816 -7196 -1821633641 6791050213648 NULL NULL 7196 -14392 -7196 NULL NULL -31.0 6.4051596E8 3.134834278502722E-5 -31 2.566225806451613 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 16:00:15.215 -7196 1077634070 -4017419812960 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -14 -14.0 1969-12-31 16:00:14.79 -7196 1100839659 -4103930248752 NULL NULL 7196 -14392 -7196 NULL NULL 14.0 6.4051596E8 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 16:00:02.38 -7196 1733885960 -6463926858880 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 35 35.0 1969-12-31 15:59:48.022 -7196 523231898 -1950608515744 NULL NULL 7196 -14392 -7196 NULL NULL -35.0 6.4051596E8 3.5393290241159765E-5 -35 2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -20 -20.0 1969-12-31 15:59:44.907 -7196 1073150417 -4000704754576 NULL NULL 7196 -14392 -7196 NULL NULL 20.0 6.4051596E8 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 0 0.0 1969-12-31 16:00:11.089 -7196 1907356119 -7110623611632 NULL NULL 7196 -14392 -7196 NULL NULL -0.0 6.4051596E8 0.0 0 Infinity +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -10 -10.0 1969-12-31 16:00:13.743 -7196 -1750160608 6524598746624 NULL NULL 7196 -14392 -7196 NULL NULL 10.0 6.4051596E8 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 15:59:55.317 -7196 926194185 -3452851921680 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 16:00:15.683 -7196 963008487 -3590095639536 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 16:00:02.777 -7196 1335415993 -4978430821904 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 15:59:50.966 -7196 601858368 -2243727995904 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 13 13.0 1969-12-31 16:00:05.368 -7196 1626425715 -6063315065520 NULL NULL 7196 -14392 -7196 NULL NULL -13.0 6.4051596E8 1.314607923243077E-5 -13 6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 4 4.0 1969-12-31 15:59:54.905 -7196 -1173921590 4376379687520 NULL NULL 7196 -14392 -7196 NULL NULL -4.0 6.4051596E8 4.044947456132545E-6 -4 19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 18 18.0 1969-12-31 15:59:49.306 -7196 -906847764 3380728464192 NULL NULL 7196 -14392 -7196 NULL NULL -18.0 6.4051596E8 1.820226355259645E-5 -18 4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -16 -16.0 1969-12-31 16:00:02.267 -7196 -405314121 1511011043088 NULL NULL 7196 -14392 -7196 NULL NULL 16.0 6.4051596E8 -1.617978982453018E-5 16 -4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 16:00:12.921 -7196 635433167 -2368894846576 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 15:59:48.395 -7196 -519770970 1937706176160 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -19 -19.0 1969-12-31 16:00:10.814 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 19.0 6.4051596E8 -1.921350041662959E-5 19 -4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 51 51.0 1969-12-31 15:59:58.171 -7196 1289268469 -4806392852432 NULL NULL 7196 -14392 -7196 NULL NULL -51.0 6.4051596E8 5.157308006568995E-5 -51 1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 15:59:53.746 -7196 -111469961 415560014608 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -28 -28.0 1969-12-31 15:59:44.895 -7196 -95814999 357198316272 NULL NULL 7196 -14392 -7196 NULL NULL 28.0 6.4051596E8 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -30 -30.0 1969-12-31 15:59:50.313 -7196 343613951 -1280992809328 NULL NULL 7196 -14392 -7196 NULL NULL 30.0 6.4051596E8 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 43 43.0 1969-12-31 16:00:13.812 -7196 -1860496519 6935931022832 NULL NULL 7196 -14392 -7196 NULL NULL -43.0 6.4051596E8 4.3483185153424856E-5 -43 1.8500697674418605 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 50 50.0 1969-12-31 16:00:08.38 -7196 1192295669 -4444878254032 NULL NULL 7196 -14392 -7196 NULL NULL -50.0 6.4051596E8 5.056184320165681E-5 -50 1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 4 4.0 1969-12-31 15:59:45.595 -7196 -514465592 1917927726976 NULL NULL 7196 -14392 -7196 NULL NULL -4.0 6.4051596E8 4.044947456132545E-6 -4 19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 39 39.0 1969-12-31 16:00:06.206 -7196 -1835825430 6843957203040 NULL NULL 7196 -14392 -7196 NULL NULL -39.0 6.4051596E8 3.9438237697292314E-5 -39 2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:15.76 -7196 2018251685 -7524042281680 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 28 28.0 1969-12-31 16:00:11.858 -7196 -1831759028 6828797656384 NULL NULL 7196 -14392 -7196 NULL NULL -28.0 6.4051596E8 2.8314632192927813E-5 -28 2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 15:59:52.946 -7196 -1900879493 7086478749904 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 16:00:13.735 -7196 650909244 -2426589661632 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -50 -50.0 1969-12-31 16:00:14.134 -7196 1740563590 -6488821063520 NULL NULL 7196 -14392 -7196 NULL NULL 50.0 6.4051596E8 -5.056184320165681E-5 50 -1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 16:00:14.364 -7196 -1303640256 4859970874368 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 15:59:45.451 -7196 -231552821 863228916688 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -26 -26.0 1969-12-31 16:00:14.661 -7196 1196069494 -4458947073632 NULL NULL 7196 -14392 -7196 NULL NULL 26.0 6.4051596E8 -2.629215846486154E-5 26 -3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 15:59:55.521 -7196 -1058636150 3946595567200 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 41 41.0 1969-12-31 15:59:44.57 -7196 649072626 -2419742749728 NULL NULL 7196 -14392 -7196 NULL NULL -41.0 6.4051596E8 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -10 -10.0 1969-12-31 16:00:13.684 -7196 -2010228069 7494130241232 NULL NULL 7196 -14392 -7196 NULL NULL 10.0 6.4051596E8 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 48 48.0 1969-12-31 15:59:57.499 -7196 -1745648407 6507777261296 NULL NULL 7196 -14392 -7196 NULL NULL -48.0 6.4051596E8 4.853936947359054E-5 -48 1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 16:00:13.197 -7196 647410848 -2413547641344 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 46 46.0 1969-12-31 16:00:07.743 -7196 -203349963 758088662064 NULL NULL 7196 -14392 -7196 NULL NULL -46.0 6.4051596E8 4.651689574552426E-5 -46 1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -27 -27.0 1969-12-31 15:59:57.664 -7196 1481888026 -5524478560928 NULL NULL 7196 -14392 -7196 NULL NULL 27.0 6.4051596E8 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 26 26.0 1969-12-31 16:00:01.871 -7196 -625819139 2333053750192 NULL NULL 7196 -14392 -7196 NULL NULL -26.0 6.4051596E8 2.629215846486154E-5 -26 3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 42 42.0 1969-12-31 15:59:57.011 -7196 -549987366 2050352900448 NULL NULL 7196 -14392 -7196 NULL NULL -42.0 6.4051596E8 4.247194828939172E-5 -42 1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:11.749 -7196 1957235821 -7296575140688 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 15:59:45.932 -7196 1611717184 -6008481661952 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 15:59:53.686 -7196 -1161932838 4331685620064 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 15:59:49.021 -7196 -580663229 2164712517712 NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 20 20.0 1969-12-31 16:00:01.267 -7196 -1587089429 5916669391312 NULL NULL 7196 -14392 -7196 NULL NULL -20.0 6.4051596E8 2.0224737280662725E-5 -20 3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 16:00:01.694 -7196 58767695 -219085966960 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 16:00:11.738 -7196 -680140600 2535564156800 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -1 -1.0 1969-12-31 16:00:06.358 -7196 -1029993753 3839816711184 NULL NULL 7196 -14392 -7196 NULL NULL 1.0 6.4051596E8 -1.0112368640331362E-6 1 -79.553 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 41 41.0 1969-12-31 16:00:08.418 -7196 791540035 -2950861250480 NULL NULL 7196 -14392 -7196 NULL NULL -41.0 6.4051596E8 4.1460711425358585E-5 -41 1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -15 -15.0 1969-12-31 15:59:46.242 -7196 1081882955 -4033259656240 NULL NULL 7196 -14392 -7196 NULL NULL 15.0 6.4051596E8 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 16:00:00.156 -7196 2104038988 -7843857347264 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 15:59:49.331 -7196 1320376751 -4922364527728 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -28 -28.0 1969-12-31 16:00:04.747 -7196 2008437496 -7487454985088 NULL NULL 7196 -14392 -7196 NULL NULL 28.0 6.4051596E8 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -37 -37.0 1969-12-31 16:00:00.539 -7196 1213297685 -4523173769680 NULL NULL 7196 -14392 -7196 NULL NULL 37.0 6.4051596E8 -3.741576396922604E-5 37 -2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 16:00:12.762 -7196 1034824629 -3857826216912 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:15.113 -7196 -2022745657 7540795809296 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -44 -44.0 1969-12-31 16:00:03.002 -7196 1216900640 -4536605585920 NULL NULL 7196 -14392 -7196 NULL NULL 44.0 6.4051596E8 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 15:59:44.823 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -17 -17.0 1969-12-31 16:00:10.939 -7196 1735209038 -6468859293664 NULL NULL 7196 -14392 -7196 NULL NULL 17.0 6.4051596E8 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -36 -36.0 1969-12-31 16:00:06.661 -7196 394687129 -1471393616912 NULL NULL 7196 -14392 -7196 NULL NULL 36.0 6.4051596E8 -3.64045271051929E-5 36 -2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 56 56.0 1969-12-31 16:00:00.909 -7196 1421751268 -5300288727104 NULL NULL 7196 -14392 -7196 NULL NULL -56.0 6.4051596E8 5.6629264385855625E-5 -56 1.4205892857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 4 4.0 1969-12-31 16:00:12.309 -7196 -1498229137 5585398222736 NULL NULL 7196 -14392 -7196 NULL NULL -4.0 6.4051596E8 4.044947456132545E-6 -4 19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 52 52.0 1969-12-31 15:59:49.565 -7196 1198121662 -4466597555936 NULL NULL 7196 -14392 -7196 NULL NULL -52.0 6.4051596E8 5.258431692972308E-5 -52 1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 33 33.0 1969-12-31 16:00:14.872 -7196 -995947123 3712890874544 NULL NULL 7196 -14392 -7196 NULL NULL -33.0 6.4051596E8 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 16:00:01.489 -7196 220682110 -822702906080 NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -1 -1.0 1969-12-31 15:59:55.53 -7196 745151099 -2777923297072 NULL NULL 7196 -14392 -7196 NULL NULL 1.0 6.4051596E8 -1.0112368640331362E-6 1 -79.553 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -14 -14.0 1969-12-31 16:00:04.574 -7196 87724305 -327036209040 NULL NULL 7196 -14392 -7196 NULL NULL 14.0 6.4051596E8 -1.4157316096463906E-5 14 -5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 16:00:00.865 -7196 1613629130 -6015609396640 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 14 14.0 1969-12-31 16:00:00.394 -7196 -1660510440 6190382920320 NULL NULL 7196 -14392 -7196 NULL NULL -14.0 6.4051596E8 1.4157316096463906E-5 -14 5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -5 -5.0 1969-12-31 16:00:10.326 -7196 -474752759 1769878285552 NULL NULL 7196 -14392 -7196 NULL NULL 5.0 6.4051596E8 -5.056184320165681E-6 5 -15.910599999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -50 -50.0 1969-12-31 16:00:00.568 -7196 -1572562680 5862513671040 NULL NULL 7196 -14392 -7196 NULL NULL 50.0 6.4051596E8 -5.056184320165681E-5 50 -1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -54 -54.0 1969-12-31 15:59:53.657 -7196 1476582815 -5504700734320 NULL NULL 7196 -14392 -7196 NULL NULL 54.0 6.4051596E8 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 26 26.0 1969-12-31 16:00:08.286 -7196 -961730755 3585332254640 NULL NULL 7196 -14392 -7196 NULL NULL -26.0 6.4051596E8 2.629215846486154E-5 -26 3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 15:59:49.051 -7196 1104752029 -4118515564112 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -15 -15.0 1969-12-31 16:00:11.257 -7196 -364742164 1359758787392 NULL NULL 7196 -14392 -7196 NULL NULL 15.0 6.4051596E8 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 0 0.0 1969-12-31 15:59:44.159 -7196 -1418871864 5289554308992 NULL NULL 7196 -14392 -7196 NULL NULL -0.0 6.4051596E8 0.0 0 Infinity +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:00.885 -7196 1970376680 -7345564263040 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 16:00:01.22 -7196 1670449519 -6227435806832 NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -42 -42.0 1969-12-31 16:00:05.729 -7196 -998749777 3723339168656 NULL NULL 7196 -14392 -7196 NULL NULL 42.0 6.4051596E8 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 26 26.0 1969-12-31 15:59:54.132 -7196 1677632608 -6254214362624 NULL NULL 7196 -14392 -7196 NULL NULL -26.0 6.4051596E8 2.629215846486154E-5 -26 3.059730769230769 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 40 40.0 1969-12-31 15:59:49.23 -7196 437984126 -1632804821728 NULL NULL 7196 -14392 -7196 NULL NULL -40.0 6.4051596E8 4.044947456132545E-5 -40 1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -54 -54.0 1969-12-31 16:00:11.198 -7196 1650677402 -6153725354656 NULL NULL 7196 -14392 -7196 NULL NULL 54.0 6.4051596E8 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -42 -42.0 1969-12-31 15:59:56.928 -7196 -1675950271 6247942610288 NULL NULL 7196 -14392 -7196 NULL NULL 42.0 6.4051596E8 -4.247194828939172E-5 42 -1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -56 -56.0 1969-12-31 16:00:02.298 -7196 -1509994296 5629258735488 NULL NULL 7196 -14392 -7196 NULL NULL 56.0 6.4051596E8 -5.6629264385855625E-5 56 -1.4205892857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 16:00:14.829 -7196 -192083402 716086922656 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 16:00:15.923 -7196 432086668 -1610819098304 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 52 52.0 1969-12-31 15:59:47.129 -7196 -224047492 835249050176 NULL NULL 7196 -14392 -7196 NULL NULL -52.0 6.4051596E8 5.258431692972308E-5 -52 1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 14 14.0 1969-12-31 15:59:55.492 -7196 1702036126 -6345190677728 NULL NULL 7196 -14392 -7196 NULL NULL -14.0 6.4051596E8 1.4157316096463906E-5 -14 5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:02.722 -7196 1960496738 -7308731839264 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -58 -58.0 1969-12-31 16:00:12.065 -7196 1257970504 -4689714038912 NULL NULL 7196 -14392 -7196 NULL NULL 58.0 6.4051596E8 -5.86517381139219E-5 58 -1.3716034482758621 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -64 -64.0 1969-12-31 16:00:01.785 -7196 -1639157869 6110780535632 NULL NULL 7196 -14392 -7196 NULL NULL 64.0 6.4051596E8 -6.471915929812072E-5 64 -1.243015625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 15:59:54.63 -7196 -1818074941 6777783380048 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -63 -63.0 1969-12-31 16:00:03.552 -7196 -1224023895 4563161080560 NULL NULL 7196 -14392 -7196 NULL NULL 63.0 6.4051596E8 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 46 46.0 1969-12-31 16:00:01.388 -7196 242119227 -902620478256 NULL NULL 7196 -14392 -7196 NULL NULL -46.0 6.4051596E8 4.651689574552426E-5 -46 1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -19 -19.0 1969-12-31 16:00:06.188 -7196 -1169681501 4360572635728 NULL NULL 7196 -14392 -7196 NULL NULL 19.0 6.4051596E8 -1.921350041662959E-5 19 -4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 16:00:11.342 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 46 46.0 1969-12-31 15:59:47.842 -7196 -1064883361 3969885169808 NULL NULL 7196 -14392 -7196 NULL NULL -46.0 6.4051596E8 4.651689574552426E-5 -46 1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -43 -43.0 1969-12-31 16:00:08.967 -7196 -798982337 2978606152336 NULL NULL 7196 -14392 -7196 NULL NULL 43.0 6.4051596E8 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -43 -43.0 1969-12-31 15:59:45.529 -7196 956226605 -3564812783440 NULL NULL 7196 -14392 -7196 NULL NULL 43.0 6.4051596E8 -4.3483185153424856E-5 43 -1.8500697674418605 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:00.73 -7196 -1419583827 5292208507056 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 4 4.0 1969-12-31 16:00:07.163 -7196 447294757 -1667514854096 NULL NULL 7196 -14392 -7196 NULL NULL -4.0 6.4051596E8 4.044947456132545E-6 -4 19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 15:59:53.213 -7196 887537434 -3308739553952 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 37 37.0 1969-12-31 16:00:16.313 -7196 -354500331 1321577233968 NULL NULL 7196 -14392 -7196 NULL NULL -37.0 6.4051596E8 3.741576396922604E-5 -37 2.150081081081081 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -24 -24.0 1969-12-31 16:00:07.696 -7196 -722892928 2694944835584 NULL NULL 7196 -14392 -7196 NULL NULL 24.0 6.4051596E8 -2.426968473679527E-5 24 -3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 16:00:03.963 -7196 95444104 -355815619712 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -57 -57.0 1969-12-31 16:00:05.5 -7196 2042351711 -7613887178608 NULL NULL 7196 -14392 -7196 NULL NULL 57.0 6.4051596E8 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 23 23.0 1969-12-31 16:00:12.759 -7196 -1246639968 4647473800704 NULL NULL 7196 -14392 -7196 NULL NULL -23.0 6.4051596E8 2.325844787276213E-5 -23 3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 38 38.0 1969-12-31 15:59:57.159 -7196 -158261029 589997116112 NULL NULL 7196 -14392 -7196 NULL NULL -38.0 6.4051596E8 3.842700083325918E-5 -38 2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 16 16.0 1969-12-31 15:59:50.404 -7196 -2016344182 7516931110496 NULL NULL 7196 -14392 -7196 NULL NULL -16.0 6.4051596E8 1.617978982453018E-5 -16 4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -52 -52.0 1969-12-31 15:59:47.15 -7196 628698169 -2343786774032 NULL NULL 7196 -14392 -7196 NULL NULL 52.0 6.4051596E8 -5.258431692972308E-5 52 -1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 23 23.0 1969-12-31 16:00:11.785 -7196 -1508117731 5622262901168 NULL NULL 7196 -14392 -7196 NULL NULL -23.0 6.4051596E8 2.325844787276213E-5 -23 3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -60 -60.0 1969-12-31 15:59:55.806 -7196 -1802243330 6718763134240 NULL NULL 7196 -14392 -7196 NULL NULL 60.0 6.4051596E8 -6.0674211841988174E-5 60 -1.3258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 15:59:58.93 -7196 772541706 -2880035479968 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -54 -54.0 1969-12-31 16:00:05.688 -7196 1614836149 -6020109163472 NULL NULL 7196 -14392 -7196 NULL NULL 54.0 6.4051596E8 -5.4606790657789354E-5 54 -1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 34 34.0 1969-12-31 15:59:46.881 -7196 -369187268 1376330135104 NULL NULL 7196 -14392 -7196 NULL NULL -34.0 6.4051596E8 3.438205337712663E-5 -34 2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -64 -64.0 1969-12-31 15:59:56.048 -7196 406535485 -1515564288080 NULL NULL 7196 -14392 -7196 NULL NULL 64.0 6.4051596E8 -6.471915929812072E-5 64 -1.243015625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 54 54.0 1969-12-31 16:00:08.241 -7196 381343252 -1421647643456 NULL NULL 7196 -14392 -7196 NULL NULL -54.0 6.4051596E8 5.4606790657789354E-5 -54 1.4732037037037036 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 45 45.0 1969-12-31 16:00:00.543 -7196 940192068 -3505036029504 NULL NULL 7196 -14392 -7196 NULL NULL -45.0 6.4051596E8 4.550565888149113E-5 -45 1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 15:59:49.512 -7196 -123182483 459224296624 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -12 -12.0 1969-12-31 16:00:09.524 -7196 -1476796699 5505498093872 NULL NULL 7196 -14392 -7196 NULL NULL 12.0 6.4051596E8 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -28 -28.0 1969-12-31 16:00:00.003 -7196 -83883851 312718996528 NULL NULL 7196 -14392 -7196 NULL NULL 28.0 6.4051596E8 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -46 -46.0 1969-12-31 15:59:54.257 -7196 -1020872577 3805812967056 NULL NULL 7196 -14392 -7196 NULL NULL 46.0 6.4051596E8 -4.651689574552426E-5 46 -1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -63 -63.0 1969-12-31 16:00:11.946 -7196 -994504916 3707514326848 NULL NULL 7196 -14392 -7196 NULL NULL 63.0 6.4051596E8 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:07.907 -7196 1200709486 -4476244963808 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 15:59:50.196 -7196 1402100915 -5227032211120 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 21 21.0 1969-12-31 16:00:10.652 -7196 1755924724 -6546087371072 NULL NULL 7196 -14392 -7196 NULL NULL -21.0 6.4051596E8 2.123597414469586E-5 -21 3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 28 28.0 1969-12-31 16:00:02.795 -7196 1542799131 -5751555160368 NULL NULL 7196 -14392 -7196 NULL NULL -28.0 6.4051596E8 2.8314632192927813E-5 -28 2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 16:00:11.526 -7196 -703366355 2622149771440 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 15:59:46.387 -7196 991147780 -3694998923840 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -9 -9.0 1969-12-31 15:59:58.825 -7196 1221941567 -4555398161776 NULL NULL 7196 -14392 -7196 NULL NULL 9.0 6.4051596E8 -9.101131776298225E-6 9 -8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -57 -57.0 1969-12-31 16:00:04.659 -7196 -1579093262 5886859680736 NULL NULL 7196 -14392 -7196 NULL NULL 57.0 6.4051596E8 -5.764050124988876E-5 57 -1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -28 -28.0 1969-12-31 15:59:51.637 -7196 -444000127 1655232473456 NULL NULL 7196 -14392 -7196 NULL NULL 28.0 6.4051596E8 -2.8314632192927813E-5 28 -2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 14 14.0 1969-12-31 15:59:50.291 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL -14.0 6.4051596E8 1.4157316096463906E-5 -14 5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 15:59:47.825 -7196 -95344418 355443990304 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -34 -34.0 1969-12-31 15:59:48.779 -7196 -1022931985 3813490440080 NULL NULL 7196 -14392 -7196 NULL NULL 34.0 6.4051596E8 -3.438205337712663E-5 34 -2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 34 34.0 1969-12-31 16:00:04.36 -7196 1412648789 -5266354685392 NULL NULL 7196 -14392 -7196 NULL NULL -34.0 6.4051596E8 3.438205337712663E-5 -34 2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 32 32.0 1969-12-31 15:59:58.962 -7196 -303275124 1130609662272 NULL NULL 7196 -14392 -7196 NULL NULL -32.0 6.4051596E8 3.235957964906036E-5 -32 2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -34 -34.0 1969-12-31 16:00:01.396 -7196 -1226942900 4574043131200 NULL NULL 7196 -14392 -7196 NULL NULL 34.0 6.4051596E8 -3.438205337712663E-5 34 -2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 27 27.0 1969-12-31 15:59:50.046 -7196 -2121399625 7908577802000 NULL NULL 7196 -14392 -7196 NULL NULL -27.0 6.4051596E8 2.7303395328894677E-5 -27 2.946407407407407 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -12 -12.0 1969-12-31 16:00:15.92 -7196 358049432 -1334808282496 NULL NULL 7196 -14392 -7196 NULL NULL 12.0 6.4051596E8 -1.2134842368397635E-5 12 -6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 48 48.0 1969-12-31 16:00:02.043 -7196 -219185402 817123178656 NULL NULL 7196 -14392 -7196 NULL NULL -48.0 6.4051596E8 4.853936947359054E-5 -48 1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -27 -27.0 1969-12-31 15:59:48.105 -7196 -859692583 3204933949424 NULL NULL 7196 -14392 -7196 NULL NULL 27.0 6.4051596E8 -2.7303395328894677E-5 27 -2.946407407407407 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:06.997 -7196 -1265540677 4717935643856 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -47 -47.0 1969-12-31 16:00:00.235 -7196 -1083011916 4037468422848 NULL NULL 7196 -14392 -7196 NULL NULL 47.0 6.4051596E8 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 55 55.0 1969-12-31 16:00:02.488 -7196 -181014520 674822130560 NULL NULL 7196 -14392 -7196 NULL NULL -55.0 6.4051596E8 5.561802752182249E-5 -55 1.4464181818181818 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 8 8.0 1969-12-31 16:00:00.613 -7196 599224705 -2233909700240 NULL NULL 7196 -14392 -7196 NULL NULL -8.0 6.4051596E8 8.08989491226509E-6 -8 9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -44 -44.0 1969-12-31 15:59:50.843 -7196 619396855 -2309111475440 NULL NULL 7196 -14392 -7196 NULL NULL 44.0 6.4051596E8 -4.449442201745799E-5 44 -1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 32 32.0 1969-12-31 15:59:54.875 -7196 1970876136 -7347426235008 NULL NULL 7196 -14392 -7196 NULL NULL -32.0 6.4051596E8 3.235957964906036E-5 -32 2.48603125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -38 -38.0 1969-12-31 16:00:00.843 -7196 -314153742 1171165150176 NULL NULL 7196 -14392 -7196 NULL NULL 38.0 6.4051596E8 -3.842700083325918E-5 38 -2.0935 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 42 42.0 1969-12-31 16:00:00.992 -7196 1644841467 -6131968988976 NULL NULL 7196 -14392 -7196 NULL NULL -42.0 6.4051596E8 4.247194828939172E-5 -42 1.8941190476190475 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 16:00:07.27 -7196 -2071049869 7720873911632 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -11 -11.0 1969-12-31 15:59:57.148 -7196 -1261670420 4703507325760 NULL NULL 7196 -14392 -7196 NULL NULL 11.0 6.4051596E8 -1.1123605504364498E-5 11 -7.232090909090909 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 16:00:15.409 -7196 313391588 -1168323840064 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -18 -18.0 1969-12-31 15:59:53.782 -7196 -1501501535 5597597722480 NULL NULL 7196 -14392 -7196 NULL NULL 18.0 6.4051596E8 -1.820226355259645E-5 18 -4.419611111111111 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 33 33.0 1969-12-31 16:00:15.99 -7196 1994545529 -7435665732112 NULL NULL 7196 -14392 -7196 NULL NULL -33.0 6.4051596E8 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 49 49.0 1969-12-31 16:00:13.879 -7196 796009413 -2967523091664 NULL NULL 7196 -14392 -7196 NULL NULL -49.0 6.4051596E8 4.9550606337623676E-5 -49 1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 6 6.0 1969-12-31 15:59:58.692 -7196 -95453964 355852377792 NULL NULL 7196 -14392 -7196 NULL NULL -6.0 6.4051596E8 6.067421184198818E-6 -6 13.258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 46 46.0 1969-12-31 15:59:45.334 -7196 -1436934967 5356893556976 NULL NULL 7196 -14392 -7196 NULL NULL -46.0 6.4051596E8 4.651689574552426E-5 -46 1.7294130434782609 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 30 30.0 1969-12-31 15:59:47.701 -7196 -478323335 1783189392880 NULL NULL 7196 -14392 -7196 NULL NULL -30.0 6.4051596E8 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 7 7.0 1969-12-31 16:00:05.724 -7196 -556098975 2073136978800 NULL NULL 7196 -14392 -7196 NULL NULL -7.0 6.4051596E8 7.078658048231953E-6 -7 11.364714285714285 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 39 39.0 1969-12-31 16:00:10.915 -7196 -361407222 1347326123616 NULL NULL 7196 -14392 -7196 NULL NULL -39.0 6.4051596E8 3.9438237697292314E-5 -39 2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 16:00:13.868 -7196 1875242301 -6990903298128 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 15:59:54.438 -7196 265927514 -991377772192 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:15.69 -7196 -1591295545 5932349791760 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -36 -36.0 1969-12-31 16:00:08.615 -7196 756475174 -2820139448672 NULL NULL 7196 -14392 -7196 NULL NULL 36.0 6.4051596E8 -3.64045271051929E-5 36 -2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -50 -50.0 1969-12-31 15:59:53.689 -7196 1294693950 -4826619045600 NULL NULL 7196 -14392 -7196 NULL NULL 50.0 6.4051596E8 -5.056184320165681E-5 50 -1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:07.204 -7196 1735272327 -6469095235056 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 15:59:48.703 -7196 -1633774587 6090711660336 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -16 -16.0 1969-12-31 15:59:54.619 -7196 -2010404362 7494787461536 NULL NULL 7196 -14392 -7196 NULL NULL 16.0 6.4051596E8 -1.617978982453018E-5 16 -4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 15:59:44.081 -7196 -322878567 1203691297776 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -41 -41.0 1969-12-31 16:00:05.785 -7196 -2045045391 7623929217648 NULL NULL 7196 -14392 -7196 NULL NULL 41.0 6.4051596E8 -4.1460711425358585E-5 41 -1.9403170731707315 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -26.28 1969-12-31 16:00:10.192 -7196 291891431 -1088171254768 NULL NULL 7196 -14392 -7196 NULL NULL 26.28 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -6 -6.0 1969-12-31 15:59:57.92 -7196 -2124802690 7921264428320 NULL NULL 7196 -14392 -7196 NULL NULL 6.0 6.4051596E8 -6.067421184198818E-6 6 -13.258833333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -31 -31.0 1969-12-31 15:59:49.226 -7196 -548962072 2046530604416 NULL NULL 7196 -14392 -7196 NULL NULL 31.0 6.4051596E8 -3.134834278502722E-5 31 -2.566225806451613 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -30 -30.0 1969-12-31 15:59:43.82 -7196 1329543519 -4956538238832 NULL NULL 7196 -14392 -7196 NULL NULL 30.0 6.4051596E8 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 16:00:01.125 -7196 -1851730063 6903249674864 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 15:59:49.652 -7196 -2039141896 7601920988288 NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -33 -33.0 1969-12-31 16:00:02.131 -7196 -1264795306 4715156900768 NULL NULL 7196 -14392 -7196 NULL NULL 33.0 6.4051596E8 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 16 16.0 1969-12-31 16:00:16.02 -7196 323260103 -1205113663984 NULL NULL 7196 -14392 -7196 NULL NULL -16.0 6.4051596E8 1.617978982453018E-5 -16 4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:12.663 -7196 -1889458933 7043902902224 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -25 -25.0 1969-12-31 16:00:03.549 -7196 -769039800 2866980374400 NULL NULL 7196 -14392 -7196 NULL NULL 25.0 6.4051596E8 -2.5280921600828406E-5 25 -3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 15:59:44.836 -7196 1003317046 -3740365947488 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 15 15.0 1969-12-31 15:59:44.16 -7196 -146790344 547234402432 NULL NULL 7196 -14392 -7196 NULL NULL -15.0 6.4051596E8 1.5168552960497044E-5 -15 5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -49 -49.0 1969-12-31 15:59:52.715 -7196 1402423611 -5228235221808 NULL NULL 7196 -14392 -7196 NULL NULL 49.0 6.4051596E8 -4.9550606337623676E-5 49 -1.6235306122448978 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 16:00:07.361 -7196 418917539 -1561724585392 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 34 34.0 1969-12-31 16:00:00.82 -7196 221369308 -825264780224 NULL NULL 7196 -14392 -7196 NULL NULL -34.0 6.4051596E8 3.438205337712663E-5 -34 2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 4 4.0 1969-12-31 16:00:08.327 -7196 -286988419 1069892826032 NULL NULL 7196 -14392 -7196 NULL NULL -4.0 6.4051596E8 4.044947456132545E-6 -4 19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -31 -31.0 1969-12-31 15:59:54.845 -7196 -1024257790 3818433041120 NULL NULL 7196 -14392 -7196 NULL NULL 31.0 6.4051596E8 -3.134834278502722E-5 31 -2.566225806451613 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 30 30.0 1969-12-31 16:00:08.554 -7196 1652888354 -6161967783712 NULL NULL 7196 -14392 -7196 NULL NULL -30.0 6.4051596E8 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 15:59:48.779 -7196 907595786 -3383517090208 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 50 50.0 1969-12-31 16:00:11.048 -7196 -1800692361 6712981121808 NULL NULL 7196 -14392 -7196 NULL NULL -50.0 6.4051596E8 5.056184320165681E-5 -50 1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -51 -51.0 1969-12-31 15:59:43.64 -7196 -1339164819 4992406445232 NULL NULL 7196 -14392 -7196 NULL NULL 51.0 6.4051596E8 -5.157308006568995E-5 51 -1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 24 24.0 1969-12-31 16:00:12.66 -7196 -930616249 3469337376272 NULL NULL 7196 -14392 -7196 NULL NULL -24.0 6.4051596E8 2.426968473679527E-5 -24 3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 47 47.0 1969-12-31 16:00:00.351 -7196 -983326369 3665840703632 NULL NULL 7196 -14392 -7196 NULL NULL -47.0 6.4051596E8 4.7528132609557405E-5 -47 1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -2 -2.0 1969-12-31 15:59:47.95 -7196 -787580432 2936099850496 NULL NULL 7196 -14392 -7196 NULL NULL 2.0 6.4051596E8 -2.0224737280662724E-6 2 -39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -35 -35.0 1969-12-31 16:00:12.959 -7196 668477655 -2492084697840 NULL NULL 7196 -14392 -7196 NULL NULL 35.0 6.4051596E8 -3.5393290241159765E-5 35 -2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -30 -30.0 1969-12-31 16:00:13.124 -7196 727610554 -2712532145312 NULL NULL 7196 -14392 -7196 NULL NULL 30.0 6.4051596E8 -3.0337105920994087E-5 30 -2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -20 -20.0 1969-12-31 16:00:13.131 -7196 -25047971 93378835888 NULL NULL 7196 -14392 -7196 NULL NULL 20.0 6.4051596E8 -2.0224737280662725E-5 20 -3.9776499999999997 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 16:00:01.11 -7196 -1144874988 4268093955264 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 15:59:51.184 -7196 1633931264 -6091295752192 NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 57 57.0 1969-12-31 15:59:51.725 -7196 -1511601241 5635249426448 NULL NULL 7196 -14392 -7196 NULL NULL -57.0 6.4051596E8 5.764050124988876E-5 -57 1.3956666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -48 -48.0 1969-12-31 16:00:01.813 -7196 -1035336927 3859736063856 NULL NULL 7196 -14392 -7196 NULL NULL 48.0 6.4051596E8 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 16:00:10.163 -7196 -1964987216 7325472341248 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -48 -48.0 1969-12-31 15:59:44.522 -7196 -954681295 3559051867760 NULL NULL 7196 -14392 -7196 NULL NULL 48.0 6.4051596E8 -4.853936947359054E-5 48 -1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -63 -63.0 1969-12-31 16:00:07.375 -7196 -1711796768 6381578351104 NULL NULL 7196 -14392 -7196 NULL NULL 63.0 6.4051596E8 -6.370792243408759E-5 63 -1.2627460317460317 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 13 13.0 1969-12-31 15:59:54.148 -7196 -1987510940 7409440784320 NULL NULL 7196 -14392 -7196 NULL NULL -13.0 6.4051596E8 1.314607923243077E-5 -13 6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 1 1.0 1969-12-31 15:59:55.524 -7196 -860168842 3206709442976 NULL NULL 7196 -14392 -7196 NULL NULL -1.0 6.4051596E8 1.0112368640331362E-6 -1 79.553 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 15:59:52.164 -7196 1306133727 -4869266534256 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 11 11.0 1969-12-31 16:00:06.603 -7196 444257258 -1656191057824 NULL NULL 7196 -14392 -7196 NULL NULL -11.0 6.4051596E8 1.1123605504364498E-5 -11 7.232090909090909 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 16:00:02.373 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 16:00:02.613 -7196 1493254737 -5566853659536 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -21 -21.0 1969-12-31 16:00:15.188 -7196 -1827273066 6812073990048 NULL NULL 7196 -14392 -7196 NULL NULL 21.0 6.4051596E8 -2.123597414469586E-5 21 -3.788238095238095 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 24 24.0 1969-12-31 15:59:46.471 -7196 813443800 -3032518486400 NULL NULL 7196 -14392 -7196 NULL NULL -24.0 6.4051596E8 2.426968473679527E-5 -24 3.3147083333333334 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 15:59:55.798 -7196 1723777074 -6426240931872 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 16:00:03.85 -7196 -642836823 2396495676144 NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -53 -53.0 1969-12-31 15:59:57.663 -7196 898472381 -3349505036368 NULL NULL 7196 -14392 -7196 NULL NULL 53.0 6.4051596E8 -5.359555379375622E-5 53 -1.501 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 16:00:07.969 -7196 -773265030 2882732031840 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 16:00:01.592 -7196 988888 -3686574464 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 15:59:44.634 -7196 -1554125282 5793779051296 NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 29 29.0 1969-12-31 15:59:47.097 -7196 1918451926 -7151988780128 NULL NULL 7196 -14392 -7196 NULL NULL -29.0 6.4051596E8 2.932586905696095E-5 -29 2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 15:59:58.395 -7196 -1367753794 5098986144032 NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -17 -17.0 1969-12-31 15:59:56.135 -7196 -509557318 1899629681504 NULL NULL 7196 -14392 -7196 NULL NULL 17.0 6.4051596E8 -1.7191026688563315E-5 17 -4.679588235294117 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -64 -64.0 1969-12-31 16:00:12.339 -7196 1805860756 -6732248898368 NULL NULL 7196 -14392 -7196 NULL NULL 64.0 6.4051596E8 -6.471915929812072E-5 64 -1.243015625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 16:00:03.049 -7196 -1513172815 5641108254320 NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 16:00:11.762 -7196 -969277545 3613466687760 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -3 -3.0 1969-12-31 15:59:57.043 -7196 -815857841 3041518031248 NULL NULL 7196 -14392 -7196 NULL NULL 3.0 6.4051596E8 -3.033710592099409E-6 3 -26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -50 -50.0 1969-12-31 16:00:08.161 -7196 -1283226068 4783866781504 NULL NULL 7196 -14392 -7196 NULL NULL 50.0 6.4051596E8 -5.056184320165681E-5 50 -1.59106 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 14 14.0 1969-12-31 15:59:56.518 -7196 -1720768938 6415026600864 NULL NULL 7196 -14392 -7196 NULL NULL -14.0 6.4051596E8 1.4157316096463906E-5 -14 5.682357142857143 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -40 -40.0 1969-12-31 16:00:06.489 -7196 -848424137 3162925182736 NULL NULL 7196 -14392 -7196 NULL NULL 40.0 6.4051596E8 -4.044947456132545E-5 40 -1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 62 62.0 1969-12-31 15:59:54.256 -7196 524247756 -1954395634368 NULL NULL 7196 -14392 -7196 NULL NULL -62.0 6.4051596E8 6.269668557005445E-5 -62 1.2831129032258064 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -33 -33.0 1969-12-31 15:59:52.682 -7196 286555719 -1068279720432 NULL NULL 7196 -14392 -7196 NULL NULL 33.0 6.4051596E8 -3.3370816513093494E-5 33 -2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:08.234 -7196 -729256990 2718670058720 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 40 40.0 1969-12-31 16:00:14.048 -7196 -1498115170 5584973353760 NULL NULL 7196 -14392 -7196 NULL NULL -40.0 6.4051596E8 4.044947456132545E-5 -40 1.9888249999999998 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 52 52.0 1969-12-31 15:59:58.309 -7196 1735974184 -6471711757952 NULL NULL 7196 -14392 -7196 NULL NULL -52.0 6.4051596E8 5.258431692972308E-5 -52 1.5298653846153845 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -34 -34.0 1969-12-31 15:59:50.263 -7196 1591827313 -5934332222864 NULL NULL 7196 -14392 -7196 NULL NULL 34.0 6.4051596E8 -3.438205337712663E-5 34 -2.3397941176470587 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 30 30.0 1969-12-31 15:59:54.76 -7196 -2060977898 7683325603744 NULL NULL 7196 -14392 -7196 NULL NULL -30.0 6.4051596E8 3.0337105920994087E-5 -30 2.6517666666666666 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -5 -5.0 1969-12-31 15:59:44.323 -7196 1644460062 -6130547111136 NULL NULL 7196 -14392 -7196 NULL NULL 5.0 6.4051596E8 -5.056184320165681E-6 5 -15.910599999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 15:59:53.679 -7196 1279487251 -4769928471728 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -8 -8.0 1969-12-31 15:59:56.367 -7196 994075198 -3705912338144 NULL NULL 7196 -14392 -7196 NULL NULL 8.0 6.4051596E8 -8.08989491226509E-6 8 -9.944125 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 25 25.0 1969-12-31 16:00:07.331 -7196 888822373 -3313529806544 NULL NULL 7196 -14392 -7196 NULL NULL -25.0 6.4051596E8 2.5280921600828406E-5 -25 3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -23 -23.0 1969-12-31 16:00:11.124 -7196 -364079399 1357287999472 NULL NULL 7196 -14392 -7196 NULL NULL 23.0 6.4051596E8 -2.325844787276213E-5 23 -3.4588260869565217 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -2 -2.0 1969-12-31 15:59:48.389 -7196 -1268340526 4728373480928 NULL NULL 7196 -14392 -7196 NULL NULL 2.0 6.4051596E8 -2.0224737280662724E-6 2 -39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -29 -29.0 1969-12-31 16:00:03.855 -7196 1616977696 -6028092850688 NULL NULL 7196 -14392 -7196 NULL NULL 29.0 6.4051596E8 -2.932586905696095E-5 29 -2.7432068965517242 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 44 44.0 1969-12-31 16:00:12.427 -7196 -928635185 3461951969680 NULL NULL 7196 -14392 -7196 NULL NULL -44.0 6.4051596E8 4.449442201745799E-5 -44 1.8080227272727272 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -47 -47.0 1969-12-31 15:59:45.028 -7196 1388924857 -5177911866896 NULL NULL 7196 -14392 -7196 NULL NULL 47.0 6.4051596E8 -4.7528132609557405E-5 47 -1.6926170212765956 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 35 35.0 1969-12-31 15:59:51.86 -7196 1667895530 -6217914535840 NULL NULL 7196 -14392 -7196 NULL NULL -35.0 6.4051596E8 3.5393290241159765E-5 -35 2.272942857142857 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 9 9.0 1969-12-31 16:00:09.285 -7196 -547733153 2041949194384 NULL NULL 7196 -14392 -7196 NULL NULL -9.0 6.4051596E8 9.101131776298225E-6 -9 8.839222222222222 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -61 -61.0 1969-12-31 16:00:11.842 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL 61.0 6.4051596E8 -6.16854487060213E-5 61 -1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 12 12.0 1969-12-31 16:00:15.27 -7196 514966110 -1919793658080 NULL NULL 7196 -14392 -7196 NULL NULL -12.0 6.4051596E8 1.2134842368397635E-5 -12 6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 36 36.0 1969-12-31 16:00:12.979 -7196 -1110874318 4141339457504 NULL NULL 7196 -14392 -7196 NULL NULL -36.0 6.4051596E8 3.64045271051929E-5 -36 2.2098055555555556 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 16:00:06.624 -7196 918951834 -3425852437152 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -22 -22.0 1969-12-31 16:00:00.586 -7196 -1104851756 4118887346368 NULL NULL 7196 -14392 -7196 NULL NULL 22.0 6.4051596E8 -2.2247211008728996E-5 22 -3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 12 12.0 1969-12-31 15:59:57.98 -7196 159910702 -596147097056 NULL NULL 7196 -14392 -7196 NULL NULL -12.0 6.4051596E8 1.2134842368397635E-5 -12 6.629416666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -4 -4.0 1969-12-31 16:00:13.324 -7196 1264553400 -4714255075200 NULL NULL 7196 -14392 -7196 NULL NULL 4.0 6.4051596E8 -4.044947456132545E-6 4 -19.88825 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 51 51.0 1969-12-31 15:59:50.363 -7196 1825079468 -6803896256704 NULL NULL 7196 -14392 -7196 NULL NULL -51.0 6.4051596E8 5.157308006568995E-5 -51 1.5598627450980391 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -3 -3.0 1969-12-31 15:59:48.04 -7196 -1125097136 4194362123008 NULL NULL 7196 -14392 -7196 NULL NULL 3.0 6.4051596E8 -3.033710592099409E-6 3 -26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 22 22.0 1969-12-31 16:00:15.715 -7196 -146384448 545721222144 NULL NULL 7196 -14392 -7196 NULL NULL -22.0 6.4051596E8 2.2247211008728996E-5 -22 3.6160454545454543 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -39 -39.0 1969-12-31 16:00:10.104 -7196 170904847 -637133269616 NULL NULL 7196 -14392 -7196 NULL NULL 39.0 6.4051596E8 -3.9438237697292314E-5 39 -2.039820512820513 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 59 59.0 1969-12-31 16:00:03.463 -7196 -1707264538 6364682197664 NULL NULL 7196 -14392 -7196 NULL NULL -59.0 6.4051596E8 5.966297497795504E-5 -59 1.3483559322033898 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 48 48.0 1969-12-31 16:00:07.257 -7196 1639854261 -6113376685008 NULL NULL 7196 -14392 -7196 NULL NULL -48.0 6.4051596E8 4.853936947359054E-5 -48 1.6573541666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 3 3.0 1969-12-31 16:00:13.064 -7196 659639923 -2459137632944 NULL NULL 7196 -14392 -7196 NULL NULL -3.0 6.4051596E8 3.033710592099409E-6 -3 26.517666666666667 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -15 -15.0 1969-12-31 15:59:58.668 -7196 -943224537 3516341073936 NULL NULL 7196 -14392 -7196 NULL NULL 15.0 6.4051596E8 -1.5168552960497044E-5 15 -5.303533333333333 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -16 -16.0 1969-12-31 16:00:01.088 -7196 469226089 -1749274859792 NULL NULL 7196 -14392 -7196 NULL NULL 16.0 6.4051596E8 -1.617978982453018E-5 16 -4.9720625 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -45 -45.0 1969-12-31 16:00:09.332 -7196 -1352651602 5042685172256 NULL NULL 7196 -14392 -7196 NULL NULL 45.0 6.4051596E8 -4.550565888149113E-5 45 -1.7678444444444443 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -1 -1.0 1969-12-31 16:00:09.511 -7196 2011635522 -7499377226016 NULL NULL 7196 -14392 -7196 NULL NULL 1.0 6.4051596E8 -1.0112368640331362E-6 1 -79.553 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 61 61.0 1969-12-31 16:00:15.143 -7196 838733994 -3126800329632 NULL NULL 7196 -14392 -7196 NULL NULL -61.0 6.4051596E8 6.16854487060213E-5 -61 1.3041475409836065 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -10 -10.0 1969-12-31 16:00:11.061 -7196 370889082 -1382674497696 NULL NULL 7196 -14392 -7196 NULL NULL 10.0 6.4051596E8 -1.0112368640331362E-5 10 -7.955299999999999 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -13 -13.0 1969-12-31 15:59:52.976 -7196 -390869916 1457163046848 NULL NULL 7196 -14392 -7196 NULL NULL 13.0 6.4051596E8 -1.314607923243077E-5 13 -6.119461538461538 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 28 28.0 1969-12-31 16:00:12.148 -7196 -1407978842 5248945122976 NULL NULL 7196 -14392 -7196 NULL NULL -28.0 6.4051596E8 2.8314632192927813E-5 -28 2.8411785714285713 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 33 33.0 1969-12-31 15:59:53.989 -7196 -2095698146 7812762688288 NULL NULL 7196 -14392 -7196 NULL NULL -33.0 6.4051596E8 3.3370816513093494E-5 -33 2.4106969696969696 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 2 2.0 1969-12-31 16:00:12.06 -7196 1364337481 -5086250129168 NULL NULL 7196 -14392 -7196 NULL NULL -2.0 6.4051596E8 2.0224737280662724E-6 -2 39.7765 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 19 19.0 1969-12-31 16:00:01.375 -7196 -1885659257 7029737710096 NULL NULL 7196 -14392 -7196 NULL NULL -19.0 6.4051596E8 1.921350041662959E-5 -19 4.187 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 1 1.0 1969-12-31 15:59:48.361 -7196 NULL NULL NULL NULL 7196 -14392 -7196 NULL NULL -1.0 6.4051596E8 1.0112368640331362E-6 -1 79.553 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false 59 59.0 1969-12-31 16:00:00.551 -7196 854892886 -3187040679008 NULL NULL 7196 -14392 -7196 NULL NULL -59.0 6.4051596E8 5.966297497795504E-5 -59 1.3483559322033898 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -25 -25.0 1969-12-31 15:59:44.455 -7196 -579903586 2161880568608 NULL NULL 7196 -14392 -7196 NULL NULL 25.0 6.4051596E8 -2.5280921600828406E-5 25 -3.18212 +NULL -7196.0 1969-12-31 15:59:58.174 NULL false -62 -62.0 1969-12-31 16:00:09.025 -7196 -840223244 3132352253632 NULL NULL 7196 -14392 -7196 NULL NULL 62.0 6.4051596E8 -6.269668557005445E-5 62 -1.2831129032258064 +-748768326 NULL NULL T6ubsbx62cmP false 11 11.0 1969-12-31 16:00:02.351 NULL -75337224 280857171072 748768326 7.48767462743E8 NULL NULL NULL 1.0 7.48767489023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1023644243 NULL NULL Cxas82oA2hX884xmYQ2jrpDX true 11 11.0 1969-12-31 16:00:02.351 NULL -866431241 3230055666448 1023644243 1.023643379743E9 NULL NULL NULL 1.0 1.023643406023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-670497702 NULL NULL gSJS1mpb5Khx8140U3 false 11 11.0 1969-12-31 16:00:02.351 NULL -413540706 1541679751968 670497702 6.70496838743E8 NULL NULL NULL 1.0 6.70496865023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-248449790 NULL NULL ce6C1MhLw false 11 11.0 1969-12-31 16:00:02.351 NULL -214114609 798219262352 248449790 2.48448926743E8 NULL NULL NULL 1.0 2.48448953023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1041353707 NULL NULL 25Qky6lf2pt5FP47Mqmb true 11 11.0 1969-12-31 16:00:02.351 NULL -931949639 3474308254192 1041353707 1.041352843743E9 NULL NULL NULL 1.0 1.041352870023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-772037548 NULL NULL e4j6pjQIS16PPiA86wnd4Ke false 11 11.0 1969-12-31 16:00:02.351 NULL -748568632 2790663860096 772037548 7.72036684743E8 NULL NULL NULL 1.0 7.72036711023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1047036113 NULL NULL Js07yFa2qnrfVU1j2e3 false 11 11.0 1969-12-31 16:00:02.351 NULL -240113848 895144425344 1047036113 1.047035249743E9 NULL NULL NULL 1.0 1.047035276023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-915318164 NULL NULL IpqVS false 11 11.0 1969-12-31 16:00:02.351 NULL -904453147 3371801332016 915318164 9.15317300743E8 NULL NULL NULL 1.0 9.15317327023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-607145105 NULL NULL 0rtl1C false 11 11.0 1969-12-31 16:00:02.351 NULL -311989648 1163097407744 607145105 6.07144241743E8 NULL NULL NULL 1.0 6.07144268023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-695529452 NULL NULL 7s6O45GD7p4ASq08a26v8 true 11 11.0 1969-12-31 16:00:02.351 NULL -467935754 1744464490912 695529452 6.95528588743E8 NULL NULL NULL 1.0 6.95528615023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-891785445 NULL NULL 31m1d3P3AD false 11 11.0 1969-12-31 16:00:02.351 NULL -670722591 2500453819248 891785445 8.91784581743E8 NULL NULL NULL 1.0 8.91784608023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-566868938 NULL NULL yJ67FYA false 11 11.0 1969-12-31 16:00:02.351 NULL -462200469 1723083348432 566868938 5.66868074743E8 NULL NULL NULL 1.0 5.66868101023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-390244123 NULL NULL JPd15l3I6F4Na true 11 11.0 1969-12-31 16:00:02.351 NULL -69466528 258971216384 390244123 3.90243259743E8 NULL NULL NULL 1.0 3.9024328602299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-434867359 NULL NULL IorWR false 11 11.0 1969-12-31 16:00:02.351 NULL -45980161 171414040208 434867359 4.34866495743E8 NULL NULL NULL 1.0 4.3486652202299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-646339276 NULL NULL 2yd00UDPJUO37S4qfT0gHyg false 11 11.0 1969-12-31 16:00:02.351 NULL -584600510 2179390701280 646339276 6.46338412743E8 NULL NULL NULL 1.0 6.46338439023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-796484582 NULL NULL gj5IRDNe62057M false 11 11.0 1969-12-31 16:00:02.351 NULL -598210892 2230130205376 796484582 7.96483718743E8 NULL NULL NULL 1.0 7.96483745023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1012011232 NULL NULL 7q0iMi2GDq0Q false 11 11.0 1969-12-31 16:00:02.351 NULL -806973080 3008395642240 1012011232 1.012010368743E9 NULL NULL NULL 1.0 1.012010395023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-369004155 NULL NULL r55X6tJ4eKvh false 11 11.0 1969-12-31 16:00:02.351 NULL -242858513 905376536464 369004155 3.69003291743E8 NULL NULL NULL 1.0 3.6900331802299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-157295768 NULL NULL O1Kq8bfOEoDR true 11 11.0 1969-12-31 16:00:02.351 NULL -89010 331829280 157295768 1.57294904743E8 NULL NULL NULL 1.0 1.57294931023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-853118632 NULL NULL er5IUhd505r0lT6sc20Tef5q true 11 11.0 1969-12-31 16:00:02.351 NULL -426033194 1588251747232 853118632 8.53117768743E8 NULL NULL NULL 1.0 8.53117795023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1055185482 NULL NULL l20vn2Awc true 11 11.0 1969-12-31 16:00:02.351 NULL -398806473 1486750531344 1055185482 1.055184618743E9 NULL NULL NULL 1.0 1.055184645023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-153888210 NULL NULL aEi5JQHQPd4Y8 true 11 11.0 1969-12-31 16:00:02.351 NULL -111343268 415087703104 153888210 1.53887346743E8 NULL NULL NULL 1.0 1.53887373023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-691793383 NULL NULL 40i6Qf07 false 11 11.0 1969-12-31 16:00:02.351 NULL -322200600 1201163836800 691793383 6.91792519743E8 NULL NULL NULL 1.0 6.91792546023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-875527384 NULL NULL 3W0GorVd6GStPF5S43 false 11 11.0 1969-12-31 16:00:02.351 NULL -332869795 1240938595760 875527384 8.75526520743E8 NULL NULL NULL 1.0 8.75526547023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-930153712 NULL NULL Jj21024T2xdn6 false 11 11.0 1969-12-31 16:00:02.351 NULL -737116859 2747971650352 930153712 9.30152848743E8 NULL NULL NULL 1.0 9.30152875023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-402903993 NULL NULL SIUKQ52i702FMVn5 false 11 11.0 1969-12-31 16:00:02.351 NULL -106842649 398309395472 402903993 4.02903129743E8 NULL NULL NULL 1.0 4.0290315602299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1054849160 NULL NULL CEGOy true 11 11.0 1969-12-31 16:00:02.351 NULL -1027630923 3831008080944 1054849160 1.054848296743E9 NULL NULL NULL 1.0 1.054848323023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-730200970 NULL NULL Ca1Tsx2aY1q true 11 11.0 1969-12-31 16:00:02.351 NULL -425808646 1587414632288 730200970 7.30200106743E8 NULL NULL NULL 1.0 7.30200133023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-884671420 NULL NULL QbGMK true 11 11.0 1969-12-31 16:00:02.351 NULL -265077470 988208808160 884671420 8.84670556743E8 NULL NULL NULL 1.0 8.84670583023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1023165277 NULL NULL 438Lxo541TwY5ID80cnR5 false 11 11.0 1969-12-31 16:00:02.351 NULL -1004780673 3745822348944 1023165277 1.023164413743E9 NULL NULL NULL 1.0 1.023164440023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-369233503 NULL NULL 4S44vF false 11 11.0 1969-12-31 16:00:02.351 NULL -282004256 1051311866368 369233503 3.69232639743E8 NULL NULL NULL 1.0 3.6923266602299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-592237581 NULL NULL auGhMXSG3mUqnh false 11 11.0 1969-12-31 16:00:02.351 NULL -46848452 174651029056 592237581 5.92236717743E8 NULL NULL NULL 1.0 5.92236744023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-901934849 NULL NULL 6tH7O0gw0gJ true 11 11.0 1969-12-31 16:00:02.351 NULL -824858323 3075071828144 901934849 9.01933985743E8 NULL NULL NULL 1.0 9.01934012023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-750036400 NULL NULL M22umK0Q1S2Q80358P6 true 11 11.0 1969-12-31 16:00:02.351 NULL -131749591 491162475248 750036400 7.50035536743E8 NULL NULL NULL 1.0 7.50035563023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1043979188 NULL NULL 2d3tQdCGQN5k7u7S false 11 11.0 1969-12-31 16:00:02.351 NULL -8894336 33158084608 1043979188 1.043978324743E9 NULL NULL NULL 1.0 1.043978351023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-970640948 NULL NULL frhe0 false 11 11.0 1969-12-31 16:00:02.351 NULL -935612665 3487964015120 970640948 9.70640084743E8 NULL NULL NULL 1.0 9.70640111023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-657225349 NULL NULL U1aid52v false 11 11.0 1969-12-31 16:00:02.351 NULL -432068801 1610752490128 657225349 6.57224485743E8 NULL NULL NULL 1.0 6.57224512023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1069736047 NULL NULL k17Am8uPHWk02cEf1jet true 11 11.0 1969-12-31 16:00:02.351 NULL -453772520 1691663954560 1069736047 1.069735183743E9 NULL NULL NULL 1.0 1.069735210023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-238517065 NULL NULL 7xh48cBvt34812U1at true 11 11.0 1969-12-31 16:00:02.351 NULL -164041058 611545064224 238517065 2.38516201743E8 NULL NULL NULL 1.0 2.38516228023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-234925520 NULL NULL rW58d3yGN1w3XhS7hx3UK1yF true 11 11.0 1969-12-31 16:00:02.351 NULL -34488346 128572553888 234925520 2.34924656743E8 NULL NULL NULL 1.0 2.34924683023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-854749761 NULL NULL pL11U1oq48Oj202Wy2W7B false 11 11.0 1969-12-31 16:00:02.351 NULL -336553394 1254671052832 854749761 8.54748897743E8 NULL NULL NULL 1.0 8.54748924023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-444756572 NULL NULL I3XOX0B0 true 11 11.0 1969-12-31 16:00:02.351 NULL -5391274 20098669472 444756572 4.44755708743E8 NULL NULL NULL 1.0 4.4475573502299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-850094446 NULL NULL 8Bshk4eu870M3VyJ8c4D1upr false 11 11.0 1969-12-31 16:00:02.351 NULL -709283154 2644207598112 850094446 8.50093582743E8 NULL NULL NULL 1.0 8.50093609023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1026019772 NULL NULL T6Al7d0hN770XB65M0F2g true 11 11.0 1969-12-31 16:00:02.351 NULL -338489479 1261888777712 1026019772 1.026018908743E9 NULL NULL NULL 1.0 1.026018935023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-791904835 NULL NULL 5TVADgO1Sm3 false 11 11.0 1969-12-31 16:00:02.351 NULL -639988447 2385876930416 791904835 7.91903971743E8 NULL NULL NULL 1.0 7.91903998023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-870474082 NULL NULL tdFP6MjN5b true 11 11.0 1969-12-31 16:00:02.351 NULL -148471202 553500641056 870474082 8.70473218743E8 NULL NULL NULL 1.0 8.70473245023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-706227781 NULL NULL jO055kB85qLIyl5VJVkj8 true 11 11.0 1969-12-31 16:00:02.351 NULL -321571126 1198817157728 706227781 7.06226917743E8 NULL NULL NULL 1.0 7.06226944023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-372691367 NULL NULL 5CbP5V2x14qPOqL3J true 11 11.0 1969-12-31 16:00:02.351 NULL -257171499 958735348272 372691367 3.72690503743E8 NULL NULL NULL 1.0 3.7269053002299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-302342259 NULL NULL H5alUwndRKm true 11 11.0 1969-12-31 16:00:02.351 NULL -279191311 1040825207408 302342259 3.02341395743E8 NULL NULL NULL 1.0 3.0234142202299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-323362404 NULL NULL 2h2qsp14cr false 11 11.0 1969-12-31 16:00:02.351 NULL -84799501 316132539728 323362404 3.23361540743E8 NULL NULL NULL 1.0 3.2336156702299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-659186324 NULL NULL QDK4Rtj7CX01p false 11 11.0 1969-12-31 16:00:02.351 NULL -609337705 2271610964240 659186324 6.59185460743E8 NULL NULL NULL 1.0 6.59185487023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-774129472 NULL NULL jeOFkUX5u5flcN5hCr4 false 11 11.0 1969-12-31 16:00:02.351 NULL -129228119 481762427632 774129472 7.74128608743E8 NULL NULL NULL 1.0 7.74128635023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-757031735 NULL NULL 6AmfdSoTPmVvXdgM8CP20sx false 11 11.0 1969-12-31 16:00:02.351 NULL -59385430 221388883040 757031735 7.57030871743E8 NULL NULL NULL 1.0 7.57030898023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-978898374 NULL NULL ShA4jlmOwF8u7kjN false 11 11.0 1969-12-31 16:00:02.351 NULL -277483031 1034456739568 978898374 9.78897510743E8 NULL NULL NULL 1.0 9.78897537023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1069103950 NULL NULL 41A0nYX72UOSfxO4053xy true 11 11.0 1969-12-31 16:00:02.351 NULL -927759444 3458687207232 1069103950 1.069103086743E9 NULL NULL NULL 1.0 1.069103113023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-839336166 NULL NULL r5osh2m507Ot387emvDxNY true 11 11.0 1969-12-31 16:00:02.351 NULL -587232793 2189203852304 839336166 8.39335302743E8 NULL NULL NULL 1.0 8.39335329023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-930463965 NULL NULL ldk1K false 11 11.0 1969-12-31 16:00:02.351 NULL -414014176 1543444848128 930463965 9.30463101743E8 NULL NULL NULL 1.0 9.30463128023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1048097158 NULL NULL fpt3gpLE true 11 11.0 1969-12-31 16:00:02.351 NULL -234579722 874513203616 1048097158 1.048096294743E9 NULL NULL NULL 1.0 1.048096321023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-1020466796 NULL NULL 7hCJ5yJvt0775jjgq8S0bX6W false 11 11.0 1969-12-31 16:00:02.351 NULL -926772952 3455009565056 1020466796 1.020465932743E9 NULL NULL NULL 1.0 1.020465959023E9 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-379279396 NULL NULL n3WIT2YtCj true 11 11.0 1969-12-31 16:00:02.351 NULL -48658326 181398239328 379279396 3.79278532743E8 NULL NULL NULL 1.0 3.7927855902299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-239794059 NULL NULL 74w2cGm0 true 11 11.0 1969-12-31 16:00:02.351 NULL -8172686 30467773408 239794059 2.39793195743E8 NULL NULL NULL 1.0 2.39793222023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-988289401 NULL NULL CeG187j false 11 11.0 1969-12-31 16:00:02.351 NULL -446065499 1662932180272 988289401 9.88288537743E8 NULL NULL NULL 1.0 9.88288564023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-528532585 NULL NULL ijU4c false 11 11.0 1969-12-31 16:00:02.351 NULL -511463313 1906735230864 528532585 5.28531721743E8 NULL NULL NULL 1.0 5.2853174802299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-743921863 NULL NULL B7grxpIo8Tf33RjGTg0 true 11 11.0 1969-12-31 16:00:02.351 NULL -517466117 1929113684176 743921863 7.43920999743E8 NULL NULL NULL 1.0 7.43921026023E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +-391573084 NULL NULL 28Oe6r21yux7Lk47 true 11 11.0 1969-12-31 16:00:02.351 NULL -236100834 880183909152 391573084 3.91572220743E8 NULL NULL NULL 1.0 3.9157224702299994E8 -11.0 NULL 1.1123605504364498E-5 -11 7.232090909090909 +PREHOOK: query: -- TargetTypeClasses: Long, String, Double, Bool, Timestamp +-- Functions: VarP, Var, StDev, StDevP, Max, Sum +-- ArithmeticOps: Divide, Remainder, Subtract, Multiply +-- FilterOps: Equal, LessThanOrEqual, LessThan, Like, GreaterThanOrEqual, NotEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))) +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Long, String, Double, Bool, Timestamp +-- Functions: VarP, Var, StDev, StDevP, Max, Sum +-- ArithmeticOps: Divide, Remainder, Subtract, Multiply +-- FilterOps: Equal, LessThanOrEqual, LessThan, Like, GreaterThanOrEqual, NotEqual, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))) +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL cint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cbigint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cfloat)) (TOK_SELEXPR (TOK_TABLE_OR_COL cdouble)) (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp2)) (TOK_SELEXPR (TOK_TABLE_OR_COL csmallint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring2)) (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean2)) (TOK_SELEXPR (/ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (% (TOK_TABLE_OR_COL cbigint) 79.553)) (TOK_SELEXPR (- (/ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (% 10.175 (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat) (- (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (% (- (TOK_TABLE_OR_COL cfloat) (- (TOK_TABLE_OR_COL cfloat))) (- 6432))) (TOK_SELEXPR (* (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat) (/ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (% 3569 (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- 359 (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL csmallint)))) (TOK_WHERE (OR (OR (OR (OR (AND (> 197 (TOK_TABLE_OR_COL ctinyint)) (= (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cbigint))) (= (TOK_TABLE_OR_COL cbigint) 359)) (< (TOK_TABLE_OR_COL cboolean1) 0)) (AND (LIKE (TOK_TABLE_OR_COL cstring1) '%ss') (<= (TOK_TABLE_OR_COL cfloat) (TOK_TABLE_OR_COL ctinyint)))) (AND (!= 16558 (TOK_TABLE_OR_COL ctimestamp1)) (AND (>= 0 (TOK_TABLE_OR_COL ctimestamp2)) (< 2563.58 (TOK_TABLE_OR_COL csmallint)))))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((((((197.0 > ctinyint) and (cint = cbigint)) or (cbigint = 359)) or (cboolean1 < 0)) or ((cstring1 like '%ss') and (cfloat <= ctinyint))) or ((16558 <> ctimestamp1) and ((0 >= ctimestamp2) and (2563.58 < csmallint)))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cint + type: int + expr: cbigint + type: bigint + expr: cstring1 + type: string + expr: cboolean1 + type: boolean + expr: cfloat + type: float + expr: cdouble + type: double + expr: ctimestamp2 + type: timestamp + expr: csmallint + type: smallint + expr: cstring2 + type: string + expr: cboolean2 + type: boolean + expr: (cint / cbigint) + type: double + expr: (cbigint % 79.553) + type: double + expr: (- (cint / cbigint)) + type: double + expr: (10.175 % cfloat) + type: double + expr: (- cfloat) + type: float + expr: (cfloat - (- cfloat)) + type: float + expr: ((cfloat - (- cfloat)) % (- 6432)) + type: float + expr: (cdouble * csmallint) + type: double + expr: (- cdouble) + type: double + expr: (- cbigint) + type: bigint + expr: (cfloat - (cint / cbigint)) + type: double + expr: (- csmallint) + type: smallint + expr: (3569 % cbigint) + type: bigint + expr: (359 - cdouble) + type: double + expr: (- csmallint) + type: smallint + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22, _col23, _col24 + Vectorized execution: true + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + Vectorized execution: true + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))) +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT cint, + cbigint, + cstring1, + cboolean1, + cfloat, + cdouble, + ctimestamp2, + csmallint, + cstring2, + cboolean2, + (cint / cbigint), + (cbigint % 79.553), + (-((cint / cbigint))), + (10.175 % cfloat), + (-(cfloat)), + (cfloat - (-(cfloat))), + ((cfloat - (-(cfloat))) % -6432), + (cdouble * csmallint), + (-(cdouble)), + (-(cbigint)), + (cfloat - (cint / cbigint)), + (-(csmallint)), + (3569 % cbigint), + (359 - cdouble), + (-(csmallint)) +FROM alltypesorc +WHERE (((197 > ctinyint) + AND (cint = cbigint)) + OR (cbigint = 359) + OR (cboolean1 < 0) + OR ((cstring1 LIKE '%ss') + AND (cfloat <= ctinyint)) + OR ((16558 != ctimestamp1) + AND ((0 >= ctimestamp2) + AND (2563.58 < csmallint)))) +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +528534767 NULL cvLH6Eat2yFsyy7p true -45.0 5521.0 1969-12-31 15:59:48.553 5521 NULL NULL NULL NULL NULL 10.175 45.0 -90.0 -90.0 3.0481441E7 -5521.0 NULL NULL -5521 NULL -5162.0 -5521 +528534767 NULL cvLH6Eat2yFsyy7p true -32.0 11242.0 1969-12-31 15:59:55.681 11242 NULL NULL NULL NULL NULL 10.175 32.0 -64.0 -64.0 1.26382564E8 -11242.0 NULL NULL -11242 NULL -10883.0 -11242 +528534767 NULL cvLH6Eat2yFsyy7p true -56.0 8353.0 1969-12-31 15:59:46.526 8353 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 6.9772609E7 -8353.0 NULL NULL -8353 NULL -7994.0 -8353 +528534767 NULL cvLH6Eat2yFsyy7p true -11.0 7476.0 1969-12-31 15:59:57.567 7476 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 5.5890576E7 -7476.0 NULL NULL -7476 NULL -7117.0 -7476 +528534767 NULL cvLH6Eat2yFsyy7p true -22.0 3856.0 1969-12-31 15:59:54.534 3856 NULL NULL NULL NULL NULL 10.175 22.0 -44.0 -44.0 1.4868736E7 -3856.0 NULL NULL -3856 NULL -3497.0 -3856 +528534767 NULL cvLH6Eat2yFsyy7p true 28.0 8035.0 1969-12-31 15:59:55.95 8035 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 6.4561225E7 -8035.0 NULL NULL -8035 NULL -7676.0 -8035 +528534767 NULL cvLH6Eat2yFsyy7p true -23.0 4587.0 1969-12-31 15:59:48.52 4587 NULL NULL NULL NULL NULL 10.175 23.0 -46.0 -46.0 2.1040569E7 -4587.0 NULL NULL -4587 NULL -4228.0 -4587 +528534767 NULL cvLH6Eat2yFsyy7p true -4.0 2617.0 1969-12-31 15:59:44.733 2617 NULL NULL NULL NULL NULL 2.1750000000000007 4.0 -8.0 -8.0 6848689.0 -2617.0 NULL NULL -2617 NULL -2258.0 -2617 +528534767 NULL cvLH6Eat2yFsyy7p true -33.0 7350.0 1969-12-31 15:59:48.183 7350 NULL NULL NULL NULL NULL 10.175 33.0 -66.0 -66.0 5.40225E7 -7350.0 NULL NULL -7350 NULL -6991.0 -7350 +528534767 NULL cvLH6Eat2yFsyy7p true 21.0 11737.0 1969-12-31 15:59:45.022 11737 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 1.37757169E8 -11737.0 NULL NULL -11737 NULL -11378.0 -11737 +528534767 NULL cvLH6Eat2yFsyy7p true -33.0 14072.0 1969-12-31 15:59:55.836 14072 NULL NULL NULL NULL NULL 10.175 33.0 -66.0 -66.0 1.98021184E8 -14072.0 NULL NULL -14072 NULL -13713.0 -14072 +528534767 NULL cvLH6Eat2yFsyy7p true -5.0 12422.0 1969-12-31 15:59:48.802 12422 NULL NULL NULL NULL NULL 0.1750000000000007 5.0 -10.0 -10.0 1.54306084E8 -12422.0 NULL NULL -12422 NULL -12063.0 -12422 +528534767 NULL cvLH6Eat2yFsyy7p true 10.0 9366.0 1969-12-31 15:59:50.592 9366 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 8.7721956E7 -9366.0 NULL NULL -9366 NULL -9007.0 -9366 +528534767 NULL cvLH6Eat2yFsyy7p true -48.0 13300.0 1969-12-31 15:59:45.827 13300 NULL NULL NULL NULL NULL 10.175 48.0 -96.0 -96.0 1.7689E8 -13300.0 NULL NULL -13300 NULL -12941.0 -13300 +528534767 NULL cvLH6Eat2yFsyy7p true 36.0 14907.0 1969-12-31 15:59:47.206 14907 NULL NULL NULL NULL NULL 10.175 -36.0 72.0 72.0 2.22218649E8 -14907.0 NULL NULL -14907 NULL -14548.0 -14907 +528534767 NULL cvLH6Eat2yFsyy7p true 26.0 3961.0 1969-12-31 15:59:52.232 3961 NULL NULL NULL NULL NULL 10.175 -26.0 52.0 52.0 1.5689521E7 -3961.0 NULL NULL -3961 NULL -3602.0 -3961 +528534767 NULL cvLH6Eat2yFsyy7p true 10.0 5568.0 1969-12-31 15:59:51.392 5568 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 3.1002624E7 -5568.0 NULL NULL -5568 NULL -5209.0 -5568 +528534767 NULL cvLH6Eat2yFsyy7p true -55.0 3708.0 1969-12-31 15:59:49.866 3708 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 1.3749264E7 -3708.0 NULL NULL -3708 NULL -3349.0 -3708 +528534767 NULL cvLH6Eat2yFsyy7p true -50.0 4647.0 1969-12-31 15:59:52.445 4647 NULL NULL NULL NULL NULL 10.175 50.0 -100.0 -100.0 2.1594609E7 -4647.0 NULL NULL -4647 NULL -4288.0 -4647 +528534767 NULL cvLH6Eat2yFsyy7p true -2.0 4579.0 1969-12-31 15:59:47.748 4579 NULL NULL NULL NULL NULL 0.1750000000000007 2.0 -4.0 -4.0 2.0967241E7 -4579.0 NULL NULL -4579 NULL -4220.0 -4579 +528534767 NULL cvLH6Eat2yFsyy7p true 31.0 13953.0 1969-12-31 15:59:48.224 13953 NULL NULL NULL NULL NULL 10.175 -31.0 62.0 62.0 1.94686209E8 -13953.0 NULL NULL -13953 NULL -13594.0 -13953 +528534767 NULL cvLH6Eat2yFsyy7p true 16.0 9597.0 1969-12-31 15:59:52.227 9597 NULL NULL NULL NULL NULL 10.175 -16.0 32.0 32.0 9.2102409E7 -9597.0 NULL NULL -9597 NULL -9238.0 -9597 +528534767 NULL cvLH6Eat2yFsyy7p true -63.0 15973.0 1969-12-31 15:59:53.94 15973 NULL NULL NULL NULL NULL 10.175 63.0 -126.0 -126.0 2.55136729E8 -15973.0 NULL NULL -15973 NULL -15614.0 -15973 +528534767 NULL cvLH6Eat2yFsyy7p true -43.0 7559.0 1969-12-31 15:59:47.117 7559 NULL NULL NULL NULL NULL 10.175 43.0 -86.0 -86.0 5.7138481E7 -7559.0 NULL NULL -7559 NULL -7200.0 -7559 +528534767 NULL cvLH6Eat2yFsyy7p true 16.0 10321.0 1969-12-31 15:59:45.18 10321 NULL NULL NULL NULL NULL 10.175 -16.0 32.0 32.0 1.06523041E8 -10321.0 NULL NULL -10321 NULL -9962.0 -10321 +528534767 NULL cvLH6Eat2yFsyy7p true 61.0 12339.0 1969-12-31 15:59:58.766 12339 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 1.52250921E8 -12339.0 NULL NULL -12339 NULL -11980.0 -12339 +528534767 NULL cvLH6Eat2yFsyy7p true -5.0 2925.0 1969-12-31 15:59:44.93 2925 NULL NULL NULL NULL NULL 0.1750000000000007 5.0 -10.0 -10.0 8555625.0 -2925.0 NULL NULL -2925 NULL -2566.0 -2925 +528534767 NULL cvLH6Eat2yFsyy7p true 9.0 9924.0 1969-12-31 15:59:56.822 9924 NULL NULL NULL NULL NULL 1.1750000000000007 -9.0 18.0 18.0 9.8485776E7 -9924.0 NULL NULL -9924 NULL -9565.0 -9924 +528534767 NULL cvLH6Eat2yFsyy7p true 50.0 14985.0 1969-12-31 15:59:47.153 14985 NULL NULL NULL NULL NULL 10.175 -50.0 100.0 100.0 2.24550225E8 -14985.0 NULL NULL -14985 NULL -14626.0 -14985 +528534767 NULL cvLH6Eat2yFsyy7p true -48.0 7062.0 1969-12-31 15:59:58.324 7062 NULL NULL NULL NULL NULL 10.175 48.0 -96.0 -96.0 4.9871844E7 -7062.0 NULL NULL -7062 NULL -6703.0 -7062 +528534767 NULL cvLH6Eat2yFsyy7p true -55.0 15646.0 1969-12-31 15:59:49.714 15646 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 2.44797316E8 -15646.0 NULL NULL -15646 NULL -15287.0 -15646 +528534767 NULL cvLH6Eat2yFsyy7p true -35.0 12781.0 1969-12-31 15:59:43.974 12781 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 1.63353961E8 -12781.0 NULL NULL -12781 NULL -12422.0 -12781 +528534767 NULL cvLH6Eat2yFsyy7p true 3.0 11675.0 1969-12-31 15:59:52.018 11675 NULL NULL NULL NULL NULL 1.1750000000000007 -3.0 6.0 6.0 1.36305625E8 -11675.0 NULL NULL -11675 NULL -11316.0 -11675 +528534767 NULL cvLH6Eat2yFsyy7p true 31.0 11913.0 1969-12-31 15:59:53.011 11913 NULL NULL NULL NULL NULL 10.175 -31.0 62.0 62.0 1.41919569E8 -11913.0 NULL NULL -11913 NULL -11554.0 -11913 +528534767 NULL cvLH6Eat2yFsyy7p true -61.0 12230.0 1969-12-31 15:59:54.47 12230 NULL NULL NULL NULL NULL 10.175 61.0 -122.0 -122.0 1.495729E8 -12230.0 NULL NULL -12230 NULL -11871.0 -12230 +528534767 NULL cvLH6Eat2yFsyy7p true -18.0 13387.0 1969-12-31 15:59:44.24 13387 NULL NULL NULL NULL NULL 10.175 18.0 -36.0 -36.0 1.79211769E8 -13387.0 NULL NULL -13387 NULL -13028.0 -13387 +528534767 NULL cvLH6Eat2yFsyy7p true 47.0 10952.0 1969-12-31 15:59:50.501 10952 NULL NULL NULL NULL NULL 10.175 -47.0 94.0 94.0 1.19946304E8 -10952.0 NULL NULL -10952 NULL -10593.0 -10952 +528534767 NULL cvLH6Eat2yFsyy7p true -38.0 13701.0 1969-12-31 15:59:51.897 13701 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 1.87717401E8 -13701.0 NULL NULL -13701 NULL -13342.0 -13701 +528534767 NULL cvLH6Eat2yFsyy7p true -55.0 13074.0 1969-12-31 15:59:53.183 13074 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 1.70929476E8 -13074.0 NULL NULL -13074 NULL -12715.0 -13074 +528534767 NULL cvLH6Eat2yFsyy7p true -14.0 8841.0 1969-12-31 15:59:46.655 8841 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 7.8163281E7 -8841.0 NULL NULL -8841 NULL -8482.0 -8841 +528534767 NULL cvLH6Eat2yFsyy7p true -15.0 11935.0 1969-12-31 15:59:58.566 11935 NULL NULL NULL NULL NULL 10.175 15.0 -30.0 -30.0 1.42444225E8 -11935.0 NULL NULL -11935 NULL -11576.0 -11935 +528534767 NULL cvLH6Eat2yFsyy7p true 1.0 7847.0 1969-12-31 15:59:56.286 7847 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 6.1575409E7 -7847.0 NULL NULL -7847 NULL -7488.0 -7847 +528534767 NULL cvLH6Eat2yFsyy7p true 30.0 5201.0 1969-12-31 15:59:55.81 5201 NULL NULL NULL NULL NULL 10.175 -30.0 60.0 60.0 2.7050401E7 -5201.0 NULL NULL -5201 NULL -4842.0 -5201 +528534767 NULL cvLH6Eat2yFsyy7p true 17.0 9292.0 1969-12-31 15:59:46.698 9292 NULL NULL NULL NULL NULL 10.175 -17.0 34.0 34.0 8.6341264E7 -9292.0 NULL NULL -9292 NULL -8933.0 -9292 +528534767 NULL cvLH6Eat2yFsyy7p true -54.0 5741.0 1969-12-31 15:59:44.577 5741 NULL NULL NULL NULL NULL 10.175 54.0 -108.0 -108.0 3.2959081E7 -5741.0 NULL NULL -5741 NULL -5382.0 -5741 +528534767 NULL cvLH6Eat2yFsyy7p true 3.0 11534.0 1969-12-31 15:59:50.603 11534 NULL NULL NULL NULL NULL 1.1750000000000007 -3.0 6.0 6.0 1.33033156E8 -11534.0 NULL NULL -11534 NULL -11175.0 -11534 +528534767 NULL cvLH6Eat2yFsyy7p true 4.0 5707.0 1969-12-31 15:59:47.01 5707 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 3.2569849E7 -5707.0 NULL NULL -5707 NULL -5348.0 -5707 +528534767 NULL cvLH6Eat2yFsyy7p true 60.0 8540.0 1969-12-31 15:59:50.625 8540 NULL NULL NULL NULL NULL 10.175 -60.0 120.0 120.0 7.29316E7 -8540.0 NULL NULL -8540 NULL -8181.0 -8540 +528534767 NULL cvLH6Eat2yFsyy7p true 17.0 7993.0 1969-12-31 15:59:44.334 7993 NULL NULL NULL NULL NULL 10.175 -17.0 34.0 34.0 6.3888049E7 -7993.0 NULL NULL -7993 NULL -7634.0 -7993 +528534767 NULL cvLH6Eat2yFsyy7p true -52.0 7705.0 1969-12-31 15:59:43.996 7705 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 5.9367025E7 -7705.0 NULL NULL -7705 NULL -7346.0 -7705 +528534767 NULL cvLH6Eat2yFsyy7p true -64.0 10097.0 1969-12-31 15:59:53.894 10097 NULL NULL NULL NULL NULL 10.175 64.0 -128.0 -128.0 1.01949409E8 -10097.0 NULL NULL -10097 NULL -9738.0 -10097 +528534767 NULL cvLH6Eat2yFsyy7p true -49.0 5420.0 1969-12-31 15:59:54.182 5420 NULL NULL NULL NULL NULL 10.175 49.0 -98.0 -98.0 2.93764E7 -5420.0 NULL NULL -5420 NULL -5061.0 -5420 +528534767 NULL cvLH6Eat2yFsyy7p true -36.0 5394.0 1969-12-31 15:59:47.036 5394 NULL NULL NULL NULL NULL 10.175 36.0 -72.0 -72.0 2.9095236E7 -5394.0 NULL NULL -5394 NULL -5035.0 -5394 +528534767 NULL cvLH6Eat2yFsyy7p true -33.0 5070.0 1969-12-31 15:59:58.993 5070 NULL NULL NULL NULL NULL 10.175 33.0 -66.0 -66.0 2.57049E7 -5070.0 NULL NULL -5070 NULL -4711.0 -5070 +528534767 NULL cvLH6Eat2yFsyy7p true -20.0 12880.0 1969-12-31 15:59:47.557 12880 NULL NULL NULL NULL NULL 10.175 20.0 -40.0 -40.0 1.658944E8 -12880.0 NULL NULL -12880 NULL -12521.0 -12880 +528534767 NULL cvLH6Eat2yFsyy7p true -12.0 14120.0 1969-12-31 15:59:50.006 14120 NULL NULL NULL NULL NULL 10.175 12.0 -24.0 -24.0 1.993744E8 -14120.0 NULL NULL -14120 NULL -13761.0 -14120 +528534767 NULL cvLH6Eat2yFsyy7p true 19.0 6246.0 1969-12-31 15:59:51.87 6246 NULL NULL NULL NULL NULL 10.175 -19.0 38.0 38.0 3.9012516E7 -6246.0 NULL NULL -6246 NULL -5887.0 -6246 +528534767 NULL cvLH6Eat2yFsyy7p true 1.0 8523.0 1969-12-31 15:59:51.341 8523 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 7.2641529E7 -8523.0 NULL NULL -8523 NULL -8164.0 -8523 +528534767 NULL cvLH6Eat2yFsyy7p true -2.0 9987.0 1969-12-31 15:59:46.277 9987 NULL NULL NULL NULL NULL 0.1750000000000007 2.0 -4.0 -4.0 9.9740169E7 -9987.0 NULL NULL -9987 NULL -9628.0 -9987 +528534767 NULL cvLH6Eat2yFsyy7p true -50.0 4162.0 1969-12-31 15:59:48.544 4162 NULL NULL NULL NULL NULL 10.175 50.0 -100.0 -100.0 1.7322244E7 -4162.0 NULL NULL -4162 NULL -3803.0 -4162 +528534767 NULL cvLH6Eat2yFsyy7p true 58.0 16045.0 1969-12-31 15:59:52.657 16045 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 2.57442025E8 -16045.0 NULL NULL -16045 NULL -15686.0 -16045 +528534767 NULL cvLH6Eat2yFsyy7p true -10.0 9243.0 1969-12-31 15:59:57.918 9243 NULL NULL NULL NULL NULL 0.1750000000000007 10.0 -20.0 -20.0 8.5433049E7 -9243.0 NULL NULL -9243 NULL -8884.0 -9243 +528534767 NULL cvLH6Eat2yFsyy7p true 27.0 11811.0 1969-12-31 15:59:52.625 11811 NULL NULL NULL NULL NULL 10.175 -27.0 54.0 54.0 1.39499721E8 -11811.0 NULL NULL -11811 NULL -11452.0 -11811 +528534767 NULL cvLH6Eat2yFsyy7p true 33.0 4936.0 1969-12-31 15:59:46.128 4936 NULL NULL NULL NULL NULL 10.175 -33.0 66.0 66.0 2.4364096E7 -4936.0 NULL NULL -4936 NULL -4577.0 -4936 +528534767 NULL cvLH6Eat2yFsyy7p true 34.0 3110.0 1969-12-31 15:59:55.766 3110 NULL NULL NULL NULL NULL 10.175 -34.0 68.0 68.0 9672100.0 -3110.0 NULL NULL -3110 NULL -2751.0 -3110 +528534767 NULL cvLH6Eat2yFsyy7p true -26.0 12339.0 1969-12-31 15:59:45.72 12339 NULL NULL NULL NULL NULL 10.175 26.0 -52.0 -52.0 1.52250921E8 -12339.0 NULL NULL -12339 NULL -11980.0 -12339 +528534767 NULL cvLH6Eat2yFsyy7p true 18.0 13825.0 1969-12-31 15:59:51.239 13825 NULL NULL NULL NULL NULL 10.175 -18.0 36.0 36.0 1.91130625E8 -13825.0 NULL NULL -13825 NULL -13466.0 -13825 +528534767 NULL cvLH6Eat2yFsyy7p true 46.0 2585.0 1969-12-31 15:59:51.436 2585 NULL NULL NULL NULL NULL 10.175 -46.0 92.0 92.0 6682225.0 -2585.0 NULL NULL -2585 NULL -2226.0 -2585 +528534767 NULL cvLH6Eat2yFsyy7p true 34.0 5015.0 1969-12-31 15:59:57.425 5015 NULL NULL NULL NULL NULL 10.175 -34.0 68.0 68.0 2.5150225E7 -5015.0 NULL NULL -5015 NULL -4656.0 -5015 +528534767 NULL cvLH6Eat2yFsyy7p true -45.0 3782.0 1969-12-31 15:59:51.488 3782 NULL NULL NULL NULL NULL 10.175 45.0 -90.0 -90.0 1.4303524E7 -3782.0 NULL NULL -3782 NULL -3423.0 -3782 +528534767 NULL cvLH6Eat2yFsyy7p true 5.0 15112.0 1969-12-31 15:59:47.153 15112 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 2.28372544E8 -15112.0 NULL NULL -15112 NULL -14753.0 -15112 +528534767 NULL cvLH6Eat2yFsyy7p true -24.0 11334.0 1969-12-31 15:59:48.623 11334 NULL NULL NULL NULL NULL 10.175 24.0 -48.0 -48.0 1.28459556E8 -11334.0 NULL NULL -11334 NULL -10975.0 -11334 +528534767 NULL cvLH6Eat2yFsyy7p true 19.0 5847.0 1969-12-31 15:59:51.838 5847 NULL NULL NULL NULL NULL 10.175 -19.0 38.0 38.0 3.4187409E7 -5847.0 NULL NULL -5847 NULL -5488.0 -5847 +528534767 NULL cvLH6Eat2yFsyy7p true -26.0 10725.0 1969-12-31 15:59:48.927 10725 NULL NULL NULL NULL NULL 10.175 26.0 -52.0 -52.0 1.15025625E8 -10725.0 NULL NULL -10725 NULL -10366.0 -10725 +528534767 NULL cvLH6Eat2yFsyy7p true 8.0 10528.0 1969-12-31 15:59:48.939 10528 NULL NULL NULL NULL NULL 2.1750000000000007 -8.0 16.0 16.0 1.10838784E8 -10528.0 NULL NULL -10528 NULL -10169.0 -10528 +528534767 NULL cvLH6Eat2yFsyy7p true -2.0 7574.0 1969-12-31 15:59:47.485 7574 NULL NULL NULL NULL NULL 0.1750000000000007 2.0 -4.0 -4.0 5.7365476E7 -7574.0 NULL NULL -7574 NULL -7215.0 -7574 +528534767 NULL cvLH6Eat2yFsyy7p true 26.0 7316.0 1969-12-31 15:59:51.129 7316 NULL NULL NULL NULL NULL 10.175 -26.0 52.0 52.0 5.3523856E7 -7316.0 NULL NULL -7316 NULL -6957.0 -7316 +528534767 NULL cvLH6Eat2yFsyy7p true 55.0 15103.0 1969-12-31 15:59:48.657 15103 NULL NULL NULL NULL NULL 10.175 -55.0 110.0 110.0 2.28100609E8 -15103.0 NULL NULL -15103 NULL -14744.0 -15103 +528534767 NULL cvLH6Eat2yFsyy7p true 0.0 7623.0 1969-12-31 15:59:43.988 7623 NULL NULL NULL NULL NULL NaN -0.0 0.0 0.0 5.8110129E7 -7623.0 NULL NULL -7623 NULL -7264.0 -7623 +528534767 NULL cvLH6Eat2yFsyy7p true -8.0 4368.0 1969-12-31 15:59:58.702 4368 NULL NULL NULL NULL NULL 2.1750000000000007 8.0 -16.0 -16.0 1.9079424E7 -4368.0 NULL NULL -4368 NULL -4009.0 -4368 +528534767 NULL cvLH6Eat2yFsyy7p true 16.0 16232.0 1969-12-31 15:59:57.417 16232 NULL NULL NULL NULL NULL 10.175 -16.0 32.0 32.0 2.63477824E8 -16232.0 NULL NULL -16232 NULL -15873.0 -16232 +528534767 NULL cvLH6Eat2yFsyy7p true -7.0 9128.0 1969-12-31 15:59:52.83 9128 NULL NULL NULL NULL NULL 3.1750000000000007 7.0 -14.0 -14.0 8.3320384E7 -9128.0 NULL NULL -9128 NULL -8769.0 -9128 +528534767 NULL cvLH6Eat2yFsyy7p true 15.0 8340.0 1969-12-31 15:59:46.383 8340 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 6.95556E7 -8340.0 NULL NULL -8340 NULL -7981.0 -8340 +528534767 NULL cvLH6Eat2yFsyy7p true -19.0 11092.0 1969-12-31 15:59:52.212 11092 NULL NULL NULL NULL NULL 10.175 19.0 -38.0 -38.0 1.23032464E8 -11092.0 NULL NULL -11092 NULL -10733.0 -11092 +528534767 NULL cvLH6Eat2yFsyy7p true -60.0 11419.0 1969-12-31 15:59:54.091 11419 NULL NULL NULL NULL NULL 10.175 60.0 -120.0 -120.0 1.30393561E8 -11419.0 NULL NULL -11419 NULL -11060.0 -11419 +528534767 NULL cvLH6Eat2yFsyy7p true 18.0 5885.0 1969-12-31 15:59:52.309 5885 NULL NULL NULL NULL NULL 10.175 -18.0 36.0 36.0 3.4633225E7 -5885.0 NULL NULL -5885 NULL -5526.0 -5885 +528534767 NULL cvLH6Eat2yFsyy7p true -56.0 4544.0 1969-12-31 15:59:46.347 4544 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.0647936E7 -4544.0 NULL NULL -4544 NULL -4185.0 -4544 +528534767 NULL cvLH6Eat2yFsyy7p true 25.0 7412.0 1969-12-31 15:59:57.006 7412 NULL NULL NULL NULL NULL 10.175 -25.0 50.0 50.0 5.4937744E7 -7412.0 NULL NULL -7412 NULL -7053.0 -7412 +528534767 NULL cvLH6Eat2yFsyy7p true 36.0 7648.0 1969-12-31 15:59:48.31 7648 NULL NULL NULL NULL NULL 10.175 -36.0 72.0 72.0 5.8491904E7 -7648.0 NULL NULL -7648 NULL -7289.0 -7648 +528534767 NULL cvLH6Eat2yFsyy7p true 7.0 13741.0 1969-12-31 15:59:48.256 13741 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 1.88815081E8 -13741.0 NULL NULL -13741 NULL -13382.0 -13741 +528534767 NULL cvLH6Eat2yFsyy7p true 31.0 11511.0 1969-12-31 15:59:47.775 11511 NULL NULL NULL NULL NULL 10.175 -31.0 62.0 62.0 1.32503121E8 -11511.0 NULL NULL -11511 NULL -11152.0 -11511 +528534767 NULL cvLH6Eat2yFsyy7p true 2.0 10637.0 1969-12-31 15:59:44.739 10637 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 1.13145769E8 -10637.0 NULL NULL -10637 NULL -10278.0 -10637 +528534767 NULL cvLH6Eat2yFsyy7p true 46.0 8675.0 1969-12-31 15:59:52.899 8675 NULL NULL NULL NULL NULL 10.175 -46.0 92.0 92.0 7.5255625E7 -8675.0 NULL NULL -8675 NULL -8316.0 -8675 +528534767 NULL cvLH6Eat2yFsyy7p true -6.0 15605.0 1969-12-31 15:59:50.672 15605 NULL NULL NULL NULL NULL 4.175000000000001 6.0 -12.0 -12.0 2.43516025E8 -15605.0 NULL NULL -15605 NULL -15246.0 -15605 +528534767 NULL cvLH6Eat2yFsyy7p true -46.0 3140.0 1969-12-31 15:59:49.574 3140 NULL NULL NULL NULL NULL 10.175 46.0 -92.0 -92.0 9859600.0 -3140.0 NULL NULL -3140 NULL -2781.0 -3140 +528534767 NULL cvLH6Eat2yFsyy7p true -19.0 16232.0 1969-12-31 15:59:54.436 16232 NULL NULL NULL NULL NULL 10.175 19.0 -38.0 -38.0 2.63477824E8 -16232.0 NULL NULL -16232 NULL -15873.0 -16232 +528534767 NULL cvLH6Eat2yFsyy7p true -11.0 16189.0 1969-12-31 15:59:49.014 16189 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 2.62083721E8 -16189.0 NULL NULL -16189 NULL -15830.0 -16189 +528534767 NULL cvLH6Eat2yFsyy7p true -52.0 14159.0 1969-12-31 15:59:45.157 14159 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 2.00477281E8 -14159.0 NULL NULL -14159 NULL -13800.0 -14159 +528534767 NULL cvLH6Eat2yFsyy7p true -31.0 15678.0 1969-12-31 15:59:47.982 15678 NULL NULL NULL NULL NULL 10.175 31.0 -62.0 -62.0 2.45799684E8 -15678.0 NULL NULL -15678 NULL -15319.0 -15678 +528534767 NULL cvLH6Eat2yFsyy7p true 31.0 3119.0 1969-12-31 15:59:51.649 3119 NULL NULL NULL NULL NULL 10.175 -31.0 62.0 62.0 9728161.0 -3119.0 NULL NULL -3119 NULL -2760.0 -3119 +528534767 NULL cvLH6Eat2yFsyy7p true -54.0 11632.0 1969-12-31 15:59:58.063 11632 NULL NULL NULL NULL NULL 10.175 54.0 -108.0 -108.0 1.35303424E8 -11632.0 NULL NULL -11632 NULL -11273.0 -11632 +528534767 NULL cvLH6Eat2yFsyy7p true 62.0 11668.0 1969-12-31 15:59:49.209 11668 NULL NULL NULL NULL NULL 10.175 -62.0 124.0 124.0 1.36142224E8 -11668.0 NULL NULL -11668 NULL -11309.0 -11668 +528534767 NULL cvLH6Eat2yFsyy7p true 58.0 12050.0 1969-12-31 15:59:46.322 12050 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 1.452025E8 -12050.0 NULL NULL -12050 NULL -11691.0 -12050 +528534767 NULL cvLH6Eat2yFsyy7p true -58.0 4811.0 1969-12-31 15:59:45.415 4811 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 2.3145721E7 -4811.0 NULL NULL -4811 NULL -4452.0 -4811 +528534767 NULL cvLH6Eat2yFsyy7p true 1.0 6554.0 1969-12-31 15:59:45.562 6554 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 4.2954916E7 -6554.0 NULL NULL -6554 NULL -6195.0 -6554 +528534767 NULL cvLH6Eat2yFsyy7p true -14.0 13802.0 1969-12-31 15:59:47.475 13802 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 1.90495204E8 -13802.0 NULL NULL -13802 NULL -13443.0 -13802 +528534767 NULL cvLH6Eat2yFsyy7p true -62.0 13953.0 1969-12-31 15:59:45.965 13953 NULL NULL NULL NULL NULL 10.175 62.0 -124.0 -124.0 1.94686209E8 -13953.0 NULL NULL -13953 NULL -13594.0 -13953 +528534767 NULL cvLH6Eat2yFsyy7p true -20.0 7162.0 1969-12-31 15:59:51.99 7162 NULL NULL NULL NULL NULL 10.175 20.0 -40.0 -40.0 5.1294244E7 -7162.0 NULL NULL -7162 NULL -6803.0 -7162 +528534767 NULL cvLH6Eat2yFsyy7p true -58.0 8744.0 1969-12-31 15:59:54.531 8744 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 7.6457536E7 -8744.0 NULL NULL -8744 NULL -8385.0 -8744 +528534767 NULL cvLH6Eat2yFsyy7p true 29.0 5617.0 1969-12-31 15:59:44.546 5617 NULL NULL NULL NULL NULL 10.175 -29.0 58.0 58.0 3.1550689E7 -5617.0 NULL NULL -5617 NULL -5258.0 -5617 +528534767 NULL cvLH6Eat2yFsyy7p true 35.0 6864.0 1969-12-31 15:59:50.582 6864 NULL NULL NULL NULL NULL 10.175 -35.0 70.0 70.0 4.7114496E7 -6864.0 NULL NULL -6864 NULL -6505.0 -6864 +528534767 NULL cvLH6Eat2yFsyy7p true 14.0 6048.0 1969-12-31 15:59:51.186 6048 NULL NULL NULL NULL NULL 10.175 -14.0 28.0 28.0 3.6578304E7 -6048.0 NULL NULL -6048 NULL -5689.0 -6048 +528534767 NULL cvLH6Eat2yFsyy7p true 48.0 13909.0 1969-12-31 15:59:57.068 13909 NULL NULL NULL NULL NULL 10.175 -48.0 96.0 96.0 1.93460281E8 -13909.0 NULL NULL -13909 NULL -13550.0 -13909 +528534767 NULL cvLH6Eat2yFsyy7p true 49.0 8465.0 1969-12-31 15:59:58.572 8465 NULL NULL NULL NULL NULL 10.175 -49.0 98.0 98.0 7.1656225E7 -8465.0 NULL NULL -8465 NULL -8106.0 -8465 +528534767 NULL cvLH6Eat2yFsyy7p true 38.0 12157.0 1969-12-31 15:59:47.279 12157 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 1.47792649E8 -12157.0 NULL NULL -12157 NULL -11798.0 -12157 +528534767 NULL cvLH6Eat2yFsyy7p true 6.0 6725.0 1969-12-31 15:59:46.403 6725 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 4.5225625E7 -6725.0 NULL NULL -6725 NULL -6366.0 -6725 +528534767 NULL cvLH6Eat2yFsyy7p true 54.0 12750.0 1969-12-31 15:59:56.254 12750 NULL NULL NULL NULL NULL 10.175 -54.0 108.0 108.0 1.625625E8 -12750.0 NULL NULL -12750 NULL -12391.0 -12750 +528534767 NULL cvLH6Eat2yFsyy7p true -7.0 14195.0 1969-12-31 15:59:48.403 14195 NULL NULL NULL NULL NULL 3.1750000000000007 7.0 -14.0 -14.0 2.01498025E8 -14195.0 NULL NULL -14195 NULL -13836.0 -14195 +528534767 NULL cvLH6Eat2yFsyy7p true -7.0 15551.0 1969-12-31 15:59:49.689 15551 NULL NULL NULL NULL NULL 3.1750000000000007 7.0 -14.0 -14.0 2.41833601E8 -15551.0 NULL NULL -15551 NULL -15192.0 -15551 +528534767 NULL cvLH6Eat2yFsyy7p true -30.0 13677.0 1969-12-31 15:59:54.988 13677 NULL NULL NULL NULL NULL 10.175 30.0 -60.0 -60.0 1.87060329E8 -13677.0 NULL NULL -13677 NULL -13318.0 -13677 +528534767 NULL cvLH6Eat2yFsyy7p true 2.0 11391.0 1969-12-31 15:59:49.331 11391 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 1.29754881E8 -11391.0 NULL NULL -11391 NULL -11032.0 -11391 +528534767 NULL cvLH6Eat2yFsyy7p true 57.0 7085.0 1969-12-31 15:59:46.666 7085 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 5.0197225E7 -7085.0 NULL NULL -7085 NULL -6726.0 -7085 +528534767 NULL cvLH6Eat2yFsyy7p true 1.0 6903.0 1969-12-31 15:59:54.013 6903 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 4.7651409E7 -6903.0 NULL NULL -6903 NULL -6544.0 -6903 +528534767 NULL cvLH6Eat2yFsyy7p true 3.0 9857.0 1969-12-31 15:59:43.832 9857 NULL NULL NULL NULL NULL 1.1750000000000007 -3.0 6.0 6.0 9.7160449E7 -9857.0 NULL NULL -9857 NULL -9498.0 -9857 +528534767 NULL cvLH6Eat2yFsyy7p true 8.0 4783.0 1969-12-31 15:59:56.456 4783 NULL NULL NULL NULL NULL 2.1750000000000007 -8.0 16.0 16.0 2.2877089E7 -4783.0 NULL NULL -4783 NULL -4424.0 -4783 +528534767 NULL cvLH6Eat2yFsyy7p true -39.0 11054.0 1969-12-31 15:59:49.854 11054 NULL NULL NULL NULL NULL 10.175 39.0 -78.0 -78.0 1.22190916E8 -11054.0 NULL NULL -11054 NULL -10695.0 -11054 +528534767 NULL cvLH6Eat2yFsyy7p true 7.0 13748.0 1969-12-31 15:59:46.53 13748 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 1.89007504E8 -13748.0 NULL NULL -13748 NULL -13389.0 -13748 +528534767 NULL cvLH6Eat2yFsyy7p true 6.0 13192.0 1969-12-31 15:59:49.394 13192 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 1.74028864E8 -13192.0 NULL NULL -13192 NULL -12833.0 -13192 +528534767 NULL cvLH6Eat2yFsyy7p true -21.0 13720.0 1969-12-31 15:59:54.868 13720 NULL NULL NULL NULL NULL 10.175 21.0 -42.0 -42.0 1.882384E8 -13720.0 NULL NULL -13720 NULL -13361.0 -13720 +528534767 NULL cvLH6Eat2yFsyy7p true 22.0 6114.0 1969-12-31 15:59:57.144 6114 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 3.7380996E7 -6114.0 NULL NULL -6114 NULL -5755.0 -6114 +528534767 NULL cvLH6Eat2yFsyy7p true -57.0 3846.0 1969-12-31 15:59:43.928 3846 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 1.4791716E7 -3846.0 NULL NULL -3846 NULL -3487.0 -3846 +528534767 NULL cvLH6Eat2yFsyy7p true 55.0 15429.0 1969-12-31 15:59:54.505 15429 NULL NULL NULL NULL NULL 10.175 -55.0 110.0 110.0 2.38054041E8 -15429.0 NULL NULL -15429 NULL -15070.0 -15429 +528534767 NULL cvLH6Eat2yFsyy7p true 29.0 3119.0 1969-12-31 15:59:54.321 3119 NULL NULL NULL NULL NULL 10.175 -29.0 58.0 58.0 9728161.0 -3119.0 NULL NULL -3119 NULL -2760.0 -3119 +528534767 NULL cvLH6Eat2yFsyy7p true 7.0 13347.0 1969-12-31 15:59:58.621 13347 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 1.78142409E8 -13347.0 NULL NULL -13347 NULL -12988.0 -13347 +528534767 NULL cvLH6Eat2yFsyy7p true 13.0 8790.0 1969-12-31 15:59:52.34 8790 NULL NULL NULL NULL NULL 10.175 -13.0 26.0 26.0 7.72641E7 -8790.0 NULL NULL -8790 NULL -8431.0 -8790 +528534767 NULL cvLH6Eat2yFsyy7p true 22.0 6967.0 1969-12-31 15:59:57.36 6967 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 4.8539089E7 -6967.0 NULL NULL -6967 NULL -6608.0 -6967 +528534767 NULL cvLH6Eat2yFsyy7p true 15.0 14966.0 1969-12-31 15:59:56.2 14966 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 2.23981156E8 -14966.0 NULL NULL -14966 NULL -14607.0 -14966 +528534767 NULL cvLH6Eat2yFsyy7p true -28.0 13783.0 1969-12-31 15:59:55.644 13783 NULL NULL NULL NULL NULL 10.175 28.0 -56.0 -56.0 1.89971089E8 -13783.0 NULL NULL -13783 NULL -13424.0 -13783 +528534767 NULL cvLH6Eat2yFsyy7p true 32.0 5063.0 1969-12-31 15:59:47.476 5063 NULL NULL NULL NULL NULL 10.175 -32.0 64.0 64.0 2.5633969E7 -5063.0 NULL NULL -5063 NULL -4704.0 -5063 +528534767 NULL cvLH6Eat2yFsyy7p true 56.0 14689.0 1969-12-31 15:59:52.821 14689 NULL NULL NULL NULL NULL 10.175 -56.0 112.0 112.0 2.15766721E8 -14689.0 NULL NULL -14689 NULL -14330.0 -14689 +528534767 NULL cvLH6Eat2yFsyy7p true 25.0 3248.0 1969-12-31 15:59:51.631 3248 NULL NULL NULL NULL NULL 10.175 -25.0 50.0 50.0 1.0549504E7 -3248.0 NULL NULL -3248 NULL -2889.0 -3248 +528534767 NULL cvLH6Eat2yFsyy7p true -11.0 13259.0 1969-12-31 15:59:45.058 13259 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 1.75801081E8 -13259.0 NULL NULL -13259 NULL -12900.0 -13259 +528534767 NULL cvLH6Eat2yFsyy7p true 14.0 13613.0 1969-12-31 15:59:51.515 13613 NULL NULL NULL NULL NULL 10.175 -14.0 28.0 28.0 1.85313769E8 -13613.0 NULL NULL -13613 NULL -13254.0 -13613 +528534767 NULL cvLH6Eat2yFsyy7p true -56.0 16069.0 1969-12-31 15:59:54.464 16069 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.58212761E8 -16069.0 NULL NULL -16069 NULL -15710.0 -16069 +528534767 NULL cvLH6Eat2yFsyy7p true 38.0 11230.0 1969-12-31 15:59:47.69 11230 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 1.261129E8 -11230.0 NULL NULL -11230 NULL -10871.0 -11230 +528534767 NULL cvLH6Eat2yFsyy7p true 11.0 4357.0 1969-12-31 15:59:54.109 4357 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 1.8983449E7 -4357.0 NULL NULL -4357 NULL -3998.0 -4357 +528534767 NULL cvLH6Eat2yFsyy7p true -55.0 4575.0 1969-12-31 15:59:45.291 4575 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 2.0930625E7 -4575.0 NULL NULL -4575 NULL -4216.0 -4575 +528534767 NULL cvLH6Eat2yFsyy7p true 26.0 4264.0 1969-12-31 15:59:47.426 4264 NULL NULL NULL NULL NULL 10.175 -26.0 52.0 52.0 1.8181696E7 -4264.0 NULL NULL -4264 NULL -3905.0 -4264 +528534767 NULL cvLH6Eat2yFsyy7p true 23.0 8661.0 1969-12-31 15:59:55.507 8661 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 7.5012921E7 -8661.0 NULL NULL -8661 NULL -8302.0 -8661 +528534767 NULL cvLH6Eat2yFsyy7p true -14.0 14778.0 1969-12-31 15:59:58.413 14778 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 2.18389284E8 -14778.0 NULL NULL -14778 NULL -14419.0 -14778 +528534767 NULL cvLH6Eat2yFsyy7p true 21.0 6663.0 1969-12-31 15:59:53.147 6663 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 4.4395569E7 -6663.0 NULL NULL -6663 NULL -6304.0 -6663 +528534767 NULL cvLH6Eat2yFsyy7p true 49.0 2594.0 1969-12-31 15:59:51.722 2594 NULL NULL NULL NULL NULL 10.175 -49.0 98.0 98.0 6728836.0 -2594.0 NULL NULL -2594 NULL -2235.0 -2594 +528534767 NULL cvLH6Eat2yFsyy7p true -63.0 8354.0 1969-12-31 15:59:50.29 8354 NULL NULL NULL NULL NULL 10.175 63.0 -126.0 -126.0 6.9789316E7 -8354.0 NULL NULL -8354 NULL -7995.0 -8354 +528534767 NULL cvLH6Eat2yFsyy7p true -61.0 15278.0 1969-12-31 15:59:46.886 15278 NULL NULL NULL NULL NULL 10.175 61.0 -122.0 -122.0 2.33417284E8 -15278.0 NULL NULL -15278 NULL -14919.0 -15278 +528534767 NULL cvLH6Eat2yFsyy7p true -57.0 8368.0 1969-12-31 15:59:56.964 8368 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 7.0023424E7 -8368.0 NULL NULL -8368 NULL -8009.0 -8368 +528534767 NULL cvLH6Eat2yFsyy7p true 20.0 13169.0 1969-12-31 15:59:51.541 13169 NULL NULL NULL NULL NULL 10.175 -20.0 40.0 40.0 1.73422561E8 -13169.0 NULL NULL -13169 NULL -12810.0 -13169 +528534767 NULL cvLH6Eat2yFsyy7p true 50.0 12235.0 1969-12-31 15:59:49.264 12235 NULL NULL NULL NULL NULL 10.175 -50.0 100.0 100.0 1.49695225E8 -12235.0 NULL NULL -12235 NULL -11876.0 -12235 +528534767 NULL cvLH6Eat2yFsyy7p true -54.0 11979.0 1969-12-31 15:59:49.904 11979 NULL NULL NULL NULL NULL 10.175 54.0 -108.0 -108.0 1.43496441E8 -11979.0 NULL NULL -11979 NULL -11620.0 -11979 +528534767 NULL cvLH6Eat2yFsyy7p true 29.0 8442.0 1969-12-31 15:59:50.551 8442 NULL NULL NULL NULL NULL 10.175 -29.0 58.0 58.0 7.1267364E7 -8442.0 NULL NULL -8442 NULL -8083.0 -8442 +528534767 NULL cvLH6Eat2yFsyy7p true 41.0 8384.0 1969-12-31 15:59:53.901 8384 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 7.0291456E7 -8384.0 NULL NULL -8384 NULL -8025.0 -8384 +528534767 NULL cvLH6Eat2yFsyy7p true -40.0 4978.0 1969-12-31 15:59:55.097 4978 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 2.4780484E7 -4978.0 NULL NULL -4978 NULL -4619.0 -4978 +528534767 NULL cvLH6Eat2yFsyy7p true -29.0 4336.0 1969-12-31 15:59:55.107 4336 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 1.8800896E7 -4336.0 NULL NULL -4336 NULL -3977.0 -4336 +528534767 NULL cvLH6Eat2yFsyy7p true -36.0 16319.0 1969-12-31 15:59:58.214 16319 NULL NULL NULL NULL NULL 10.175 36.0 -72.0 -72.0 2.66309761E8 -16319.0 NULL NULL -16319 NULL -15960.0 -16319 +528534767 NULL cvLH6Eat2yFsyy7p true 30.0 10044.0 1969-12-31 15:59:49.971 10044 NULL NULL NULL NULL NULL 10.175 -30.0 60.0 60.0 1.00881936E8 -10044.0 NULL NULL -10044 NULL -9685.0 -10044 +528534767 NULL cvLH6Eat2yFsyy7p true -18.0 11625.0 1969-12-31 15:59:52.925 11625 NULL NULL NULL NULL NULL 10.175 18.0 -36.0 -36.0 1.35140625E8 -11625.0 NULL NULL -11625 NULL -11266.0 -11625 +528534767 NULL cvLH6Eat2yFsyy7p true 4.0 9351.0 1969-12-31 15:59:57.307 9351 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 8.7441201E7 -9351.0 NULL NULL -9351 NULL -8992.0 -9351 +528534767 NULL cvLH6Eat2yFsyy7p true -19.0 14547.0 1969-12-31 15:59:47.453 14547 NULL NULL NULL NULL NULL 10.175 19.0 -38.0 -38.0 2.11615209E8 -14547.0 NULL NULL -14547 NULL -14188.0 -14547 +528534767 NULL cvLH6Eat2yFsyy7p true -7.0 11847.0 1969-12-31 15:59:47.569 11847 NULL NULL NULL NULL NULL 3.1750000000000007 7.0 -14.0 -14.0 1.40351409E8 -11847.0 NULL NULL -11847 NULL -11488.0 -11847 +528534767 NULL cvLH6Eat2yFsyy7p true -34.0 12660.0 1969-12-31 15:59:44.105 12660 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 1.602756E8 -12660.0 NULL NULL -12660 NULL -12301.0 -12660 +528534767 NULL cvLH6Eat2yFsyy7p true -31.0 5792.0 1969-12-31 15:59:57.399 5792 NULL NULL NULL NULL NULL 10.175 31.0 -62.0 -62.0 3.3547264E7 -5792.0 NULL NULL -5792 NULL -5433.0 -5792 +528534767 NULL cvLH6Eat2yFsyy7p true -43.0 6626.0 1969-12-31 15:59:47.712 6626 NULL NULL NULL NULL NULL 10.175 43.0 -86.0 -86.0 4.3903876E7 -6626.0 NULL NULL -6626 NULL -6267.0 -6626 +528534767 NULL cvLH6Eat2yFsyy7p true 49.0 15523.0 1969-12-31 15:59:51.085 15523 NULL NULL NULL NULL NULL 10.175 -49.0 98.0 98.0 2.40963529E8 -15523.0 NULL NULL -15523 NULL -15164.0 -15523 +528534767 NULL cvLH6Eat2yFsyy7p true -57.0 4811.0 1969-12-31 15:59:51.928 4811 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 2.3145721E7 -4811.0 NULL NULL -4811 NULL -4452.0 -4811 +528534767 NULL cvLH6Eat2yFsyy7p true 51.0 5042.0 1969-12-31 15:59:43.779 5042 NULL NULL NULL NULL NULL 10.175 -51.0 102.0 102.0 2.5421764E7 -5042.0 NULL NULL -5042 NULL -4683.0 -5042 +528534767 NULL cvLH6Eat2yFsyy7p true -49.0 7482.0 1969-12-31 15:59:46.848 7482 NULL NULL NULL NULL NULL 10.175 49.0 -98.0 -98.0 5.5980324E7 -7482.0 NULL NULL -7482 NULL -7123.0 -7482 +528534767 NULL cvLH6Eat2yFsyy7p true -19.0 3805.0 1969-12-31 15:59:45.129 3805 NULL NULL NULL NULL NULL 10.175 19.0 -38.0 -38.0 1.4478025E7 -3805.0 NULL NULL -3805 NULL -3446.0 -3805 +528534767 NULL cvLH6Eat2yFsyy7p true 9.0 7552.0 1969-12-31 15:59:55.967 7552 NULL NULL NULL NULL NULL 1.1750000000000007 -9.0 18.0 18.0 5.7032704E7 -7552.0 NULL NULL -7552 NULL -7193.0 -7552 +528534767 NULL cvLH6Eat2yFsyy7p true 41.0 16370.0 1969-12-31 15:59:58.089 16370 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 2.679769E8 -16370.0 NULL NULL -16370 NULL -16011.0 -16370 +528534767 NULL cvLH6Eat2yFsyy7p true 39.0 13352.0 1969-12-31 15:59:53.791 13352 NULL NULL NULL NULL NULL 10.175 -39.0 78.0 78.0 1.78275904E8 -13352.0 NULL NULL -13352 NULL -12993.0 -13352 +528534767 NULL cvLH6Eat2yFsyy7p true 8.0 7787.0 1969-12-31 15:59:49.916 7787 NULL NULL NULL NULL NULL 2.1750000000000007 -8.0 16.0 16.0 6.0637369E7 -7787.0 NULL NULL -7787 NULL -7428.0 -7787 +-462839731 988888 ss false -51.0 NULL NULL NULL Lml5J2QBU77 false -468.04059812638036 44.210000000033915 468.04059812638036 10.175 51.0 -102.0 -102.0 NULL NULL -988888 417.04059812638036 NULL 3569 NULL NULL +-635141101 -89010 ss false -51.0 NULL NULL NULL rVWAj4N1MCg8Scyp7wj2C true 7135.6151106617235 -69.74600000000305 -7135.6151106617235 10.175 51.0 -102.0 -102.0 NULL NULL 89010 -7186.6151106617235 NULL 3569 NULL NULL +626923679 NULL 821UdmGbkEf4j true 4.0 7648.0 1969-12-31 15:59:50.499 7648 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 5.8491904E7 -7648.0 NULL NULL -7648 NULL -7289.0 -7648 +626923679 NULL 821UdmGbkEf4j true -4.0 6852.0 1969-12-31 15:59:47.122 6852 NULL NULL NULL NULL NULL 2.1750000000000007 4.0 -8.0 -8.0 4.6949904E7 -6852.0 NULL NULL -6852 NULL -6493.0 -6852 +626923679 NULL 821UdmGbkEf4j true 51.0 14567.0 1969-12-31 15:59:50.578 14567 NULL NULL NULL NULL NULL 10.175 -51.0 102.0 102.0 2.12197489E8 -14567.0 NULL NULL -14567 NULL -14208.0 -14567 +626923679 NULL 821UdmGbkEf4j true 5.0 10436.0 1969-12-31 15:59:52.804 10436 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 1.08910096E8 -10436.0 NULL NULL -10436 NULL -10077.0 -10436 +626923679 NULL 821UdmGbkEf4j true -23.0 8896.0 1969-12-31 15:59:45.279 8896 NULL NULL NULL NULL NULL 10.175 23.0 -46.0 -46.0 7.9138816E7 -8896.0 NULL NULL -8896 NULL -8537.0 -8896 +626923679 NULL 821UdmGbkEf4j true -33.0 11883.0 1969-12-31 15:59:57.009 11883 NULL NULL NULL NULL NULL 10.175 33.0 -66.0 -66.0 1.41205689E8 -11883.0 NULL NULL -11883 NULL -11524.0 -11883 +626923679 NULL 821UdmGbkEf4j true -8.0 12104.0 1969-12-31 15:59:47.203 12104 NULL NULL NULL NULL NULL 2.1750000000000007 8.0 -16.0 -16.0 1.46506816E8 -12104.0 NULL NULL -12104 NULL -11745.0 -12104 +626923679 NULL 821UdmGbkEf4j true -64.0 6811.0 1969-12-31 15:59:47.063 6811 NULL NULL NULL NULL NULL 10.175 64.0 -128.0 -128.0 4.6389721E7 -6811.0 NULL NULL -6811 NULL -6452.0 -6811 +626923679 NULL 821UdmGbkEf4j true 61.0 6004.0 1969-12-31 15:59:46.6 6004 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 3.6048016E7 -6004.0 NULL NULL -6004 NULL -5645.0 -6004 +626923679 NULL 821UdmGbkEf4j true -59.0 8781.0 1969-12-31 15:59:52.909 8781 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 7.7105961E7 -8781.0 NULL NULL -8781 NULL -8422.0 -8781 +626923679 NULL 821UdmGbkEf4j true 34.0 15890.0 1969-12-31 15:59:53.471 15890 NULL NULL NULL NULL NULL 10.175 -34.0 68.0 68.0 2.524921E8 -15890.0 NULL NULL -15890 NULL -15531.0 -15890 +626923679 NULL 821UdmGbkEf4j true -33.0 4024.0 1969-12-31 15:59:51.871 4024 NULL NULL NULL NULL NULL 10.175 33.0 -66.0 -66.0 1.6192576E7 -4024.0 NULL NULL -4024 NULL -3665.0 -4024 +626923679 NULL 821UdmGbkEf4j true 2.0 10953.0 1969-12-31 15:59:48.305 10953 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 1.19968209E8 -10953.0 NULL NULL -10953 NULL -10594.0 -10953 +626923679 NULL 821UdmGbkEf4j true -15.0 14626.0 1969-12-31 15:59:57.519 14626 NULL NULL NULL NULL NULL 10.175 15.0 -30.0 -30.0 2.13919876E8 -14626.0 NULL NULL -14626 NULL -14267.0 -14626 +626923679 NULL 821UdmGbkEf4j true -9.0 13411.0 1969-12-31 15:59:47.547 13411 NULL NULL NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 1.79854921E8 -13411.0 NULL NULL -13411 NULL -13052.0 -13411 +626923679 NULL 821UdmGbkEf4j true 4.0 8340.0 1969-12-31 15:59:43.731 8340 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 6.95556E7 -8340.0 NULL NULL -8340 NULL -7981.0 -8340 +626923679 NULL 821UdmGbkEf4j true 38.0 7046.0 1969-12-31 15:59:54.108 7046 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 4.9646116E7 -7046.0 NULL NULL -7046 NULL -6687.0 -7046 +626923679 NULL 821UdmGbkEf4j true 50.0 2972.0 1969-12-31 15:59:49.325 2972 NULL NULL NULL NULL NULL 10.175 -50.0 100.0 100.0 8832784.0 -2972.0 NULL NULL -2972 NULL -2613.0 -2972 +626923679 NULL 821UdmGbkEf4j true -38.0 6777.0 1969-12-31 15:59:52.3 6777 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 4.5927729E7 -6777.0 NULL NULL -6777 NULL -6418.0 -6777 +626923679 NULL 821UdmGbkEf4j true 39.0 12112.0 1969-12-31 15:59:44.717 12112 NULL NULL NULL NULL NULL 10.175 -39.0 78.0 78.0 1.46700544E8 -12112.0 NULL NULL -12112 NULL -11753.0 -12112 +626923679 NULL 821UdmGbkEf4j true 32.0 12200.0 1969-12-31 15:59:56.332 12200 NULL NULL NULL NULL NULL 10.175 -32.0 64.0 64.0 1.4884E8 -12200.0 NULL NULL -12200 NULL -11841.0 -12200 +626923679 NULL 821UdmGbkEf4j true 5.0 3066.0 1969-12-31 15:59:55.426 3066 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 9400356.0 -3066.0 NULL NULL -3066 NULL -2707.0 -3066 +626923679 NULL 821UdmGbkEf4j true 6.0 12529.0 1969-12-31 15:59:52.283 12529 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 1.56975841E8 -12529.0 NULL NULL -12529 NULL -12170.0 -12529 +626923679 NULL 821UdmGbkEf4j true -15.0 6506.0 1969-12-31 15:59:48.458 6506 NULL NULL NULL NULL NULL 10.175 15.0 -30.0 -30.0 4.2328036E7 -6506.0 NULL NULL -6506 NULL -6147.0 -6506 +626923679 NULL 821UdmGbkEf4j true 20.0 15014.0 1969-12-31 15:59:44.982 15014 NULL NULL NULL NULL NULL 10.175 -20.0 40.0 40.0 2.25420196E8 -15014.0 NULL NULL -15014 NULL -14655.0 -15014 +626923679 NULL 821UdmGbkEf4j true -58.0 15602.0 1969-12-31 15:59:50.529 15602 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 2.43422404E8 -15602.0 NULL NULL -15602 NULL -15243.0 -15602 +626923679 NULL 821UdmGbkEf4j true -35.0 4055.0 1969-12-31 15:59:45.254 4055 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 1.6443025E7 -4055.0 NULL NULL -4055 NULL -3696.0 -4055 +626923679 NULL 821UdmGbkEf4j true -53.0 10858.0 1969-12-31 15:59:44.99 10858 NULL NULL NULL NULL NULL 10.175 53.0 -106.0 -106.0 1.17896164E8 -10858.0 NULL NULL -10858 NULL -10499.0 -10858 +626923679 NULL 821UdmGbkEf4j true 14.0 10723.0 1969-12-31 15:59:48.497 10723 NULL NULL NULL NULL NULL 10.175 -14.0 28.0 28.0 1.14982729E8 -10723.0 NULL NULL -10723 NULL -10364.0 -10723 +626923679 NULL 821UdmGbkEf4j true 23.0 6838.0 1969-12-31 15:59:50.399 6838 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 4.6758244E7 -6838.0 NULL NULL -6838 NULL -6479.0 -6838 +626923679 NULL 821UdmGbkEf4j true 39.0 16279.0 1969-12-31 15:59:52.481 16279 NULL NULL NULL NULL NULL 10.175 -39.0 78.0 78.0 2.65005841E8 -16279.0 NULL NULL -16279 NULL -15920.0 -16279 +626923679 NULL 821UdmGbkEf4j true 47.0 7365.0 1969-12-31 15:59:52.547 7365 NULL NULL NULL NULL NULL 10.175 -47.0 94.0 94.0 5.4243225E7 -7365.0 NULL NULL -7365 NULL -7006.0 -7365 +626923679 NULL 821UdmGbkEf4j true -50.0 2707.0 1969-12-31 15:59:51.65 2707 NULL NULL NULL NULL NULL 10.175 50.0 -100.0 -100.0 7327849.0 -2707.0 NULL NULL -2707 NULL -2348.0 -2707 +626923679 NULL 821UdmGbkEf4j true 44.0 15609.0 1969-12-31 15:59:58.991 15609 NULL NULL NULL NULL NULL 10.175 -44.0 88.0 88.0 2.43640881E8 -15609.0 NULL NULL -15609 NULL -15250.0 -15609 +626923679 NULL 821UdmGbkEf4j true -1.0 10104.0 1969-12-31 15:59:50.713 10104 NULL NULL NULL NULL NULL 0.1750000000000007 1.0 -2.0 -2.0 1.02090816E8 -10104.0 NULL NULL -10104 NULL -9745.0 -10104 +626923679 NULL 821UdmGbkEf4j true -52.0 10785.0 1969-12-31 15:59:51.297 10785 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 1.16316225E8 -10785.0 NULL NULL -10785 NULL -10426.0 -10785 +626923679 NULL 821UdmGbkEf4j true -35.0 6576.0 1969-12-31 15:59:58.135 6576 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 4.3243776E7 -6576.0 NULL NULL -6576 NULL -6217.0 -6576 +626923679 NULL 821UdmGbkEf4j true -61.0 10211.0 1969-12-31 15:59:46.573 10211 NULL NULL NULL NULL NULL 10.175 61.0 -122.0 -122.0 1.04264521E8 -10211.0 NULL NULL -10211 NULL -9852.0 -10211 +626923679 NULL 821UdmGbkEf4j true -56.0 7175.0 1969-12-31 15:59:52.567 7175 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 5.1480625E7 -7175.0 NULL NULL -7175 NULL -6816.0 -7175 +626923679 NULL 821UdmGbkEf4j true -52.0 6516.0 1969-12-31 15:59:52.111 6516 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 4.2458256E7 -6516.0 NULL NULL -6516 NULL -6157.0 -6516 +626923679 NULL 821UdmGbkEf4j true -61.0 2657.0 1969-12-31 15:59:46.331 2657 NULL NULL NULL NULL NULL 10.175 61.0 -122.0 -122.0 7059649.0 -2657.0 NULL NULL -2657 NULL -2298.0 -2657 +626923679 NULL 821UdmGbkEf4j true -16.0 9892.0 1969-12-31 15:59:49.034 9892 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 9.7851664E7 -9892.0 NULL NULL -9892 NULL -9533.0 -9892 +626923679 NULL 821UdmGbkEf4j true 60.0 10187.0 1969-12-31 15:59:51.48 10187 NULL NULL NULL NULL NULL 10.175 -60.0 120.0 120.0 1.03774969E8 -10187.0 NULL NULL -10187 NULL -9828.0 -10187 +626923679 NULL 821UdmGbkEf4j true 14.0 15401.0 1969-12-31 15:59:48.875 15401 NULL NULL NULL NULL NULL 10.175 -14.0 28.0 28.0 2.37190801E8 -15401.0 NULL NULL -15401 NULL -15042.0 -15401 +626923679 NULL 821UdmGbkEf4j true 26.0 14191.0 1969-12-31 15:59:47.84 14191 NULL NULL NULL NULL NULL 10.175 -26.0 52.0 52.0 2.01384481E8 -14191.0 NULL NULL -14191 NULL -13832.0 -14191 +626923679 NULL 821UdmGbkEf4j true -1.0 14436.0 1969-12-31 15:59:46.623 14436 NULL NULL NULL NULL NULL 0.1750000000000007 1.0 -2.0 -2.0 2.08398096E8 -14436.0 NULL NULL -14436 NULL -14077.0 -14436 +626923679 NULL 821UdmGbkEf4j true 28.0 11841.0 1969-12-31 15:59:52.108 11841 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 1.40209281E8 -11841.0 NULL NULL -11841 NULL -11482.0 -11841 +626923679 NULL 821UdmGbkEf4j true -52.0 9971.0 1969-12-31 15:59:46.634 9971 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 9.9420841E7 -9971.0 NULL NULL -9971 NULL -9612.0 -9971 +626923679 NULL 821UdmGbkEf4j true 12.0 6300.0 1969-12-31 15:59:48.908 6300 NULL NULL NULL NULL NULL 10.175 -12.0 24.0 24.0 3.969E7 -6300.0 NULL NULL -6300 NULL -5941.0 -6300 +626923679 NULL 821UdmGbkEf4j true -27.0 11847.0 1969-12-31 15:59:46.328 11847 NULL NULL NULL NULL NULL 10.175 27.0 -54.0 -54.0 1.40351409E8 -11847.0 NULL NULL -11847 NULL -11488.0 -11847 +626923679 NULL 821UdmGbkEf4j true 27.0 2752.0 1969-12-31 15:59:49.211 2752 NULL NULL NULL NULL NULL 10.175 -27.0 54.0 54.0 7573504.0 -2752.0 NULL NULL -2752 NULL -2393.0 -2752 +626923679 NULL 821UdmGbkEf4j true -1.0 10601.0 1969-12-31 15:59:51.674 10601 NULL NULL NULL NULL NULL 0.1750000000000007 1.0 -2.0 -2.0 1.12381201E8 -10601.0 NULL NULL -10601 NULL -10242.0 -10601 +626923679 NULL 821UdmGbkEf4j true 37.0 12557.0 1969-12-31 15:59:48.338 12557 NULL NULL NULL NULL NULL 10.175 -37.0 74.0 74.0 1.57678249E8 -12557.0 NULL NULL -12557 NULL -12198.0 -12557 +626923679 NULL 821UdmGbkEf4j true -13.0 15958.0 1969-12-31 15:59:54.907 15958 NULL NULL NULL NULL NULL 10.175 13.0 -26.0 -26.0 2.54657764E8 -15958.0 NULL NULL -15958 NULL -15599.0 -15958 +626923679 NULL 821UdmGbkEf4j true 1.0 11449.0 1969-12-31 15:59:54.582 11449 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 1.31079601E8 -11449.0 NULL NULL -11449 NULL -11090.0 -11449 +626923679 NULL 821UdmGbkEf4j true -55.0 16056.0 1969-12-31 15:59:56.447 16056 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 2.57795136E8 -16056.0 NULL NULL -16056 NULL -15697.0 -16056 +626923679 NULL 821UdmGbkEf4j true 11.0 3357.0 1969-12-31 15:59:49.336 3357 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 1.1269449E7 -3357.0 NULL NULL -3357 NULL -2998.0 -3357 +626923679 NULL 821UdmGbkEf4j true -37.0 10551.0 1969-12-31 15:59:54.984 10551 NULL NULL NULL NULL NULL 10.175 37.0 -74.0 -74.0 1.11323601E8 -10551.0 NULL NULL -10551 NULL -10192.0 -10551 +626923679 NULL 821UdmGbkEf4j true 40.0 11476.0 1969-12-31 15:59:58.159 11476 NULL NULL NULL NULL NULL 10.175 -40.0 80.0 80.0 1.31698576E8 -11476.0 NULL NULL -11476 NULL -11117.0 -11476 +626923679 NULL 821UdmGbkEf4j true -39.0 8234.0 1969-12-31 15:59:52.602 8234 NULL NULL NULL NULL NULL 10.175 39.0 -78.0 -78.0 6.7798756E7 -8234.0 NULL NULL -8234 NULL -7875.0 -8234 +626923679 NULL 821UdmGbkEf4j true -30.0 4997.0 1969-12-31 15:59:50.159 4997 NULL NULL NULL NULL NULL 10.175 30.0 -60.0 -60.0 2.4970009E7 -4997.0 NULL NULL -4997 NULL -4638.0 -4997 +626923679 NULL 821UdmGbkEf4j true -11.0 9842.0 1969-12-31 15:59:44.225 9842 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 9.6864964E7 -9842.0 NULL NULL -9842 NULL -9483.0 -9842 +626923679 NULL 821UdmGbkEf4j true 39.0 13438.0 1969-12-31 15:59:49.517 13438 NULL NULL NULL NULL NULL 10.175 -39.0 78.0 78.0 1.80579844E8 -13438.0 NULL NULL -13438 NULL -13079.0 -13438 +626923679 NULL 821UdmGbkEf4j true -31.0 2814.0 1969-12-31 15:59:49.916 2814 NULL NULL NULL NULL NULL 10.175 31.0 -62.0 -62.0 7918596.0 -2814.0 NULL NULL -2814 NULL -2455.0 -2814 +626923679 NULL 821UdmGbkEf4j true -25.0 14709.0 1969-12-31 15:59:49.121 14709 NULL NULL NULL NULL NULL 10.175 25.0 -50.0 -50.0 2.16354681E8 -14709.0 NULL NULL -14709 NULL -14350.0 -14709 +626923679 NULL 821UdmGbkEf4j true 24.0 6731.0 1969-12-31 15:59:50.922 6731 NULL NULL NULL NULL NULL 10.175 -24.0 48.0 48.0 4.5306361E7 -6731.0 NULL NULL -6731 NULL -6372.0 -6731 +626923679 NULL 821UdmGbkEf4j true -7.0 9791.0 1969-12-31 15:59:53.597 9791 NULL NULL NULL NULL NULL 3.1750000000000007 7.0 -14.0 -14.0 9.5863681E7 -9791.0 NULL NULL -9791 NULL -9432.0 -9791 +626923679 NULL 821UdmGbkEf4j true -48.0 11197.0 1969-12-31 15:59:52.232 11197 NULL NULL NULL NULL NULL 10.175 48.0 -96.0 -96.0 1.25372809E8 -11197.0 NULL NULL -11197 NULL -10838.0 -11197 +626923679 NULL 821UdmGbkEf4j true -34.0 4967.0 1969-12-31 15:59:44.577 4967 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 2.4671089E7 -4967.0 NULL NULL -4967 NULL -4608.0 -4967 +626923679 NULL 821UdmGbkEf4j true 44.0 3855.0 1969-12-31 15:59:58.864 3855 NULL NULL NULL NULL NULL 10.175 -44.0 88.0 88.0 1.4861025E7 -3855.0 NULL NULL -3855 NULL -3496.0 -3855 +626923679 NULL 821UdmGbkEf4j true -13.0 14569.0 1969-12-31 15:59:53.456 14569 NULL NULL NULL NULL NULL 10.175 13.0 -26.0 -26.0 2.12255761E8 -14569.0 NULL NULL -14569 NULL -14210.0 -14569 +626923679 NULL 821UdmGbkEf4j true -40.0 13153.0 1969-12-31 15:59:51.016 13153 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 1.73001409E8 -13153.0 NULL NULL -13153 NULL -12794.0 -13153 +626923679 NULL 821UdmGbkEf4j true 62.0 8882.0 1969-12-31 15:59:58.334 8882 NULL NULL NULL NULL NULL 10.175 -62.0 124.0 124.0 7.8889924E7 -8882.0 NULL NULL -8882 NULL -8523.0 -8882 +626923679 NULL 821UdmGbkEf4j true 6.0 10548.0 1969-12-31 15:59:49.252 10548 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 1.11260304E8 -10548.0 NULL NULL -10548 NULL -10189.0 -10548 +626923679 NULL 821UdmGbkEf4j true 54.0 14965.0 1969-12-31 15:59:55.88 14965 NULL NULL NULL NULL NULL 10.175 -54.0 108.0 108.0 2.23951225E8 -14965.0 NULL NULL -14965 NULL -14606.0 -14965 +626923679 NULL 821UdmGbkEf4j true -25.0 4696.0 1969-12-31 15:59:58.657 4696 NULL NULL NULL NULL NULL 10.175 25.0 -50.0 -50.0 2.2052416E7 -4696.0 NULL NULL -4696 NULL -4337.0 -4696 +626923679 NULL 821UdmGbkEf4j true 43.0 15111.0 1969-12-31 15:59:48.489 15111 NULL NULL NULL NULL NULL 10.175 -43.0 86.0 86.0 2.28342321E8 -15111.0 NULL NULL -15111 NULL -14752.0 -15111 +626923679 NULL 821UdmGbkEf4j true -24.0 3944.0 1969-12-31 15:59:56.713 3944 NULL NULL NULL NULL NULL 10.175 24.0 -48.0 -48.0 1.5555136E7 -3944.0 NULL NULL -3944 NULL -3585.0 -3944 +626923679 NULL 821UdmGbkEf4j true -27.0 5369.0 1969-12-31 15:59:58.131 5369 NULL NULL NULL NULL NULL 10.175 27.0 -54.0 -54.0 2.8826161E7 -5369.0 NULL NULL -5369 NULL -5010.0 -5369 +626923679 NULL 821UdmGbkEf4j true -29.0 4977.0 1969-12-31 15:59:44.697 4977 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 2.4770529E7 -4977.0 NULL NULL -4977 NULL -4618.0 -4977 +626923679 NULL 821UdmGbkEf4j true 1.0 6256.0 1969-12-31 15:59:53.094 6256 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 3.9137536E7 -6256.0 NULL NULL -6256 NULL -5897.0 -6256 +626923679 NULL 821UdmGbkEf4j true -37.0 15296.0 1969-12-31 15:59:48.773 15296 NULL NULL NULL NULL NULL 10.175 37.0 -74.0 -74.0 2.33967616E8 -15296.0 NULL NULL -15296 NULL -14937.0 -15296 +626923679 NULL 821UdmGbkEf4j true -63.0 9539.0 1969-12-31 15:59:45.568 9539 NULL NULL NULL NULL NULL 10.175 63.0 -126.0 -126.0 9.0992521E7 -9539.0 NULL NULL -9539 NULL -9180.0 -9539 +626923679 NULL 821UdmGbkEf4j true -6.0 4469.0 1969-12-31 15:59:53.157 4469 NULL NULL NULL NULL NULL 4.175000000000001 6.0 -12.0 -12.0 1.9971961E7 -4469.0 NULL NULL -4469 NULL -4110.0 -4469 +626923679 NULL 821UdmGbkEf4j true 2.0 15749.0 1969-12-31 15:59:54.116 15749 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 2.48031001E8 -15749.0 NULL NULL -15749 NULL -15390.0 -15749 +626923679 NULL 821UdmGbkEf4j true 16.0 9390.0 1969-12-31 15:59:47.126 9390 NULL NULL NULL NULL NULL 10.175 -16.0 32.0 32.0 8.81721E7 -9390.0 NULL NULL -9390 NULL -9031.0 -9390 +626923679 NULL 821UdmGbkEf4j true -47.0 2804.0 1969-12-31 15:59:55.335 2804 NULL NULL NULL NULL NULL 10.175 47.0 -94.0 -94.0 7862416.0 -2804.0 NULL NULL -2804 NULL -2445.0 -2804 +626923679 NULL 821UdmGbkEf4j true 1.0 14662.0 1969-12-31 15:59:56.565 14662 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 2.14974244E8 -14662.0 NULL NULL -14662 NULL -14303.0 -14662 +626923679 NULL 821UdmGbkEf4j true -35.0 4625.0 1969-12-31 15:59:58.816 4625 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 2.1390625E7 -4625.0 NULL NULL -4625 NULL -4266.0 -4625 +626923679 NULL 821UdmGbkEf4j true 38.0 9925.0 1969-12-31 15:59:47.483 9925 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 9.8505625E7 -9925.0 NULL NULL -9925 NULL -9566.0 -9925 +626923679 NULL 821UdmGbkEf4j true 13.0 5290.0 1969-12-31 15:59:43.693 5290 NULL NULL NULL NULL NULL 10.175 -13.0 26.0 26.0 2.79841E7 -5290.0 NULL NULL -5290 NULL -4931.0 -5290 +626923679 NULL 821UdmGbkEf4j true 57.0 6776.0 1969-12-31 15:59:48.071 6776 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 4.5914176E7 -6776.0 NULL NULL -6776 NULL -6417.0 -6776 +626923679 NULL 821UdmGbkEf4j true 10.0 2580.0 1969-12-31 15:59:54.759 2580 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 6656400.0 -2580.0 NULL NULL -2580 NULL -2221.0 -2580 +626923679 NULL 821UdmGbkEf4j true -58.0 15841.0 1969-12-31 15:59:50.468 15841 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 2.50937281E8 -15841.0 NULL NULL -15841 NULL -15482.0 -15841 +626923679 NULL 821UdmGbkEf4j true -56.0 14848.0 1969-12-31 15:59:51.357 14848 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.20463104E8 -14848.0 NULL NULL -14848 NULL -14489.0 -14848 +626923679 NULL 821UdmGbkEf4j true -42.0 12772.0 1969-12-31 15:59:53.578 12772 NULL NULL NULL NULL NULL 10.175 42.0 -84.0 -84.0 1.63123984E8 -12772.0 NULL NULL -12772 NULL -12413.0 -12772 +626923679 NULL 821UdmGbkEf4j true 23.0 11059.0 1969-12-31 15:59:53.891 11059 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 1.22301481E8 -11059.0 NULL NULL -11059 NULL -10700.0 -11059 +626923679 NULL 821UdmGbkEf4j true -11.0 13678.0 1969-12-31 15:59:47.797 13678 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 1.87087684E8 -13678.0 NULL NULL -13678 NULL -13319.0 -13678 +626923679 NULL 821UdmGbkEf4j true 23.0 6935.0 1969-12-31 15:59:48.845 6935 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 4.8094225E7 -6935.0 NULL NULL -6935 NULL -6576.0 -6935 +626923679 NULL 821UdmGbkEf4j true 52.0 6018.0 1969-12-31 15:59:54.388 6018 NULL NULL NULL NULL NULL 10.175 -52.0 104.0 104.0 3.6216324E7 -6018.0 NULL NULL -6018 NULL -5659.0 -6018 +626923679 NULL 821UdmGbkEf4j true -31.0 3834.0 1969-12-31 15:59:53.891 3834 NULL NULL NULL NULL NULL 10.175 31.0 -62.0 -62.0 1.4699556E7 -3834.0 NULL NULL -3834 NULL -3475.0 -3834 +626923679 NULL 821UdmGbkEf4j true -17.0 8386.0 1969-12-31 15:59:48.73 8386 NULL NULL NULL NULL NULL 10.175 17.0 -34.0 -34.0 7.0324996E7 -8386.0 NULL NULL -8386 NULL -8027.0 -8386 +626923679 NULL 821UdmGbkEf4j true -8.0 9100.0 1969-12-31 15:59:50.336 9100 NULL NULL NULL NULL NULL 2.1750000000000007 8.0 -16.0 -16.0 8.281E7 -9100.0 NULL NULL -9100 NULL -8741.0 -9100 +626923679 NULL 821UdmGbkEf4j true -38.0 7109.0 1969-12-31 15:59:56.023 7109 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 5.0537881E7 -7109.0 NULL NULL -7109 NULL -6750.0 -7109 +626923679 NULL 821UdmGbkEf4j true -23.0 6866.0 1969-12-31 15:59:52.685 6866 NULL NULL NULL NULL NULL 10.175 23.0 -46.0 -46.0 4.7141956E7 -6866.0 NULL NULL -6866 NULL -6507.0 -6866 +626923679 NULL 821UdmGbkEf4j true 16.0 7485.0 1969-12-31 15:59:56.198 7485 NULL NULL NULL NULL NULL 10.175 -16.0 32.0 32.0 5.6025225E7 -7485.0 NULL NULL -7485 NULL -7126.0 -7485 +626923679 NULL 821UdmGbkEf4j true 60.0 8000.0 1969-12-31 15:59:49.61 8000 NULL NULL NULL NULL NULL 10.175 -60.0 120.0 120.0 6.4E7 -8000.0 NULL NULL -8000 NULL -7641.0 -8000 +626923679 NULL 821UdmGbkEf4j true -58.0 15909.0 1969-12-31 15:59:47.258 15909 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 2.53096281E8 -15909.0 NULL NULL -15909 NULL -15550.0 -15909 +626923679 NULL 821UdmGbkEf4j true 2.0 14247.0 1969-12-31 15:59:47.819 14247 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 2.02977009E8 -14247.0 NULL NULL -14247 NULL -13888.0 -14247 +626923679 NULL 821UdmGbkEf4j true -29.0 10452.0 1969-12-31 15:59:44.833 10452 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 1.09244304E8 -10452.0 NULL NULL -10452 NULL -10093.0 -10452 +626923679 NULL 821UdmGbkEf4j true 2.0 15298.0 1969-12-31 15:59:45.866 15298 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 2.34028804E8 -15298.0 NULL NULL -15298 NULL -14939.0 -15298 +626923679 NULL 821UdmGbkEf4j true -55.0 4513.0 1969-12-31 15:59:58.636 4513 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 2.0367169E7 -4513.0 NULL NULL -4513 NULL -4154.0 -4513 +626923679 NULL 821UdmGbkEf4j true -32.0 4136.0 1969-12-31 15:59:54.53 4136 NULL NULL NULL NULL NULL 10.175 32.0 -64.0 -64.0 1.7106496E7 -4136.0 NULL NULL -4136 NULL -3777.0 -4136 +626923679 NULL 821UdmGbkEf4j true 30.0 11642.0 1969-12-31 15:59:43.694 11642 NULL NULL NULL NULL NULL 10.175 -30.0 60.0 60.0 1.35536164E8 -11642.0 NULL NULL -11642 NULL -11283.0 -11642 +626923679 NULL 821UdmGbkEf4j true -28.0 7302.0 1969-12-31 15:59:30.929 7302 NULL NULL NULL NULL NULL 10.175 28.0 -56.0 -56.0 5.3319204E7 -7302.0 NULL NULL -7302 NULL -6943.0 -7302 +626923679 NULL 821UdmGbkEf4j true -59.0 6738.0 1969-12-31 15:59:54.299 6738 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 4.5400644E7 -6738.0 NULL NULL -6738 NULL -6379.0 -6738 +626923679 NULL 821UdmGbkEf4j true -42.0 3333.0 1969-12-31 15:59:54.135 3333 NULL NULL NULL NULL NULL 10.175 42.0 -84.0 -84.0 1.1108889E7 -3333.0 NULL NULL -3333 NULL -2974.0 -3333 +626923679 NULL 821UdmGbkEf4j true -59.0 11028.0 1969-12-31 15:59:44.085 11028 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 1.21616784E8 -11028.0 NULL NULL -11028 NULL -10669.0 -11028 +626923679 NULL 821UdmGbkEf4j true -57.0 4120.0 1969-12-31 15:59:51.744 4120 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 1.69744E7 -4120.0 NULL NULL -4120 NULL -3761.0 -4120 +626923679 NULL 821UdmGbkEf4j true -24.0 7651.0 1969-12-31 15:59:57.405 7651 NULL NULL NULL NULL NULL 10.175 24.0 -48.0 -48.0 5.8537801E7 -7651.0 NULL NULL -7651 NULL -7292.0 -7651 +626923679 NULL 821UdmGbkEf4j true -10.0 13495.0 1969-12-31 15:59:49.195 13495 NULL NULL NULL NULL NULL 0.1750000000000007 10.0 -20.0 -20.0 1.82115025E8 -13495.0 NULL NULL -13495 NULL -13136.0 -13495 +626923679 NULL 821UdmGbkEf4j true 41.0 11165.0 1969-12-31 15:59:49.621 11165 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 1.24657225E8 -11165.0 NULL NULL -11165 NULL -10806.0 -11165 +626923679 NULL 821UdmGbkEf4j true 55.0 9934.0 1969-12-31 15:59:56.278 9934 NULL NULL NULL NULL NULL 10.175 -55.0 110.0 110.0 9.8684356E7 -9934.0 NULL NULL -9934 NULL -9575.0 -9934 +626923679 NULL 821UdmGbkEf4j true -14.0 10394.0 1969-12-31 15:59:49.523 10394 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 1.08035236E8 -10394.0 NULL NULL -10394 NULL -10035.0 -10394 +626923679 NULL 821UdmGbkEf4j true 21.0 13071.0 1969-12-31 15:59:50.137 13071 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 1.70851041E8 -13071.0 NULL NULL -13071 NULL -12712.0 -13071 +626923679 NULL 821UdmGbkEf4j true 0.0 15193.0 1969-12-31 15:59:51.678 15193 NULL NULL NULL NULL NULL NaN -0.0 0.0 0.0 2.30827249E8 -15193.0 NULL NULL -15193 NULL -14834.0 -15193 +626923679 NULL 821UdmGbkEf4j true 58.0 8793.0 1969-12-31 15:59:46.796 8793 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 7.7316849E7 -8793.0 NULL NULL -8793 NULL -8434.0 -8793 +626923679 NULL 821UdmGbkEf4j true 48.0 6749.0 1969-12-31 15:59:46.94 6749 NULL NULL NULL NULL NULL 10.175 -48.0 96.0 96.0 4.5549001E7 -6749.0 NULL NULL -6749 NULL -6390.0 -6749 +626923679 NULL 821UdmGbkEf4j true -57.0 5630.0 1969-12-31 15:59:58.883 5630 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 3.16969E7 -5630.0 NULL NULL -5630 NULL -5271.0 -5630 +626923679 NULL 821UdmGbkEf4j true 22.0 12291.0 1969-12-31 15:59:55.183 12291 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 1.51068681E8 -12291.0 NULL NULL -12291 NULL -11932.0 -12291 +626923679 NULL 821UdmGbkEf4j true -58.0 12183.0 1969-12-31 15:59:54.631 12183 NULL NULL NULL NULL NULL 10.175 58.0 -116.0 -116.0 1.48425489E8 -12183.0 NULL NULL -12183 NULL -11824.0 -12183 +626923679 NULL 821UdmGbkEf4j true -54.0 5377.0 1969-12-31 15:59:50.699 5377 NULL NULL NULL NULL NULL 10.175 54.0 -108.0 -108.0 2.8912129E7 -5377.0 NULL NULL -5377 NULL -5018.0 -5377 +626923679 NULL 821UdmGbkEf4j true 25.0 10036.0 1969-12-31 15:59:53.481 10036 NULL NULL NULL NULL NULL 10.175 -25.0 50.0 50.0 1.00721296E8 -10036.0 NULL NULL -10036 NULL -9677.0 -10036 +626923679 NULL 821UdmGbkEf4j true 17.0 6827.0 1969-12-31 15:59:51.481 6827 NULL NULL NULL NULL NULL 10.175 -17.0 34.0 34.0 4.6607929E7 -6827.0 NULL NULL -6827 NULL -6468.0 -6827 +626923679 NULL 821UdmGbkEf4j true 48.0 5092.0 1969-12-31 15:59:46.639 5092 NULL NULL NULL NULL NULL 10.175 -48.0 96.0 96.0 2.5928464E7 -5092.0 NULL NULL -5092 NULL -4733.0 -5092 +626923679 NULL 821UdmGbkEf4j true -9.0 8580.0 1969-12-31 15:59:53.72 8580 NULL NULL NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 7.36164E7 -8580.0 NULL NULL -8580 NULL -8221.0 -8580 +626923679 NULL 821UdmGbkEf4j true -5.0 14241.0 1969-12-31 15:59:48.156 14241 NULL NULL NULL NULL NULL 0.1750000000000007 5.0 -10.0 -10.0 2.02806081E8 -14241.0 NULL NULL -14241 NULL -13882.0 -14241 +626923679 NULL 821UdmGbkEf4j true 4.0 3030.0 1969-12-31 15:59:54.347 3030 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 9180900.0 -3030.0 NULL NULL -3030 NULL -2671.0 -3030 +626923679 NULL 821UdmGbkEf4j true 38.0 7548.0 1969-12-31 15:59:52.465 7548 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 5.6972304E7 -7548.0 NULL NULL -7548 NULL -7189.0 -7548 +626923679 NULL 821UdmGbkEf4j true -1.0 10285.0 1969-12-31 15:59:48.14 10285 NULL NULL NULL NULL NULL 0.1750000000000007 1.0 -2.0 -2.0 1.05781225E8 -10285.0 NULL NULL -10285 NULL -9926.0 -10285 +626923679 NULL 821UdmGbkEf4j true -63.0 11457.0 1969-12-31 15:59:51.916 11457 NULL NULL NULL NULL NULL 10.175 63.0 -126.0 -126.0 1.31262849E8 -11457.0 NULL NULL -11457 NULL -11098.0 -11457 +626923679 NULL 821UdmGbkEf4j true 10.0 3874.0 1969-12-31 15:59:51.819 3874 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 1.5007876E7 -3874.0 NULL NULL -3874 NULL -3515.0 -3874 +626923679 NULL 821UdmGbkEf4j true -38.0 6340.0 1969-12-31 15:59:43.838 6340 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 4.01956E7 -6340.0 NULL NULL -6340 NULL -5981.0 -6340 +626923679 NULL 821UdmGbkEf4j true -56.0 4585.0 1969-12-31 15:59:47.222 4585 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.1022225E7 -4585.0 NULL NULL -4585 NULL -4226.0 -4585 +626923679 NULL 821UdmGbkEf4j true -5.0 9001.0 1969-12-31 15:59:52.914 9001 NULL NULL NULL NULL NULL 0.1750000000000007 5.0 -10.0 -10.0 8.1018001E7 -9001.0 NULL NULL -9001 NULL -8642.0 -9001 +626923679 NULL 821UdmGbkEf4j true -16.0 14076.0 1969-12-31 15:59:58.039 14076 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 1.98133776E8 -14076.0 NULL NULL -14076 NULL -13717.0 -14076 +626923679 NULL 821UdmGbkEf4j true 30.0 12141.0 1969-12-31 15:59:43.98 12141 NULL NULL NULL NULL NULL 10.175 -30.0 60.0 60.0 1.47403881E8 -12141.0 NULL NULL -12141 NULL -11782.0 -12141 +626923679 NULL 821UdmGbkEf4j true 41.0 3349.0 1969-12-31 15:59:44.162 3349 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 1.1215801E7 -3349.0 NULL NULL -3349 NULL -2990.0 -3349 +626923679 NULL 821UdmGbkEf4j true 3.0 8063.0 1969-12-31 15:59:46.76 8063 NULL NULL NULL NULL NULL 1.1750000000000007 -3.0 6.0 6.0 6.5011969E7 -8063.0 NULL NULL -8063 NULL -7704.0 -8063 +626923679 NULL 821UdmGbkEf4j true -44.0 5927.0 1969-12-31 15:59:45.724 5927 NULL NULL NULL NULL NULL 10.175 44.0 -88.0 -88.0 3.5129329E7 -5927.0 NULL NULL -5927 NULL -5568.0 -5927 +626923679 NULL 821UdmGbkEf4j true 37.0 7607.0 1969-12-31 15:59:54.702 7607 NULL NULL NULL NULL NULL 10.175 -37.0 74.0 74.0 5.7866449E7 -7607.0 NULL NULL -7607 NULL -7248.0 -7607 +626923679 NULL 821UdmGbkEf4j true 39.0 11148.0 1969-12-31 15:59:46.76 11148 NULL NULL NULL NULL NULL 10.175 -39.0 78.0 78.0 1.24277904E8 -11148.0 NULL NULL -11148 NULL -10789.0 -11148 +626923679 NULL 821UdmGbkEf4j true -2.0 15969.0 1969-12-31 15:59:50.715 15969 NULL NULL NULL NULL NULL 0.1750000000000007 2.0 -4.0 -4.0 2.55008961E8 -15969.0 NULL NULL -15969 NULL -15610.0 -15969 +626923679 NULL 821UdmGbkEf4j true 51.0 7006.0 1969-12-31 15:59:53.701 7006 NULL NULL NULL NULL NULL 10.175 -51.0 102.0 102.0 4.9084036E7 -7006.0 NULL NULL -7006 NULL -6647.0 -7006 +626923679 NULL 821UdmGbkEf4j true -53.0 13801.0 1969-12-31 15:59:53.001 13801 NULL NULL NULL NULL NULL 10.175 53.0 -106.0 -106.0 1.90467601E8 -13801.0 NULL NULL -13801 NULL -13442.0 -13801 +626923679 NULL 821UdmGbkEf4j true -43.0 12477.0 1969-12-31 15:59:58.893 12477 NULL NULL NULL NULL NULL 10.175 43.0 -86.0 -86.0 1.55675529E8 -12477.0 NULL NULL -12477 NULL -12118.0 -12477 +626923679 NULL 821UdmGbkEf4j true -16.0 8142.0 1969-12-31 15:59:48.325 8142 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 6.6292164E7 -8142.0 NULL NULL -8142 NULL -7783.0 -8142 +626923679 NULL 821UdmGbkEf4j true 8.0 5790.0 1969-12-31 15:59:55.389 5790 NULL NULL NULL NULL NULL 2.1750000000000007 -8.0 16.0 16.0 3.35241E7 -5790.0 NULL NULL -5790 NULL -5431.0 -5790 +626923679 NULL 821UdmGbkEf4j true 7.0 15169.0 1969-12-31 15:59:58.709 15169 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 2.30098561E8 -15169.0 NULL NULL -15169 NULL -14810.0 -15169 +626923679 NULL 821UdmGbkEf4j true 43.0 6690.0 1969-12-31 15:59:54.374 6690 NULL NULL NULL NULL NULL 10.175 -43.0 86.0 86.0 4.47561E7 -6690.0 NULL NULL -6690 NULL -6331.0 -6690 +626923679 NULL 821UdmGbkEf4j true 1.0 6072.0 1969-12-31 15:59:44.811 6072 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 3.6869184E7 -6072.0 NULL NULL -6072 NULL -5713.0 -6072 +626923679 NULL 821UdmGbkEf4j true 55.0 6413.0 1969-12-31 15:59:55.084 6413 NULL NULL NULL NULL NULL 10.175 -55.0 110.0 110.0 4.1126569E7 -6413.0 NULL NULL -6413 NULL -6054.0 -6413 +626923679 NULL 821UdmGbkEf4j true -43.0 14685.0 1969-12-31 15:59:53.151 14685 NULL NULL NULL NULL NULL 10.175 43.0 -86.0 -86.0 2.15649225E8 -14685.0 NULL NULL -14685 NULL -14326.0 -14685 +626923679 NULL 821UdmGbkEf4j true 44.0 9210.0 1969-12-31 15:59:52.882 9210 NULL NULL NULL NULL NULL 10.175 -44.0 88.0 88.0 8.48241E7 -9210.0 NULL NULL -9210 NULL -8851.0 -9210 +626923679 NULL 821UdmGbkEf4j true 42.0 11883.0 1969-12-31 15:59:47.296 11883 NULL NULL NULL NULL NULL 10.175 -42.0 84.0 84.0 1.41205689E8 -11883.0 NULL NULL -11883 NULL -11524.0 -11883 +626923679 NULL 821UdmGbkEf4j true 17.0 6469.0 1969-12-31 15:59:44.702 6469 NULL NULL NULL NULL NULL 10.175 -17.0 34.0 34.0 4.1847961E7 -6469.0 NULL NULL -6469 NULL -6110.0 -6469 +626923679 NULL 821UdmGbkEf4j true 57.0 13383.0 1969-12-31 15:59:48.276 13383 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 1.79104689E8 -13383.0 NULL NULL -13383 NULL -13024.0 -13383 +626923679 NULL 821UdmGbkEf4j true -54.0 7111.0 1969-12-31 15:59:49.584 7111 NULL NULL NULL NULL NULL 10.175 54.0 -108.0 -108.0 5.0566321E7 -7111.0 NULL NULL -7111 NULL -6752.0 -7111 +626923679 NULL 821UdmGbkEf4j true 6.0 15375.0 1969-12-31 15:59:52.754 15375 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 2.36390625E8 -15375.0 NULL NULL -15375 NULL -15016.0 -15375 +626923679 NULL 821UdmGbkEf4j true 57.0 5722.0 1969-12-31 15:59:44.269 5722 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 3.2741284E7 -5722.0 NULL NULL -5722 NULL -5363.0 -5722 +626923679 NULL 821UdmGbkEf4j true 24.0 5147.0 1969-12-31 15:59:48.479 5147 NULL NULL NULL NULL NULL 10.175 -24.0 48.0 48.0 2.6491609E7 -5147.0 NULL NULL -5147 NULL -4788.0 -5147 +626923679 NULL 821UdmGbkEf4j true 2.0 5383.0 1969-12-31 15:59:46.315 5383 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 2.8976689E7 -5383.0 NULL NULL -5383 NULL -5024.0 -5383 +626923679 NULL 821UdmGbkEf4j true 22.0 7828.0 1969-12-31 15:59:51.06 7828 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 6.1277584E7 -7828.0 NULL NULL -7828 NULL -7469.0 -7828 +626923679 NULL 821UdmGbkEf4j true 7.0 5105.0 1969-12-31 15:59:58.764 5105 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 2.6061025E7 -5105.0 NULL NULL -5105 NULL -4746.0 -5105 +626923679 NULL 821UdmGbkEf4j true 3.0 14909.0 1969-12-31 15:59:56.053 14909 NULL NULL NULL NULL NULL 1.1750000000000007 -3.0 6.0 6.0 2.22278281E8 -14909.0 NULL NULL -14909 NULL -14550.0 -14909 +626923679 NULL 821UdmGbkEf4j true 28.0 14040.0 1969-12-31 15:59:46.77 14040 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 1.971216E8 -14040.0 NULL NULL -14040 NULL -13681.0 -14040 +626923679 NULL 821UdmGbkEf4j true -39.0 9907.0 1969-12-31 15:59:54.496 9907 NULL NULL NULL NULL NULL 10.175 39.0 -78.0 -78.0 9.8148649E7 -9907.0 NULL NULL -9907 NULL -9548.0 -9907 +626923679 NULL 821UdmGbkEf4j true 31.0 9930.0 1969-12-31 15:59:52.308 9930 NULL NULL NULL NULL NULL 10.175 -31.0 62.0 62.0 9.86049E7 -9930.0 NULL NULL -9930 NULL -9571.0 -9930 +626923679 NULL 821UdmGbkEf4j true 15.0 6380.0 1969-12-31 15:59:49 6380 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 4.07044E7 -6380.0 NULL NULL -6380 NULL -6021.0 -6380 +626923679 NULL 821UdmGbkEf4j true 10.0 11595.0 1969-12-31 15:59:57.406 11595 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 1.34444025E8 -11595.0 NULL NULL -11595 NULL -11236.0 -11595 +626923679 NULL 821UdmGbkEf4j true 25.0 12905.0 1969-12-31 15:59:51.677 12905 NULL NULL NULL NULL NULL 10.175 -25.0 50.0 50.0 1.66539025E8 -12905.0 NULL NULL -12905 NULL -12546.0 -12905 +626923679 NULL 821UdmGbkEf4j true -34.0 5680.0 1969-12-31 15:59:58.436 5680 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 3.22624E7 -5680.0 NULL NULL -5680 NULL -5321.0 -5680 +626923679 NULL 821UdmGbkEf4j true -29.0 6346.0 1969-12-31 15:59:46.632 6346 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 4.0271716E7 -6346.0 NULL NULL -6346 NULL -5987.0 -6346 +626923679 NULL 821UdmGbkEf4j true -21.0 14318.0 1969-12-31 15:59:58.997 14318 NULL NULL NULL NULL NULL 10.175 21.0 -42.0 -42.0 2.05005124E8 -14318.0 NULL NULL -14318 NULL -13959.0 -14318 +626923679 NULL 821UdmGbkEf4j true 9.0 15616.0 1969-12-31 15:59:49.187 15616 NULL NULL NULL NULL NULL 1.1750000000000007 -9.0 18.0 18.0 2.43859456E8 -15616.0 NULL NULL -15616 NULL -15257.0 -15616 +626923679 NULL 821UdmGbkEf4j true -27.0 10096.0 1969-12-31 15:59:45.703 10096 NULL NULL NULL NULL NULL 10.175 27.0 -54.0 -54.0 1.01929216E8 -10096.0 NULL NULL -10096 NULL -9737.0 -10096 +626923679 NULL 821UdmGbkEf4j true 24.0 8050.0 1969-12-31 15:59:50.563 8050 NULL NULL NULL NULL NULL 10.175 -24.0 48.0 48.0 6.48025E7 -8050.0 NULL NULL -8050 NULL -7691.0 -8050 +626923679 NULL 821UdmGbkEf4j true -57.0 10139.0 1969-12-31 15:59:48.636 10139 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 1.02799321E8 -10139.0 NULL NULL -10139 NULL -9780.0 -10139 +626923679 NULL 821UdmGbkEf4j true -59.0 8267.0 1969-12-31 15:59:50.922 8267 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 6.8343289E7 -8267.0 NULL NULL -8267 NULL -7908.0 -8267 +626923679 NULL 821UdmGbkEf4j true 5.0 4154.0 1969-12-31 15:59:47.821 4154 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 1.7255716E7 -4154.0 NULL NULL -4154 NULL -3795.0 -4154 +626923679 NULL 821UdmGbkEf4j true -34.0 9452.0 1969-12-31 15:59:54.095 9452 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 8.9340304E7 -9452.0 NULL NULL -9452 NULL -9093.0 -9452 +626923679 NULL 821UdmGbkEf4j true -56.0 16178.0 1969-12-31 15:59:51.648 16178 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.61727684E8 -16178.0 NULL NULL -16178 NULL -15819.0 -16178 +626923679 NULL 821UdmGbkEf4j true -62.0 5972.0 1969-12-31 15:59:43.789 5972 NULL NULL NULL NULL NULL 10.175 62.0 -124.0 -124.0 3.5664784E7 -5972.0 NULL NULL -5972 NULL -5613.0 -5972 +626923679 NULL 821UdmGbkEf4j true 28.0 8351.0 1969-12-31 15:59:51.546 8351 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 6.9739201E7 -8351.0 NULL NULL -8351 NULL -7992.0 -8351 +626923679 NULL 821UdmGbkEf4j true 36.0 15012.0 1969-12-31 15:59:47.365 15012 NULL NULL NULL NULL NULL 10.175 -36.0 72.0 72.0 2.25360144E8 -15012.0 NULL NULL -15012 NULL -14653.0 -15012 +626923679 NULL 821UdmGbkEf4j true -63.0 5241.0 1969-12-31 15:59:58.621 5241 NULL NULL NULL NULL NULL 10.175 63.0 -126.0 -126.0 2.7468081E7 -5241.0 NULL NULL -5241 NULL -4882.0 -5241 +626923679 NULL 821UdmGbkEf4j true 33.0 8693.0 1969-12-31 15:59:54.51 8693 NULL NULL NULL NULL NULL 10.175 -33.0 66.0 66.0 7.5568249E7 -8693.0 NULL NULL -8693 NULL -8334.0 -8693 +626923679 NULL 821UdmGbkEf4j true 4.0 14548.0 1969-12-31 15:59:46.182 14548 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 2.11644304E8 -14548.0 NULL NULL -14548 NULL -14189.0 -14548 +626923679 NULL 821UdmGbkEf4j true -49.0 5356.0 1969-12-31 15:59:58.396 5356 NULL NULL NULL NULL NULL 10.175 49.0 -98.0 -98.0 2.8686736E7 -5356.0 NULL NULL -5356 NULL -4997.0 -5356 +626923679 NULL 821UdmGbkEf4j true 37.0 2969.0 1969-12-31 15:59:46.668 2969 NULL NULL NULL NULL NULL 10.175 -37.0 74.0 74.0 8814961.0 -2969.0 NULL NULL -2969 NULL -2610.0 -2969 +626923679 NULL 821UdmGbkEf4j true 61.0 2700.0 1969-12-31 15:59:50.175 2700 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 7290000.0 -2700.0 NULL NULL -2700 NULL -2341.0 -2700 +626923679 NULL 821UdmGbkEf4j true -42.0 11565.0 1969-12-31 15:59:55.091 11565 NULL NULL NULL NULL NULL 10.175 42.0 -84.0 -84.0 1.33749225E8 -11565.0 NULL NULL -11565 NULL -11206.0 -11565 +626923679 NULL 821UdmGbkEf4j true 49.0 7423.0 1969-12-31 15:59:50.449 7423 NULL NULL NULL NULL NULL 10.175 -49.0 98.0 98.0 5.5100929E7 -7423.0 NULL NULL -7423 NULL -7064.0 -7423 +626923679 NULL 821UdmGbkEf4j true -46.0 3116.0 1969-12-31 15:59:50.81 3116 NULL NULL NULL NULL NULL 10.175 46.0 -92.0 -92.0 9709456.0 -3116.0 NULL NULL -3116 NULL -2757.0 -3116 +626923679 NULL 821UdmGbkEf4j true 10.0 15038.0 1969-12-31 15:59:58.691 15038 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 2.26141444E8 -15038.0 NULL NULL -15038 NULL -14679.0 -15038 +626923679 NULL 821UdmGbkEf4j true 11.0 11150.0 1969-12-31 15:59:55.809 11150 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 1.243225E8 -11150.0 NULL NULL -11150 NULL -10791.0 -11150 +NULL -893636289 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 L2WL0K8Q3077Q7lHWxq3 true NULL -17.89300003064966 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 893636289 NULL -15601 3569 -15242.0 -15601 +NULL -1792474070 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 e6mKyhM false NULL -34.43400006147772 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 1792474070 NULL -15601 3569 -15242.0 -15601 +NULL -1160428011 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 oEX4B1gHrPoGq false NULL -14.7380000398 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 1160428011 NULL -15601 3569 -15242.0 -15601 +NULL 1987471865 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 TNE8eY3 false NULL 61.53000006816569 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 -1987471865 NULL -15601 3569 -15242.0 -15601 +NULL -1114169807 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 m67dOAXV false NULL -50.51900003821345 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 1114169807 NULL -15601 3569 -15242.0 -15601 +NULL -1676223874 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 6ySy81Xi5 true NULL -0.9100000574906062 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 1676223874 NULL -15601 3569 -15242.0 -15601 +NULL 46706681 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 Xp6aP true NULL 0.9580000016019312 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -46706681 NULL -15601 3569 -15242.0 -15601 +NULL 672512361 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 0to563s4g3qycP5T8 true NULL 17.63300002306562 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 -672512361 NULL -15601 3569 -15242.0 -15601 +NULL -2098300466 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 IAnfq false NULL -37.00400007196686 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 2098300466 NULL -15601 3569 -15242.0 -15601 +NULL 1860728286 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 B3sM2VnR true NULL 3.918000063818681 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -1860728286 NULL -15601 3569 -15242.0 -15601 +NULL 2144274348 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 2On21PaPPbpDap7Q55a5Iw true NULL 1.645000073543656 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -2144274348 NULL -15601 3569 -15242.0 -15601 +NULL 1522352025 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 8DLDCR7L false NULL 41.828000052213156 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -1522352025 NULL -15601 3569 -15242.0 -15601 +NULL 1958873163 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 Qq2Jy5Iy15LsnaWwI false NULL 26.606000067184823 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -1958873163 NULL -15601 3569 -15242.0 -15601 +NULL -1914520574 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 kOmtKm55GCMaOodNR8k true NULL -64.82500006566363 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 1914520574 NULL -15601 3569 -15242.0 -15601 +NULL 1326401578 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 57eimVBuq4i3FdRlJi5iNFh5 true NULL 9.90700004549251 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 -1326401578 NULL -15601 3569 -15242.0 -15601 +NULL 2102392175 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 4M0VqYd8r8D5 false NULL 17.002000072107194 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 -2102392175 NULL -15601 3569 -15242.0 -15601 +NULL -550628565 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 kEdEmqG8m0244ddyfl47d4XF false NULL -9.357000018885287 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 550628565 NULL -15601 3569 -15242.0 -15601 +NULL -1433781206 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 g885ACJCYkvRC3dJ6 true NULL -32.69600004917538 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 1433781206 NULL -15601 3569 -15242.0 -15601 +NULL -865054294 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 ihe1gDEGygF380lr7q4 false NULL -63.39200002966936 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 865054294 NULL -15601 3569 -15242.0 -15601 +NULL -245067785 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 48gL7oUDAKW75kgT true NULL -74.87300000840526 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 245067785 NULL -15601 3569 -15242.0 -15601 +NULL -1651489748 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 Ner2VnJw3kK6StMYD true NULL -16.352000056642282 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 1651489748 NULL -15601 3569 -15242.0 -15601 +NULL 791493164 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 beF0xaC8FJY616Rwkd false NULL 1.4320000271463869 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -791493164 NULL -15601 3569 -15242.0 -15601 +NULL -591161051 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 gGvqMjI false NULL -3.198000020275458 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 591161051 NULL -15601 3569 -15242.0 -15601 +NULL 1054004122 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 jE27TXC7m8Gi1u7BU5sV true NULL 60.760000036149904 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -1054004122 NULL -15601 3569 -15242.0 -15601 +NULL -765146525 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 6ERA57C3XFjRG3oJ0 false NULL -43.18400002624276 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 765146525 NULL -15601 3569 -15242.0 -15601 +NULL -1399138608 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 mpf2ET1sMf4aGnT4imw true NULL -61.39400004798722 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 1399138608 NULL -15601 3569 -15242.0 -15601 +NULL 946654233 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 8W4LA8kaxVohu172E false NULL 24.149000032468052 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 -946654233 NULL -15601 3569 -15242.0 -15601 +NULL 1793484431 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 at8mQq7J5yx false NULL 72.33400006151237 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 -1793484431 NULL -15601 3569 -15242.0 -15601 +NULL 1273900453 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 k4vuu7Rg2lB2x87dhR false NULL 46.36300004369184 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 -1273900453 NULL -15601 3569 -15242.0 -15601 +NULL 364112219 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 xMP4uDMX3RU4I0B false NULL 47.272000012488206 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 -364112219 NULL -15601 3569 -15242.0 -15601 +NULL -671519607 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 5tCt5 true NULL -5.520000023031571 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 671519607 NULL -15601 3569 -15242.0 -15601 +NULL -1228417392 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 C0M1vBmsgknoehCiG7 false NULL -60.712000042131876 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1228417392 NULL -15601 3569 -15242.0 -15601 +NULL 1274836009 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 F68eh false NULL 59.08300004372393 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 -1274836009 NULL -15601 3569 -15242.0 -15601 +NULL -1506320791 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 nid4Y78a31Tj6Aip2l true NULL -10.176000051663323 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 1506320791 NULL -15601 3569 -15242.0 -15601 +NULL 432515401 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 7W2RwS80JX true NULL 59.54000001483428 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 -432515401 NULL -15601 3569 -15242.0 -15601 +NULL -461126191 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 pMU7u8s true NULL -10.855000015815563 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 461126191 NULL -15601 3569 -15242.0 -15601 +NULL 1733197419 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 d0kurqgKX7cyh27S1kKB6 false NULL 73.90000005944466 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 -1733197419 NULL -15601 3569 -15242.0 -15601 +NULL -436916225 NULL NULL -47.0 15601.0 1969-12-31 15:59:58.456 15601 u2uy5DJ1Fpt67Th42X false NULL -11.580000014985217 NULL 10.175 47.0 -94.0 -94.0 2.43391201E8 -15601.0 436916225 NULL -15601 3569 -15242.0 -15601 +NULL -200542601 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 oS56Rg88DHRNu true NULL -68.54900000687815 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 200542601 NULL -15601 3569 -15242.0 -15601 +NULL -1675398355 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 NP22kVaQGeaH604 false NULL -3.3910000574622927 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 1675398355 NULL -15601 3569 -15242.0 -15601 +NULL 1129495890 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 SJf447 false NULL 9.4100000387391 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -1129495890 NULL -15601 3569 -15242.0 -15601 +NULL -1196406048 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 x50e5GXc true NULL -48.38200004103396 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 1196406048 NULL -15601 3569 -15242.0 -15601 +NULL -310826420 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 2R8parX8OGHj3vE6Hk761a6b true NULL -40.96700001066063 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 310826420 NULL -15601 3569 -15242.0 -15601 +NULL -775351902 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 63ml1hL17Hky false NULL -43.13200002659278 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 775351902 NULL -15601 3569 -15242.0 -15601 +NULL -1111841132 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 kUms72e17J5e72 false NULL -50.93500003813358 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 1111841132 NULL -15601 3569 -15242.0 -15601 +NULL -1230441185 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 SpJMvUVUfHrf1A723s10EdC false NULL -25.39200004220129 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 1230441185 NULL -15601 3569 -15242.0 -15601 +NULL 281485844 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 62YSTHdPej50X5u3O1D false NULL 43.32100000965431 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 -281485844 NULL -15601 3569 -15242.0 -15601 +NULL 99984127 NULL NULL 10.175 15601.0 1969-12-31 15:59:58.456 15601 8CiP3 true NULL 7.328000003429224 NULL 10.175 -10.175 20.35 20.35 2.43391201E8 -15601.0 -99984127 NULL -15601 3569 -15242.0 -15601 +NULL -1029272743 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 PFiGGCalsC false NULL -38.847000035301676 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 1029272743 NULL -15601 3569 -15242.0 -15601 +NULL -682718731 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 w68k1XApiUr4Q true NULL -55.94500002341567 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 682718731 NULL -15601 3569 -15242.0 -15601 +NULL 1217409914 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 8V43o1S8d0t6u4i true NULL 13.110000041754347 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -1217409914 NULL -15601 3569 -15242.0 -15601 +NULL -1186641445 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 F0FeMN5eraBSeNo false NULL -19.26100004069906 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 1186641445 NULL -15601 3569 -15242.0 -15601 +NULL -362433250 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 316f2Yg786dK8Bdk true NULL -44.33700001243062 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 362433250 NULL -15601 3569 -15242.0 -15601 +NULL -1875861804 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 0u7Jba8i21vWm true NULL -75.17500006433772 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 1875861804 NULL -15601 3569 -15242.0 -15601 +NULL -1178735095 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 47Sm8wxGLl4syvsh1W8d2eq true NULL -44.16600004042789 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 1178735095 NULL -15601 3569 -15242.0 -15601 +NULL -2142615863 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 3qT4ePv7ISMeETgFD0b0S1Ly true NULL -37.58900007348677 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 2142615863 NULL -15601 3569 -15242.0 -15601 +NULL 824241372 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 g350sS307k4M7WV2W7f35v false NULL 57.87600002826957 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -824241372 NULL -15601 3569 -15242.0 -15601 +NULL 188016060 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 63N5mknei4aeWJ8V0qwVI false NULL 22.482000006448516 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 -188016060 NULL -15601 3569 -15242.0 -15601 +NULL -1086197521 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 EUfLkLQ true NULL -31.273000037254064 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 1086197521 NULL -15601 3569 -15242.0 -15601 +NULL 1241388233 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 gKCLGo3l4W3168iBtLxp3kT true NULL 23.721000042576748 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -1241388233 NULL -15601 3569 -15242.0 -15601 +NULL 1736691817 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 203NY247Byl0uo false NULL 26.822000059564516 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 -1736691817 NULL -15601 3569 -15242.0 -15601 +NULL -1315413812 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 T3KP6V true NULL -24.714000045115654 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 1315413812 NULL -15601 3569 -15242.0 -15601 +NULL 308271363 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 AofL0r45t false NULL 67.221000010573 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -308271363 NULL -15601 3569 -15242.0 -15601 +NULL -691840768 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 cLxM44xUu0Iq false NULL -68.64700002372854 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 691840768 NULL -15601 3569 -15242.0 -15601 +NULL -1378117091 NULL NULL 56.0 15601.0 1969-12-31 15:59:58.456 15601 PS4fs5g7Itj843qvX true NULL -26.87900004726623 NULL 10.175 -56.0 112.0 112.0 2.43391201E8 -15601.0 1378117091 NULL -15601 3569 -15242.0 -15601 +NULL -2103985381 NULL NULL 51.0 15601.0 1969-12-31 15:59:58.456 15601 BRG7Sv5qr1v0twTX22 false NULL -15.071000072161837 NULL 10.175 -51.0 102.0 102.0 2.43391201E8 -15601.0 2103985381 NULL -15601 3569 -15242.0 -15601 +NULL -1416000760 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -0.4080000485655546 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 1416000760 NULL -15601 3569 -15242.0 -15601 +NULL 912955819 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 6ukSO2rt3sY false NULL 22.290000031312275 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 -912955819 NULL -15601 3569 -15242.0 -15601 +NULL -1721221449 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 4EbBPLvTO2Pe6s33iKn8 true NULL -12.520000059033919 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 1721221449 NULL -15601 3569 -15242.0 -15601 +NULL 503569096 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 Lc62N872p2Qx048D8x true NULL 37.954000017271255 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 -503569096 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 578rPxyhOk6IXAKYJn false NULL NULL NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -1046520269 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 MhnIfCXt3OD false NULL -76.68200003589322 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 1046520269 NULL -15601 3569 -15242.0 -15601 +NULL -1000935343 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 xDY63L03K7Af true NULL -53.87100003432977 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 1000935343 NULL -15601 3569 -15242.0 -15601 +NULL -402193022 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 Rkjxcgk8n8m2B3jrKY1PbS3 false NULL -22.46700001379429 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 402193022 NULL -15601 3569 -15242.0 -15601 +NULL 29687887 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 FAYy2rCtAk6p6LyMS7S3M false NULL 59.801000001018224 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -29687887 NULL -15601 3569 -15242.0 -15601 +NULL -2118522134 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 f8rNQqRWwPS3JP70 true NULL -48.38100007266041 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 2118522134 NULL -15601 3569 -15242.0 -15601 +NULL 1358900024 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 g8TU8YythQiV5NnoeU3swK5n true NULL 21.21800004660713 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -1358900024 NULL -15601 3569 -15242.0 -15601 +NULL -1624506701 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 60fy6yAOepPm6l3 true NULL -74.10400005571682 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 1624506701 NULL -15601 3569 -15242.0 -15601 +NULL -1231026402 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 Kp7FRaBtqU8i2U1 true NULL -50.52400004222136 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 1231026402 NULL -15601 3569 -15242.0 -15601 +NULL 943423950 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 K3d77AuD2 false NULL 70.26700003235726 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 -943423950 NULL -15601 3569 -15242.0 -15601 +NULL 2061177369 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 HN57u11H8 false NULL 29.24200007069362 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 -2061177369 NULL -15601 3569 -15242.0 -15601 +NULL -2104361963 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 0KoLN8L6Iih8ej2sW7JF true NULL -72.72200007217475 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 2104361963 NULL -15601 3569 -15242.0 -15601 +NULL -508126361 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 wrDOhn8W3RPeO3 true NULL -29.79600001742756 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 508126361 NULL -15601 3569 -15242.0 -15601 +NULL 1810075387 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 2g0kR10R20S8bO7x233PflX false NULL 11.525000062081403 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -1810075387 NULL -15601 3569 -15242.0 -15601 +NULL 496222742 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 JqulbtcrXcNBymoHD0uDu true NULL 5.739000017019293 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -496222742 NULL -15601 3569 -15242.0 -15601 +NULL 996077543 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 1af7dEq0egH false NULL 78.26300003416316 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -996077543 NULL -15601 3569 -15242.0 -15601 +NULL -831227593 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 G8YI4g61V5l0 false NULL -13.969000028509186 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 831227593 NULL -15601 3569 -15242.0 -15601 +NULL 1023307150 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 5Fy3QhweW false NULL 45.76400003509707 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 -1023307150 NULL -15601 3569 -15242.0 -15601 +NULL -532065045 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 vgyy3nDg1FVHe false NULL -22.8010000182486 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 532065045 NULL -15601 3569 -15242.0 -15601 +NULL -1141582332 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 DUE3Y1g4jLp345K false NULL -43.673000039153635 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 1141582332 NULL -15601 3569 -15242.0 -15601 +NULL -987166521 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 2uXU06tULF7itEhNYy5j7k true NULL -26.45200003385753 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 987166521 NULL -15601 3569 -15242.0 -15601 +NULL 1018195815 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 7jEJE3CR3l027M76o2N81 true NULL 70.56700003492176 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -1018195815 NULL -15601 3569 -15242.0 -15601 +NULL 1781483364 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 HUKr4vWS false NULL 52.70200006110076 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 -1781483364 NULL -15601 3569 -15242.0 -15601 +NULL 897944388 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 23EpSjnhU1fkij33yNA763AK true NULL 3.731000030797418 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 -897944388 NULL -15601 3569 -15242.0 -15601 +NULL -1230115822 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 0IJJNV0BH false NULL -34.16200004219013 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 1230115822 NULL -15601 3569 -15242.0 -15601 +NULL 42147119 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 14MDiWrX false NULL 19.153000001445548 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -42147119 NULL -15601 3569 -15242.0 -15601 +NULL 1927566094 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 r00VVii8T37 true NULL 6.5670000661110635 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -1927566094 NULL -15601 3569 -15242.0 -15601 +NULL -989710558 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 3HY275 false NULL -38.065000033944784 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 989710558 NULL -15601 3569 -15242.0 -15601 +NULL -1838132825 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 O30yrAd1e8dgm5 true NULL -61.06100006304371 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 1838132825 NULL -15601 3569 -15242.0 -15601 +NULL 1647833756 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 6hI8NKEDoQHh false NULL 41.57300005651689 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -1647833756 NULL -15601 3569 -15242.0 -15601 +NULL -1996378319 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 b74m5y50l5e2 false NULL -0.309000068471164 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 1996378319 NULL -15601 3569 -15242.0 -15601 +NULL 728050590 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 m48LN0I7HV4OsK12q5bc false NULL 69.84900002497045 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -728050590 NULL -15601 3569 -15242.0 -15601 +NULL 993796288 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 ya64Ik false NULL 5.5380000340849165 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 -993796288 NULL -15601 3569 -15242.0 -15601 +NULL 710154995 NULL NULL 13.0 15601.0 1969-12-31 15:59:58.456 15601 u4yueq6cflb7Hh false NULL 1.7520000243566756 NULL 10.175 -13.0 26.0 26.0 2.43391201E8 -15601.0 -710154995 NULL -15601 3569 -15242.0 -15601 +NULL 11070716 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 yfpFFQ0 false NULL 40.9670000003797 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -11070716 NULL -15601 3569 -15242.0 -15601 +NULL -337682588 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 4Y8Yutn4b4HF0 true NULL -70.80300001158173 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 337682588 NULL -15601 3569 -15242.0 -15601 +NULL 226841234 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 06Tj8f5xNhpaiE71AWqJ7b5 true NULL 70.80900000778013 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 -226841234 NULL -15601 3569 -15242.0 -15601 +NULL 1762456014 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 2S72XuXwWWB2bpmYpu6Y0q false NULL 30.13600006044817 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -1762456014 NULL -15601 3569 -15242.0 -15601 +NULL 1956045570 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 3th76XH6M3nttE4 false NULL 65.43800006708784 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -1956045570 NULL -15601 3569 -15242.0 -15601 +NULL -413080018 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 oE1QgH7HQ2 true NULL -31.31100001416769 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 413080018 NULL -15601 3569 -15242.0 -15601 +NULL 1759317222 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 gENKm4XGrhXjE8X false NULL 1.751000060340516 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -1759317222 NULL -15601 3569 -15242.0 -15601 +NULL 24464415 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 3t5w8EbK07SIW3PEI4 false NULL 37.78100000083907 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 -24464415 NULL -15601 3569 -15242.0 -15601 +NULL -1045079067 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 eLFsQ364kEkcTM2Jv300h true NULL -56.830000035843796 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 1045079067 NULL -15601 3569 -15242.0 -15601 +NULL -2105144474 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 7C80P162Dh088i1 false NULL -20.86100007220159 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 2105144474 NULL -15601 3569 -15242.0 -15601 +NULL -1559932440 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 YA630l4W6 false NULL -17.393000053502078 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 1559932440 NULL -15601 3569 -15242.0 -15601 +NULL -901264012 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 ICK66G8e8 false NULL -40.14700003091127 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 901264012 NULL -15601 3569 -15242.0 -15601 +NULL 2123136080 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 0nur4r8MV673GcJp3h765I true NULL 79.48700007281866 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 -2123136080 NULL -15601 3569 -15242.0 -15601 +NULL -144116978 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 6KJ1McyXPvnI1aVA2m1 false NULL -36.04800000494288 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 144116978 NULL -15601 3569 -15242.0 -15601 +NULL 1055873342 NULL NULL 50.0 15601.0 1969-12-31 15:59:58.456 15601 k3OJC6gIgoNnv2s128Js false NULL 23.919000036214015 NULL 10.175 -50.0 100.0 100.0 2.43391201E8 -15601.0 -1055873342 NULL -15601 3569 -15242.0 -15601 +NULL -223687300 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 0034fkcXMQI3 false NULL -15.494000007671957 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 223687300 NULL -15601 3569 -15242.0 -15601 +NULL -258993110 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 0p6665Ys81o1ITrC5DSoHV true NULL -44.988000008882864 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 258993110 NULL -15601 3569 -15242.0 -15601 +NULL 846324964 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 TwtBSyUgu7uOpsQ true NULL 55.28800002902699 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -846324964 NULL -15601 3569 -15242.0 -15601 +NULL -1843534244 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 aoUmJWOOkfRmRba4i4N0 true NULL -70.02000006322896 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 1843534244 NULL -15601 3569 -15242.0 -15601 +NULL 873370057 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 A4g0u43t1BLI4h true NULL 71.74900002995457 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 -873370057 NULL -15601 3569 -15242.0 -15601 +NULL 676613895 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 6002q false NULL 37.61200002320629 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -676613895 NULL -15601 3569 -15242.0 -15601 +NULL 1849599424 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 FEfERlrjMF6a37teo6RpLM false NULL 49.747000063436985 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -1849599424 NULL -15601 3569 -15242.0 -15601 +NULL 547762198 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 L1pn2rBecf3v4mOe false NULL 16.500000018786977 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 -547762198 NULL -15601 3569 -15242.0 -15601 +NULL -1559306282 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 b11r7DwVT3 false NULL -21.056000053480602 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 1559306282 NULL -15601 3569 -15242.0 -15601 +NULL -1367836702 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 gM47H3PEBmHiU false NULL -33.41000004691364 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 1367836702 NULL -15601 3569 -15242.0 -15601 +NULL 1096516417 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 sy3fum7CE true NULL 28.09000003760798 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -1096516417 NULL -15601 3569 -15242.0 -15601 +NULL -1465963146 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 3g41G77ehhX5fI7 true NULL -79.39400005027915 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 1465963146 NULL -15601 3569 -15242.0 -15601 +NULL 944581452 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 8r0tSk false NULL 76.11700003239696 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 -944581452 NULL -15601 3569 -15242.0 -15601 +NULL 1825424393 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 QWSToWHfYl4rAJcLMwO true NULL 61.70500006260784 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 -1825424393 NULL -15601 3569 -15242.0 -15601 +NULL 1863251368 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 da07f4FYOd3hfuo4O8A50V true NULL 62.523000063905215 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 -1863251368 NULL -15601 3569 -15242.0 -15601 +NULL -226993201 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 28j21KA5BLfXk8IrHe false NULL -12.026000007785342 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 226993201 NULL -15601 3569 -15242.0 -15601 +NULL 1841882240 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 17r8lCoU7J3mt47of258 false NULL 63.6180000631723 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -1841882240 NULL -15601 3569 -15242.0 -15601 +NULL -584361640 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 ft8b3sx52Pwy73Di66bW6 true NULL -66.66100002004225 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 584361640 NULL -15601 3569 -15242.0 -15601 +NULL 623049731 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 ByMim67Bdl5Kq5NSjW17G3 true NULL 22.254000021369166 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 -623049731 NULL -15601 3569 -15242.0 -15601 +NULL 833507857 NULL NULL -27.0 15601.0 1969-12-31 15:59:58.456 15601 v1425 false NULL 50.33000002858739 NULL 10.175 27.0 -54.0 -54.0 2.43391201E8 -15601.0 -833507857 NULL -15601 3569 -15242.0 -15601 +NULL -6432 NULL NULL -38.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -67.76000000000022 NULL 10.175 38.0 -76.0 -76.0 2.43391201E8 -15601.0 6432 NULL -15601 3569 -15242.0 -15601 +NULL 281019305 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 VTDTuUp true NULL 3.113000009638313 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 -281019305 NULL -15601 3569 -15242.0 -15601 +NULL 1638241933 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 18QAI3 false NULL 3.3360000561879133 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -1638241933 NULL -15601 3569 -15242.0 -15601 +NULL -773540513 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 gK0xU2oAY5 true NULL -75.94200002653065 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 773540513 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 P66k5ETLyP41K5o5gAT true NULL NULL NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -67671601 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 6oAqXj7Kno4oPwyyvkFHx26E false NULL -0.6560000023209795 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 67671601 NULL -15601 3569 -15242.0 -15601 +NULL -1698345590 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 B5E1TD86mgjtAtB4 false NULL -16.43500005824933 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 1698345590 NULL -15601 3569 -15242.0 -15601 +NULL -1488190636 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 0Ef374 false NULL -63.4290000510415 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 1488190636 NULL -15601 3569 -15242.0 -15601 +NULL -1932369186 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 7RTbw57HqNyGPcn false NULL -6.639000066275798 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 1932369186 NULL -15601 3569 -15242.0 -15601 +NULL 2050006061 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 i55St4S1BXI true NULL 30.82000007031047 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 -2050006061 NULL -15601 3569 -15242.0 -15601 +NULL -2021724111 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 AIb8nmLQ0Jg4t3gUu75vJeyH false NULL -47.403000069340465 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 2021724111 NULL -15601 3569 -15242.0 -15601 +NULL 1941610780 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 BLO5XwB7 true NULL 8.182000066592764 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 -1941610780 NULL -15601 3569 -15242.0 -15601 +NULL 1055253200 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 m2pL7R33U true NULL 77.10700003619274 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 -1055253200 NULL -15601 3569 -15242.0 -15601 +NULL -2044770406 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 CJgR7y5fJt25q1 false NULL -76.9620000701309 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 2044770406 NULL -15601 3569 -15242.0 -15601 +NULL 934071980 NULL NULL -27.0 15601.0 1969-12-31 15:59:58.456 15601 WBuN1V4lP1858Dd3 true NULL 32.73500003203651 NULL 10.175 27.0 -54.0 -54.0 2.43391201E8 -15601.0 -934071980 NULL -15601 3569 -15242.0 -15601 +NULL -1028809597 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 Lm4jGS6uC6m0buRvp63 false NULL -50.41300003528579 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 1028809597 NULL -15601 3569 -15242.0 -15601 +NULL 542472416 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 a2y5iM3sPb4giV false NULL 31.68200001860555 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 -542472416 NULL -15601 3569 -15242.0 -15601 +NULL 642606685 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 Ci5SHf false NULL 64.49900002203992 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -642606685 NULL -15601 3569 -15242.0 -15601 +NULL -1740312484 NULL NULL 24.0 15601.0 1969-12-31 15:59:58.456 15601 0e8O8CeLi true NULL -77.6860000596887 NULL 10.175 -24.0 48.0 48.0 2.43391201E8 -15601.0 1740312484 NULL -15601 3569 -15242.0 -15601 +NULL 1511836517 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 3J5RuDO2K true NULL 8.4740000518525 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -1511836517 NULL -15601 3569 -15242.0 -15601 +NULL 1605330367 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 6A657TNuJgSp1Y6chfUOqyo false NULL 70.30700005505912 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -1605330367 NULL -15601 3569 -15242.0 -15601 +NULL -458110015 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 3v66hVGTQa true NULL -7.297000015712115 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 458110015 NULL -15601 3569 -15242.0 -15601 +NULL -777113949 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 68ldxXNy74071w true NULL -70.73500002665321 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 777113949 NULL -15601 3569 -15242.0 -15601 +NULL 1480022657 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 1GMeP false NULL 29.598000050761357 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 -1480022657 NULL -15601 3569 -15242.0 -15601 +NULL -13357585 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 D26B67MOpPcteG70IOsMqH false NULL -79.42900000045813 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 13357585 NULL -15601 3569 -15242.0 -15601 +NULL 1295172704 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 ERwT6401a164 true NULL 63.82200004442143 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 -1295172704 NULL -15601 3569 -15242.0 -15601 +NULL 940280284 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 tyg5iHNF1G434 false NULL 20.61500003224944 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -940280284 NULL -15601 3569 -15242.0 -15601 +NULL 448409948 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 5JN6of4vi false NULL 76.24600001537942 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 -448409948 NULL -15601 3569 -15242.0 -15601 +NULL -1064437283 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 PN71Bl6jM true NULL -4.916000036507739 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 1064437283 NULL -15601 3569 -15242.0 -15601 +NULL -176425309 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 268awl0F5A false NULL -64.02900000605098 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 176425309 NULL -15601 3569 -15242.0 -15601 +NULL 984832395 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 H2W5UNJvOk4884lt0u2K false NULL 65.02500003377747 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 -984832395 NULL -15601 3569 -15242.0 -15601 +NULL -772919195 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 1GsrLIbvD7J7l7eyJ7 false NULL -66.87200002650934 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 772919195 NULL -15601 3569 -15242.0 -15601 +NULL -1474993355 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 Etkti70 true NULL -68.25800005058886 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 1474993355 NULL -15601 3569 -15242.0 -15601 +NULL 1395869576 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 3RUv5ya25aqr5127TxoQT251 true NULL 21.2700000478751 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -1395869576 NULL -15601 3569 -15242.0 -15601 +NULL -85144619 NULL NULL 56.0 15601.0 1969-12-31 15:59:58.456 15601 d6663E0E true NULL -77.28900000292026 NULL 10.175 -56.0 112.0 112.0 2.43391201E8 -15601.0 85144619 NULL -15601 3569 -15242.0 -15601 +NULL 113880409 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 EPi08Ihi40O false NULL 50.84100000390583 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 -113880409 NULL -15601 3569 -15242.0 -15601 +NULL -1828371599 NULL NULL -47.0 15601.0 1969-12-31 15:59:58.456 15601 2N0G8 true NULL -67.71400006270892 NULL 10.175 47.0 -94.0 -94.0 2.43391201E8 -15601.0 1828371599 NULL -15601 3569 -15242.0 -15601 +NULL 68208550 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 EmIssCRj false NULL 46.459000002339394 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -68208550 NULL -15601 3569 -15242.0 -15601 +NULL 1958832178 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 2O55G false NULL 11.401000067183418 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -1958832178 NULL -15601 3569 -15242.0 -15601 +NULL -847064600 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 6Ro6sc8i5gt3Yau7O false NULL -7.4940000290523585 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 847064600 NULL -15601 3569 -15242.0 -15601 +NULL -1207674957 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 1tIN2rwDJ0 true NULL -36.27300004142046 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 1207674957 NULL -15601 3569 -15242.0 -15601 +NULL 286911598 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 LGM2rR true NULL 44.0620000098404 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 -286911598 NULL -15601 3569 -15242.0 -15601 +NULL 391612768 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 ROWD7iWDvXjq3RU60LfIm true NULL 78.80800001343141 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 -391612768 NULL -15601 3569 -15242.0 -15601 +NULL -225001319 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 wLHtAqb0NXKKb1 false NULL -57.59300000771702 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 225001319 NULL -15601 3569 -15242.0 -15601 +NULL -125514283 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 5fecwPu2O6YdwAt false NULL -14.56800000430485 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 125514283 NULL -15601 3569 -15242.0 -15601 +NULL -746546766 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 ik3BB3 false NULL -14.243000025604829 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 746546766 NULL -15601 3569 -15242.0 -15601 +NULL -668597606 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 7XSN7PgyBJ42NuN87t true NULL -65.76300002293135 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 668597606 NULL -15601 3569 -15242.0 -15601 +NULL -232545302 NULL NULL 51.0 15601.0 1969-12-31 15:59:58.456 15601 QLA5Le5ePE53UgM7km6 false NULL -29.603000007975766 NULL 10.175 -51.0 102.0 102.0 2.43391201E8 -15601.0 232545302 NULL -15601 3569 -15242.0 -15601 +NULL 1223102141 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 ttJ61D false NULL 63.854000041949575 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 -1223102141 NULL -15601 3569 -15242.0 -15601 +NULL -357908629 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 b true NULL -0.21200001227543908 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 357908629 NULL -15601 3569 -15242.0 -15601 +NULL 882926601 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 1812MP27X false NULL 72.96500003028234 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -882926601 NULL -15601 3569 -15242.0 -15601 +NULL 649202618 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 0QVeMpE1JOCOS1427vP47tk0 true NULL 19.61000002226615 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 -649202618 NULL -15601 3569 -15242.0 -15601 +NULL 1447975413 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 25EMXg12 false NULL 75.22400004966221 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 -1447975413 NULL -15601 3569 -15242.0 -15601 +NULL -1611690058 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 rGr0f7 true NULL -55.82800005527724 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 1611690058 NULL -15601 3569 -15242.0 -15601 +NULL -335637893 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 gJuMthRVJniFQmAW7UeEMD6 true NULL -47.0090000115116 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 335637893 NULL -15601 3569 -15242.0 -15601 +NULL 661404907 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 yO7xKhbtrsBU147xuT0CF7Q true NULL 71.70500002268466 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 -661404907 NULL -15601 3569 -15242.0 -15601 +NULL -118815110 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 fp3dP50xdAqQ true NULL -79.25100000407508 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 118815110 NULL -15601 3569 -15242.0 -15601 +NULL -505179873 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 RFm8XplgEW3ep0R true NULL -25.8100000173265 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 505179873 NULL -15601 3569 -15242.0 -15601 +NULL 632923730 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 aNNR3y48b3H1e1XGN false NULL 62.00000002170782 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -632923730 NULL -15601 3569 -15242.0 -15601 +NULL 2089310019 NULL NULL 13.0 15601.0 1969-12-31 15:59:58.456 15601 b0qC1eN1o4Nmaa3GH5WpiE false NULL 33.640000071658505 NULL 10.175 -13.0 26.0 26.0 2.43391201E8 -15601.0 -2089310019 NULL -15601 3569 -15242.0 -15601 +NULL 157777107 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 OqeL462twjC0O34y086scWbW true NULL 39.86500000541139 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -157777107 NULL -15601 3569 -15242.0 -15601 +NULL -287502046 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 W2i72S68FOFb0F0nq0s64Y true NULL -49.696000009860654 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 287502046 NULL -15601 3569 -15242.0 -15601 +NULL 344147390 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 e078t7j0TY3K6ObLx77fW13 true NULL 77.81100001180346 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -344147390 NULL -15601 3569 -15242.0 -15601 +NULL 2106881426 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 1a8dVp true NULL 12.659000072261165 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -2106881426 NULL -15601 3569 -15242.0 -15601 +NULL 1164066405 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 3Rql1n377th0WNasiwTIqfAk true NULL 52.28300003992479 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 -1164066405 NULL -15601 3569 -15242.0 -15601 +NULL -655443218 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 Is5DY4nt6n85p8 false NULL -4.972000022480188 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 655443218 NULL -15601 3569 -15242.0 -15601 +NULL 1075572270 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 cE20QJGb6X6p4f true NULL 38.05900003688964 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -1075572270 NULL -15601 3569 -15242.0 -15601 +NULL -1767756774 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 56J7AFRtVC30pT458Lc3461 true NULL -14.640000060629973 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 1767756774 NULL -15601 3569 -15242.0 -15601 +NULL 313560581 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 yTd31x01OaIdi221345ICr true NULL 44.9100000107544 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 -313560581 NULL -15601 3569 -15242.0 -15601 +NULL 1294882412 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 6UFb57s47rh1M046gK2RyP false NULL 60.71900004441147 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -1294882412 NULL -15601 3569 -15242.0 -15601 +NULL 2109726979 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 pKFSm3qD true NULL 34.40200007235876 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -2109726979 NULL -15601 3569 -15242.0 -15601 +NULL 960563498 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 y2fwm6qtkThWx22V false NULL 3.9700000329451086 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 -960563498 NULL -15601 3569 -15242.0 -15601 +NULL -120943153 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 bsud5mR7 true NULL -79.50100000414807 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 120943153 NULL -15601 3569 -15242.0 -15601 +NULL -1057361026 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -66.81900003626504 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 1057361026 NULL -15601 3569 -15242.0 -15601 +NULL 908699526 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 1r31LS0 false NULL 53.44900003116629 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -908699526 NULL -15601 3569 -15242.0 -15601 +NULL 722336779 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 Crds83KvG3egbK true NULL 73.52100002477448 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -722336779 NULL -15601 3569 -15242.0 -15601 +NULL 2088429109 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 1ydwoKOeCAx7c15W08 true NULL 14.009000071628293 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 -2088429109 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 2Y1016lg2I5NaYJ true NULL NULL NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 709756299 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 6ekoSl0HCwx6IuWGt5JC5U0 true NULL 25.388000024343 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 -709756299 NULL -15601 3569 -15242.0 -15601 +NULL 346317340 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 wMoj1J0g0oauw true NULL 60.63000001187788 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -346317340 NULL -15601 3569 -15242.0 -15601 +NULL -1617443296 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 Uw8VcBX726537W7Nc32f5og1 false NULL -20.868000055474567 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 1617443296 NULL -15601 3569 -15242.0 -15601 +NULL -386315686 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 A1qy8CWr78 true NULL -33.313000013249734 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 386315686 NULL -15601 3569 -15242.0 -15601 +NULL 1214460731 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 lu1GiQgG5vAAqILhJM7D883X false NULL 18.926000041653197 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 -1214460731 NULL -15601 3569 -15242.0 -15601 +NULL 999773880 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 iG5mDW8 true NULL 64.67100003428993 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 -999773880 NULL -15601 3569 -15242.0 -15601 +NULL -457778616 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 wJ6tvCKgHi0A0Ssjbt false NULL -26.095000015700748 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 457778616 NULL -15601 3569 -15242.0 -15601 +NULL 1278766496 NULL NULL 50.0 15601.0 1969-12-31 15:59:58.456 15601 6D4DQRSeJLF51 true NULL 71.01200004385873 NULL 10.175 -50.0 100.0 100.0 2.43391201E8 -15601.0 -1278766496 NULL -15601 3569 -15242.0 -15601 +NULL -671949185 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 xm384w822LsLRWoMpf3G false NULL -76.8730000230463 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 671949185 NULL -15601 3569 -15242.0 -15601 +NULL -208178544 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 Kt5AoC5 true NULL -37.29100000714004 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 208178544 NULL -15601 3569 -15242.0 -15601 +NULL 1366904455 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 tUdb3621AQpyuulCmrx1 false NULL 68.01700004688166 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -1366904455 NULL -15601 3569 -15242.0 -15601 +NULL 665140863 NULL NULL -36.0 15601.0 1969-12-31 15:59:58.456 15601 fJrwswe true NULL 59.71900002281279 NULL 10.175 36.0 -72.0 -72.0 2.43391201E8 -15601.0 -665140863 NULL -15601 3569 -15242.0 -15601 +NULL -1225938733 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 Wn8om1ooSVQSHxcg5F true NULL -34.533000042046865 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 1225938733 NULL -15601 3569 -15242.0 -15601 +NULL -1046301933 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 Q08uv20m true NULL -34.11400003588574 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 1046301933 NULL -15601 3569 -15242.0 -15601 +NULL 1990837220 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 2fqi280kgLqm40T8Pg2e47 false NULL 6.418000068281117 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 -1990837220 NULL -15601 3569 -15242.0 -15601 +NULL -870417768 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 u070j74P3 true NULL -74.13200002985332 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 870417768 NULL -15601 3569 -15242.0 -15601 +NULL 1449097159 NULL NULL -36.0 15601.0 1969-12-31 15:59:58.456 15601 3AXY47D false NULL 44.37100004970068 NULL 10.175 36.0 -72.0 -72.0 2.43391201E8 -15601.0 -1449097159 NULL -15601 3569 -15242.0 -15601 +NULL 1660201497 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 16NIx33qB1Thp5q true NULL 75.42800005694107 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 -1660201497 NULL -15601 3569 -15242.0 -15601 +NULL 1057122452 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 X03I20xG6O6Agj1sSW0Si3F false NULL 72.26600003625686 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 -1057122452 NULL -15601 3569 -15242.0 -15601 +NULL 348712969 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 x80X7VcJ2l3u true NULL 30.588000011960048 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -348712969 NULL -15601 3569 -15242.0 -15601 +NULL 183549371 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 ISSP0gjn3qxAC7gH3l11N6 false NULL 75.32600000629532 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 -183549371 NULL -15601 3569 -15242.0 -15601 +NULL 1210224988 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 DpXKnXx54Ped8cJeCJL false NULL 75.41100004150792 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -1210224988 NULL -15601 3569 -15242.0 -15601 +NULL 445347927 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 YfGW4JvD false NULL 50.2160000152744 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 -445347927 NULL -15601 3569 -15242.0 -15601 +NULL -640286718 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 1mwmV true NULL -22.085000021960354 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 640286718 NULL -15601 3569 -15242.0 -15601 +NULL -47379735 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 563BdSoLJFx false NULL -36.578000001625014 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 47379735 NULL -15601 3569 -15242.0 -15601 +NULL 1897963814 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 qc47VGJ1Crvp true NULL 34.29100006509577 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 -1897963814 NULL -15601 3569 -15242.0 -15601 +NULL 2125913889 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 7E0b24sDWE4IdwLO true NULL 56.83300007291393 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -2125913889 NULL -15601 3569 -15242.0 -15601 +NULL 2006398616 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 VXtbOP4eT6x2R05 false NULL 40.088000068814836 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -2006398616 NULL -15601 3569 -15242.0 -15601 +NULL 380840615 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 8U6rv3y3cwrlg6L true NULL 38.43200001306195 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 -380840615 NULL -15601 3569 -15242.0 -15601 +NULL -1749442997 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 545WCULCG83sT3fR1RD38e true NULL -54.21700006000185 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 1749442997 NULL -15601 3569 -15242.0 -15601 +NULL -641670659 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 67p706r1Gv1cjIO true NULL -59.09700002200782 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 641670659 NULL -15601 3569 -15242.0 -15601 +NULL -1332540455 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 lyN0VKr0Rg5IQTcVaa6r8E true NULL -20.55600004570306 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 1332540455 NULL -15601 3569 -15242.0 -15601 +NULL 1089687789 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 DJq0Lol1I true NULL 70.50400003737377 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 -1089687789 NULL -15601 3569 -15242.0 -15601 +NULL 823972698 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 U2MJbm false NULL 34.35700002826036 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 -823972698 NULL -15601 3569 -15242.0 -15601 +NULL -1644694994 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 RV01bFdAim2mhn0is3SuP false NULL -43.18800005640924 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 1644694994 NULL -15601 3569 -15242.0 -15601 +NULL -537124320 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 yeqcahUIvo4AA65P5dEf06 true NULL -45.21300001842212 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 537124320 NULL -15601 3569 -15242.0 -15601 +NULL 1365515285 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 LW12Cn18Fa3jK0 false NULL 52.50300004683402 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 -1365515285 NULL -15601 3569 -15242.0 -15601 +NULL 951445775 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 AoaeP78qMN6Owq7 true NULL 9.406000032632392 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -951445775 NULL -15601 3569 -15242.0 -15601 +NULL -1358164329 NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 H6EQ3Y5tY82S5U1 false NULL -32.3620000465819 NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 1358164329 NULL -15601 3569 -15242.0 -15601 +NULL 1445828009 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 F06d7U0vinY false NULL 45.35300004958856 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 -1445828009 NULL -15601 3569 -15242.0 -15601 +NULL -832606494 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 16jmamsEtKc51n true NULL -22.82000002855648 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 832606494 NULL -15601 3569 -15242.0 -15601 +NULL -507162101 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 PQyN2mruXRR47dPEkesk false NULL -31.709000017394487 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 507162101 NULL -15601 3569 -15242.0 -15601 +NULL 1386764124 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 Ljca2gTfVlP3iiRV4Ue false NULL 46.544000047562804 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 -1386764124 NULL -15601 3569 -15242.0 -15601 +NULL 400830823 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 6rMa1i false NULL 9.48600001374757 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -400830823 NULL -15601 3569 -15242.0 -15601 +NULL 1264871108 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 dmT56yq1egdC6Q6 true NULL 46.416000043382155 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -1264871108 NULL -15601 3569 -15242.0 -15601 +NULL 560414150 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 7Ur2a5SGe4m64pM2BC false NULL 18.48600001922091 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 -560414150 NULL -15601 3569 -15242.0 -15601 +NULL -996165688 NULL NULL 23.0 15601.0 1969-12-31 15:59:58.456 15601 XfVO17QmuH0yT1uQKCKvFtU true NULL -78.53900003416618 NULL 10.175 -23.0 46.0 46.0 2.43391201E8 -15601.0 996165688 NULL -15601 3569 -15242.0 -15601 +NULL 1813355796 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 g7kxp5q false NULL 52.57000006219391 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -1813355796 NULL -15601 3569 -15242.0 -15601 +NULL -208932264 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 0bsH6qR false NULL -72.16900000716589 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 208932264 NULL -15601 3569 -15242.0 -15601 +NULL -1692252476 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 w30Y47Ow40Oyys7u03Pu3 false NULL -25.81100005804035 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 1692252476 NULL -15601 3569 -15242.0 -15601 +NULL -803222928 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 B4bPyjY false NULL -73.34700002754869 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 803222928 NULL -15601 3569 -15242.0 -15601 +NULL 1489229962 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 85nENa25nmPijGxYvb5F7 true NULL 29.484000051077146 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 -1489229962 NULL -15601 3569 -15242.0 -15601 +NULL 970050613 NULL NULL 24.0 15601.0 1969-12-31 15:59:58.456 15601 p321oSUY1unfds5DQE74S false NULL 25.955000033270494 NULL 10.175 -24.0 48.0 48.0 2.43391201E8 -15601.0 -970050613 NULL -15601 3569 -15242.0 -15601 +NULL 1710641158 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 Q4yNJBnb true NULL 31.86100005867104 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 -1710641158 NULL -15601 3569 -15242.0 -15601 +NULL -789881959 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 O2387e47vBg false NULL -62.894000027091124 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 789881959 NULL -15601 3569 -15242.0 -15601 +NULL -1505978287 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 PyGaf true NULL -61.394000051651574 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 1505978287 NULL -15601 3569 -15242.0 -15601 +NULL -659825179 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 8bcU4P2 false NULL -27.62600002263048 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 659825179 NULL -15601 3569 -15242.0 -15601 +NULL -1569241661 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 Hs4v5FHpNs4 true NULL -25.886000053821363 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 1569241661 NULL -15601 3569 -15242.0 -15601 +NULL 1674587606 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 2FlOO88n5i2I false NULL 58.567000057434484 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -1674587606 NULL -15601 3569 -15242.0 -15601 +NULL 1327060856 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 3aDifhjuk6b4nntFIF true NULL 32.19600004551512 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 -1327060856 NULL -15601 3569 -15242.0 -15601 +NULL -645509327 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 mRqxYkN3756QLXuPfp4B true NULL -56.18800002213948 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 645509327 NULL -15601 3569 -15242.0 -15601 +NULL 721859927 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 hj4mH3t false NULL 62.203000024758126 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -721859927 NULL -15601 3569 -15242.0 -15601 +NULL -626924299 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 xe4Vqy7BQowm8 false NULL -40.942000021502054 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 626924299 NULL -15601 3569 -15242.0 -15601 +NULL -1823591768 NULL NULL 79.553 15601.0 1969-12-31 15:59:58.456 15601 DANHO0P7GlF6WFPQkFF8 false NULL -19.613000062544984 NULL 10.175 -79.553 159.106 159.106 2.43391201E8 -15601.0 1823591768 NULL -15601 3569 -15242.0 -15601 +NULL 1499121057 NULL NULL 23.0 15601.0 1969-12-31 15:59:58.456 15601 J4Fr2Ysig4v1h1y4Yg0QF8w8 true NULL 61.33500005141639 NULL 10.175 -23.0 46.0 46.0 2.43391201E8 -15601.0 -1499121057 NULL -15601 3569 -15242.0 -15601 +NULL 821719163 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 8T0iicu1hkiuJIF6nIYW0G5 true NULL 76.74100002818307 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -821719163 NULL -15601 3569 -15242.0 -15601 +NULL 1748908827 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 Y7y6VtlL3yi6mWjRecJ60 false NULL 3.059000059983532 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -1748908827 NULL -15601 3569 -15242.0 -15601 +NULL -1293754251 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 IvE07gK77 false NULL -40.81200004437278 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 1293754251 NULL -15601 3569 -15242.0 -15601 +NULL -33712062 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -46.296000001156244 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 33712062 NULL -15601 3569 -15242.0 -15601 +NULL 1001238455 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 iG1F11qUU5q5riJ5 false NULL 68.94100003434016 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 -1001238455 NULL -15601 3569 -15242.0 -15601 +NULL 2059199534 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 28412JHar2yEWJ4rsg false NULL 40.928000070625785 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 -2059199534 NULL -15601 3569 -15242.0 -15601 +NULL -1294837001 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 lu5du5q41SxW1 false NULL -74.48200004440992 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1294837001 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 SJ8F14f7LlNlWpBJ false NULL NULL NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 1747188649 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 Wkr033CN8bH7LI false NULL 79.13100005992453 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 -1747188649 NULL -15601 3569 -15242.0 -15601 +NULL 1281189908 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 sNcTl4Y5SipY7 true NULL 59.97300004394185 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -1281189908 NULL -15601 3569 -15242.0 -15601 +NULL 254788466 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 4U34tbdGyu6f52ry false NULL 15.697000008738655 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 -254788466 NULL -15601 3569 -15242.0 -15601 +NULL 1631784601 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 85F0x1b1jAwFtt0 true NULL 67.89900005596644 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -1631784601 NULL -15601 3569 -15242.0 -15601 +NULL 2094164536 NULL NULL 33.0 15601.0 1969-12-31 15:59:58.456 15601 UU01Fkn1Fp2d true NULL 67.474000071825 NULL 10.175 -33.0 66.0 66.0 2.43391201E8 -15601.0 -2094164536 NULL -15601 3569 -15242.0 -15601 +NULL 1787283476 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 8qRIl5Mu125F3y0RDS2tJ false NULL 35.02500006129969 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -1787283476 NULL -15601 3569 -15242.0 -15601 +NULL 159274870 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 8gqle254GhDd1pCxr2k45 true NULL 58.53400000546276 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -159274870 NULL -15601 3569 -15242.0 -15601 +NULL 252879408 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 8C2si8HMM25gTx false NULL 70.59100000867318 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -252879408 NULL -15601 3569 -15242.0 -15601 +NULL -971846497 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 TTC6F8qbjDrUwqlWQ674T true NULL -0.9800000333320895 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 971846497 NULL -15601 3569 -15242.0 -15601 +NULL 1267863526 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 35MAHX70Py67 false NULL 78.32100004348479 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 -1267863526 NULL -15601 3569 -15242.0 -15601 +NULL -30310351 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 a6W8Uy8i87 true NULL -21.576000001039574 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 30310351 NULL -15601 3569 -15242.0 -15601 +NULL 1892527183 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 TGfOwisk27yqU43c4NdpO true NULL 55.31100006490931 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 -1892527183 NULL -15601 3569 -15242.0 -15601 +NULL -892983643 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 lC1yi7 false NULL -24.705000030627275 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 892983643 NULL -15601 3569 -15242.0 -15601 +NULL 1425488085 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 l0LkTlJ1 false NULL 73.28700004889095 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 -1425488085 NULL -15601 3569 -15242.0 -15601 +NULL 28509031 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 rR33Ko8U4GJXbdb52a6Axg false NULL 20.155000000977793 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 -28509031 NULL -15601 3569 -15242.0 -15601 +NULL -1310922279 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 W6d48516 false NULL -54.094000044961604 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 1310922279 NULL -15601 3569 -15242.0 -15601 +NULL -2141336536 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 WLct4cIh2E3 false NULL -2.382000073442896 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 2141336536 NULL -15601 3569 -15242.0 -15601 +NULL -982179838 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 m66GtfujU0fOu false NULL -43.7040000336865 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 982179838 NULL -15601 3569 -15242.0 -15601 +NULL 987132753 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 ytBjVwe7b true NULL 68.47700003385637 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 -987132753 NULL -15601 3569 -15242.0 -15601 +NULL -1355363882 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 FH3xC0m38Hp false NULL -10.06800004648585 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 1355363882 NULL -15601 3569 -15242.0 -15601 +NULL -1954258334 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 sE2L40Cr0 true NULL -67.13600006702654 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 1954258334 NULL -15601 3569 -15242.0 -15601 +NULL 919939154 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 djH1qdcKcQ58DEql85us true NULL 35.844000031551786 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 -919939154 NULL -15601 3569 -15242.0 -15601 +NULL 1270307708 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 Q76PX622TlrNxcGCf5p507o8 false NULL 73.94900004356862 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 -1270307708 NULL -15601 3569 -15242.0 -15601 +NULL 1417503370 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 MD1CaRLo1Q1yu8633IB false NULL 13.34400004861709 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -1417503370 NULL -15601 3569 -15242.0 -15601 +NULL 377434477 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 7hs2n1g25 false NULL 41.68000001294513 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 -377434477 NULL -15601 3569 -15242.0 -15601 +NULL -230127703 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 CQCJ6h0swWhp4 false NULL -46.27300000789285 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 230127703 NULL -15601 3569 -15242.0 -15601 +NULL 1850922992 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 l5x5rlx8kVbbJo654C0 false NULL 14.933000063482382 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -1850922992 NULL -15601 3569 -15242.0 -15601 +NULL 1415455683 NULL NULL -53.0 15601.0 1969-12-31 15:59:58.456 15601 6G507mfwId541DtIuy false NULL 20.56400004854686 NULL 10.175 53.0 -106.0 -106.0 2.43391201E8 -15601.0 -1415455683 NULL -15601 3569 -15242.0 -15601 +NULL -1986754040 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 020gtq4CLjybO3F40kpyXi true NULL -43.24900006814107 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 1986754040 NULL -15601 3569 -15242.0 -15601 +NULL 1008710487 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 xq041c6705rqnGTm true NULL 5.863000034596439 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 -1008710487 NULL -15601 3569 -15242.0 -15601 +NULL 268499605 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 UHSnND7vTVfm80W3E3AX5aR true NULL 36.041000009208915 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 -268499605 NULL -15601 3569 -15242.0 -15601 +NULL -1668687246 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 OX3YD1C1JMmS52Y false NULL -65.02400005723212 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 1668687246 NULL -15601 3569 -15242.0 -15601 +NULL 1665942427 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 y17AjWLrJ45lXLyhT false NULL 63.183000057137974 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 -1665942427 NULL -15601 3569 -15242.0 -15601 +NULL -64512046 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 doj2Q3 true NULL -52.15700000221261 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 64512046 NULL -15601 3569 -15242.0 -15601 +NULL 441754322 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 JO2608Lv74HyA false NULL 13.332000015151152 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 -441754322 NULL -15601 3569 -15242.0 -15601 +NULL 2079381885 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 5rg4D5D3KoH7Em1 true NULL 34.48700007131799 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -2079381885 NULL -15601 3569 -15242.0 -15601 +NULL 137074296 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 8wAyA76 false NULL 22.03200000470133 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 -137074296 NULL -15601 3569 -15242.0 -15601 +NULL 628017061 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 x0Brw7 true NULL 62.93400002153953 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -628017061 NULL -15601 3569 -15242.0 -15601 +NULL 657369975 NULL NULL 43.0 15601.0 1969-12-31 15:59:58.456 15601 kEwglXSSP8B35 true NULL 67.86500002254627 NULL 10.175 -43.0 86.0 86.0 2.43391201E8 -15601.0 -657369975 NULL -15601 3569 -15242.0 -15601 +NULL 274226131 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 Vc0uIW6g2n7P8f75JDUG6yN false NULL 18.889000009405322 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -274226131 NULL -15601 3569 -15242.0 -15601 +NULL 1675482723 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 2V48sMwTCo8fdDnY78qDXns true NULL 45.211000057465185 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 -1675482723 NULL -15601 3569 -15242.0 -15601 +NULL 1440689576 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 kWRV7gp4 false NULL 20.176000049412323 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 -1440689576 NULL -15601 3569 -15242.0 -15601 +NULL -214199588 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 kPd7a1 false NULL -32.93300000734655 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 214199588 NULL -15601 3569 -15242.0 -15601 +NULL 605778880 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 78Qfd68RemAlT6Kn8j true NULL 48.001000020776814 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 -605778880 NULL -15601 3569 -15242.0 -15601 +NULL 617599316 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 d2OqdsnW4dLrI5C8dX2m5V84 false NULL 21.94300002118223 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -617599316 NULL -15601 3569 -15242.0 -15601 +NULL 590990961 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 tIoowu false NULL 77.06500002026962 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 -590990961 NULL -15601 3569 -15242.0 -15601 +NULL 1004601674 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 bp162YrYD14I3X6 false NULL 25.760000034455516 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 -1004601674 NULL -15601 3569 -15242.0 -15601 +NULL -1355080830 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 h464Q true NULL -7.6420000464761415 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 1355080830 NULL -15601 3569 -15242.0 -15601 +NULL -1084500358 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 k315d4o8kNtFUqAXtAT2Yuh true NULL -51.975000037195855 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 1084500358 NULL -15601 3569 -15242.0 -15601 +NULL -221039350 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 0q1A0HR4Q8Cd6r false NULL -66.65200000758114 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 221039350 NULL -15601 3569 -15242.0 -15601 +NULL 907202969 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 LxdPDb true NULL 47.485000031114964 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -907202969 NULL -15601 3569 -15242.0 -15601 +NULL 84294427 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 a7038S0o714p6v3e0j true NULL 68.2000000028911 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -84294427 NULL -15601 3569 -15242.0 -15601 +NULL 184592771 NULL NULL 24.0 15601.0 1969-12-31 15:59:58.456 15601 F1p7M8ag2lHT1No88g564W0 false NULL 58.178000006331104 NULL 10.175 -24.0 48.0 48.0 2.43391201E8 -15601.0 -184592771 NULL -15601 3569 -15242.0 -15601 +NULL -2093472028 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 T5W42P5q3uxBgYya8Et085C true NULL -68.33900007180125 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 2093472028 NULL -15601 3569 -15242.0 -15601 +NULL 954040345 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 mvnU4NajvXq2eALbla855jLY true NULL 37.86400003272138 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -954040345 NULL -15601 3569 -15242.0 -15601 +NULL -1025788056 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 Tcvj5uSM1NCQUr true NULL -11.90600003518216 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 1025788056 NULL -15601 3569 -15242.0 -15601 +NULL -2097289702 NULL NULL -52.0 15601.0 1969-12-31 15:59:58.456 15601 uiyxp4VoL false NULL -73.42200007193219 NULL 10.175 52.0 -104.0 -104.0 2.43391201E8 -15601.0 2097289702 NULL -15601 3569 -15242.0 -15601 +NULL 635214602 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 cjNq1lNy1sMIiL4qe5 true NULL 46.25900002178639 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 -635214602 NULL -15601 3569 -15242.0 -15601 +NULL 2062427061 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 W58KCRgshk2VVbX true NULL 23.165000070736482 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -2062427061 NULL -15601 3569 -15242.0 -15601 +NULL -1844060558 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 32u2yKHQehN false NULL -61.372000063247015 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 1844060558 NULL -15601 3569 -15242.0 -15601 +NULL 273979313 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 w06h5W423BwPh2W false NULL 53.848000009396856 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -273979313 NULL -15601 3569 -15242.0 -15601 +NULL 711356569 NULL NULL -27.0 15601.0 1969-12-31 15:59:58.456 15601 H660yyHFbeUy864u1nS1 false NULL 7.240000024397887 NULL 10.175 27.0 -54.0 -54.0 2.43391201E8 -15601.0 -711356569 NULL -15601 3569 -15242.0 -15601 +NULL -1405201067 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 G70732cedJMM0TMdTnO2 false NULL -24.92300004819515 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 1405201067 NULL -15601 3569 -15242.0 -15601 +NULL 273663235 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 B561GDW true NULL 39.917000009386015 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 -273663235 NULL -15601 3569 -15242.0 -15601 +NULL -573372032 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 J73U1aQTRUd false NULL -69.18700001966533 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 573372032 NULL -15601 3569 -15242.0 -15601 +NULL 4757615 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 67jdQgbohcurvMDHh5W true NULL 27.388000000163174 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 -4757615 NULL -15601 3569 -15242.0 -15601 +NULL 915188100 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 c1nG1 true NULL 46.110000031388836 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 -915188100 NULL -15601 3569 -15242.0 -15601 +NULL -617977476 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 lSs0sO false NULL -66.5340000211952 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 617977476 NULL -15601 3569 -15242.0 -15601 +NULL 1807684300 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 49.04600006199939 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 -1807684300 NULL -15601 3569 -15242.0 -15601 +NULL -579164639 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 fIB2O false NULL -24.492000019864008 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 579164639 NULL -15601 3569 -15242.0 -15601 +NULL 1588633683 NULL NULL -51.0 15601.0 1969-12-31 15:59:58.456 15601 d86U1lX5qf6tgG true NULL 49.50000005448646 NULL 10.175 51.0 -102.0 -102.0 2.43391201E8 -15601.0 -1588633683 NULL -15601 3569 -15242.0 -15601 +NULL 146845669 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 MKVQYGxtltIv4QN true NULL 59.148000005036465 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 -146845669 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 iHC3j false NULL NULL NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -937270420 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 Dncfdm0107vK5Bmwppr1H true NULL -44.37000003214621 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 937270420 NULL -15601 3569 -15242.0 -15601 +NULL 1164180530 NULL NULL -53.0 15601.0 1969-12-31 15:59:58.456 15601 FbU0U126PPV4V80C true NULL 18.728000039928702 NULL 10.175 53.0 -106.0 -106.0 2.43391201E8 -15601.0 -1164180530 NULL -15601 3569 -15242.0 -15601 +NULL -664588420 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 IDPh0xt5aj4nhjfgvB6O6X3 false NULL -32.751000022793846 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 664588420 NULL -15601 3569 -15242.0 -15601 +NULL -782857402 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 QFHk87n5xsCYI226 false NULL -35.7940000268502 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 782857402 NULL -15601 3569 -15242.0 -15601 +NULL 519083144 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 qg54YQM true NULL 57.65900001780335 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 -519083144 NULL -15601 3569 -15242.0 -15601 +NULL 147916674 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 53XJFq221K true NULL 42.1090000050732 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -147916674 NULL -15601 3569 -15242.0 -15601 +NULL 2080590537 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 SwEtmG886dSmCVYqhnvUm true NULL 37.75800007135945 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 -2080590537 NULL -15601 3569 -15242.0 -15601 +NULL -88020940 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 aN81vd750N2U1yT25YY7aL false NULL -0.46800000301891487 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 88020940 NULL -15601 3569 -15242.0 -15601 +NULL 1786184100 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 w6YWmSE false NULL 1.9320000612619879 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -1786184100 NULL -15601 3569 -15242.0 -15601 +NULL -6432 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 5MO0A16x7Ec5nM23WnBU true NULL -67.76000000000022 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 6432 NULL -15601 3569 -15242.0 -15601 +NULL 879759030 NULL NULL -53.0 15601.0 1969-12-31 15:59:58.456 15601 HCr4b46Dx6aSa0Q7CRp3 true NULL 63.7660000301737 NULL 10.175 53.0 -106.0 -106.0 2.43391201E8 -15601.0 -879759030 NULL -15601 3569 -15242.0 -15601 +NULL -1479988050 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 SD7DWsK false NULL -28.15300005076017 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 1479988050 NULL -15601 3569 -15242.0 -15601 +NULL -721244708 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 tdq5eCyVhN true NULL -26.552000024737026 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 721244708 NULL -15601 3569 -15242.0 -15601 +NULL 270259380 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 obwNUO6 false NULL 19.12800000926927 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 -270259380 NULL -15601 3569 -15242.0 -15601 +NULL 1351119189 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 oN08d77RYhug false NULL 26.489000046340266 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 -1351119189 NULL -15601 3569 -15242.0 -15601 +NULL -1901567703 NULL NULL -17.0 15601.0 1969-12-31 15:59:58.456 15601 XO40KP8emk1B6Cf4O64 false NULL -13.285000065219378 NULL 10.175 17.0 -34.0 -34.0 2.43391201E8 -15601.0 1901567703 NULL -15601 3569 -15242.0 -15601 +NULL -928466576 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 2M5wNS40c8E03s6aUlur true NULL -12.668000031844258 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 928466576 NULL -15601 3569 -15242.0 -15601 +NULL -1535090489 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 pG5Htuu0BnglS2j7w true NULL -2.150000052650057 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 1535090489 NULL -15601 3569 -15242.0 -15601 +NULL -1300587151 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 7o8D0lTRw30h false NULL -54.08900004460713 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 1300587151 NULL -15601 3569 -15242.0 -15601 +NULL -1495050520 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 l4Bsp true NULL -12.686000051276778 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 1495050520 NULL -15601 3569 -15242.0 -15601 +NULL -303944829 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 juiE0qx6nvgWJk false NULL -23.126000010424605 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 303944829 NULL -15601 3569 -15242.0 -15601 +NULL 761255971 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 7JQfxa2Or8T4qp true NULL 28.64900002610932 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -761255971 NULL -15601 3569 -15242.0 -15601 +NULL -854893578 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 h7rnBHvFw7leTMV1x true NULL -15.658000029320874 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 854893578 NULL -15601 3569 -15242.0 -15601 +NULL 160587665 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 5Pn1BhiCeCd true NULL 69.92800000550778 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 -160587665 NULL -15601 3569 -15242.0 -15601 +NULL -1384901601 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 PK01P7dDg2f8IAPjo662y072 true NULL -18.380000047498925 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 1384901601 NULL -15601 3569 -15242.0 -15601 +NULL -1096047343 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 N6s6Ya7n38uF3 true NULL -78.13100003759189 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 1096047343 NULL -15601 3569 -15242.0 -15601 +NULL -1902104689 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 5FApe58n1bNcyN52tE true NULL -16.535000065237796 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 1902104689 NULL -15601 3569 -15242.0 -15601 +NULL -860591619 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 53J14DdxOk0BwV5x3TunGjou false NULL -73.0330000295163 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 860591619 NULL -15601 3569 -15242.0 -15601 +NULL -1440134532 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 tJJoWfsEN true NULL -17.457000049393287 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 1440134532 NULL -15601 3569 -15242.0 -15601 +NULL -1912094416 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 RrQO5beX488KbcA6g4Jnu5 false NULL -34.66600006558042 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 1912094416 NULL -15601 3569 -15242.0 -15601 +NULL -1185085807 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 Q1T7u0syw2NPveOu false NULL -40.176000040645704 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 1185085807 NULL -15601 3569 -15242.0 -15601 +NULL -338257841 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 rtbj2fm0U1XeR06B5xLu488V false NULL -76.06000001160146 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 338257841 NULL -15601 3569 -15242.0 -15601 +NULL 326323074 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 53X1h8m4Q5y8SGKk0EL74v false NULL 9.226000011192127 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -326323074 NULL -15601 3569 -15242.0 -15601 +NULL 1122241452 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 5lXRdTnA22VoT16Npr true NULL 9.480000038490289 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 -1122241452 NULL -15601 3569 -15242.0 -15601 +NULL 1364240151 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 2YAbAlSe6FR66WFo false NULL 73.54000004679028 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -1364240151 NULL -15601 3569 -15242.0 -15601 +NULL 56009543 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 Gv7dDwR true NULL 14.691000001920997 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 -56009543 NULL -15601 3569 -15242.0 -15601 +NULL 1868299403 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 i4xc1Gh68105elv2 false NULL 61.90800006407835 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -1868299403 NULL -15601 3569 -15242.0 -15601 +NULL -1407693136 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 gQ7g8F7M1dhGxS false NULL -16.64500004828062 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 1407693136 NULL -15601 3569 -15242.0 -15601 +NULL -1145489043 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 XKSgnqfq2Nn18h7GB6 true NULL -65.94900003928763 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 1145489043 NULL -15601 3569 -15242.0 -15601 +NULL -2129158440 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 fAn001Bl7Fy78pJpXvY8 false NULL -38.728000073025214 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 2129158440 NULL -15601 3569 -15242.0 -15601 +NULL 1351243372 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 0E6V6dPe00Ort5Ia6Ha8 false NULL 27.256000046344525 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 -1351243372 NULL -15601 3569 -15242.0 -15601 +NULL -1858689000 NULL NULL -38.0 15601.0 1969-12-31 15:59:58.456 15601 eWGOSRouQsWe7ns false NULL -59.07300006374874 NULL 10.175 38.0 -76.0 -76.0 2.43391201E8 -15601.0 1858689000 NULL -15601 3569 -15242.0 -15601 +NULL -2028170063 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 DWHPiSxW7ON5vyCNmn true NULL -58.472000069561545 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 2028170063 NULL -15601 3569 -15242.0 -15601 +NULL -1964641289 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 7MH3oxJA2Tk false NULL -3.235000067382657 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 1964641289 NULL -15601 3569 -15242.0 -15601 +NULL 1756904629 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 s8028N5Vfu1ewl3i false NULL 12.58200006025777 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 -1756904629 NULL -15601 3569 -15242.0 -15601 +NULL -657503893 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 Y71O40OUSsvw true NULL -18.613000022550864 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 657503893 NULL -15601 3569 -15242.0 -15601 +NULL 562442679 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 3l33jTxWC false NULL 25.539000019290484 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 -562442679 NULL -15601 3569 -15242.0 -15601 +NULL -515857483 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 cD40qCxO1RYcNJl5SpL6 true NULL -32.15000001769272 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 515857483 NULL -15601 3569 -15242.0 -15601 +NULL 421004600 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 xKXtAm45C false NULL 20.769000014439484 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -421004600 NULL -15601 3569 -15242.0 -15601 +NULL -1592016120 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 8NB5Hm30xPsXKoQUCdxi true NULL -52.04600005460247 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 1592016120 NULL -15601 3569 -15242.0 -15601 +NULL -1426659283 NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 JN1cd false NULL -12.468000048931117 NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 1426659283 NULL -15601 3569 -15242.0 -15601 +NULL 1913333647 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 mlKm4cK3F true NULL 68.58500006562292 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 -1913333647 NULL -15601 3569 -15242.0 -15601 +NULL 1561097160 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 4lAdgqS7J8PYkK false NULL 1.9200000535420259 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -1561097160 NULL -15601 3569 -15242.0 -15601 +NULL -1925755234 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 Wqx20H0G3di6k6KN54T true NULL -11.506000066048955 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 1925755234 NULL -15601 3569 -15242.0 -15601 +NULL -1540302337 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 Mfyi8GP6X7lQ28o3l true NULL -14.908000052828811 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 1540302337 NULL -15601 3569 -15242.0 -15601 +NULL -1291025659 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 2TCJA4qtFeE58 false NULL -37.159000044279196 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 1291025659 NULL -15601 3569 -15242.0 -15601 +NULL 142487106 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 YoE3rCoae83u101q true NULL 45.91200000488698 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 -142487106 NULL -15601 3569 -15242.0 -15601 +NULL -2123576095 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 hh8UaA8d false NULL -7.291000072833754 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 2123576095 NULL -15601 3569 -15242.0 -15601 +NULL 667693308 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 ss true NULL 46.714000022900336 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 -667693308 NULL -15601 3569 -15242.0 -15601 +NULL -1655350680 NULL NULL -36.0 15601.0 1969-12-31 15:59:58.456 15601 l341V65B87PovhCN54I8Uy7U true NULL -2.603000056774704 NULL 10.175 36.0 -72.0 -72.0 2.43391201E8 -15601.0 1655350680 NULL -15601 3569 -15242.0 -15601 +NULL 1850076369 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 0uO20 false NULL 74.51200006345334 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -1850076369 NULL -15601 3569 -15242.0 -15601 +NULL 1551526522 NULL NULL -51.0 15601.0 1969-12-31 15:59:58.456 15601 60g81s false NULL 67.13800005321377 NULL 10.175 51.0 -102.0 -102.0 2.43391201E8 -15601.0 -1551526522 NULL -15601 3569 -15242.0 -15601 +NULL 992449209 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 yWHlYm0LoySX1LfNl false NULL 77.04000003403871 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -992449209 NULL -15601 3569 -15242.0 -15601 +NULL -1175444744 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 5ydLyNvMP2B2 true NULL -5.246000040315039 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 1175444744 NULL -15601 3569 -15242.0 -15601 +NULL -1127028116 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 putXB1b616C0c false NULL -49.02300003865446 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 1127028116 NULL -15601 3569 -15242.0 -15601 +NULL 624304190 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 JeNoQM2514UXI306K8SbN true NULL 9.997000021412191 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 -624304190 NULL -15601 3569 -15242.0 -15601 +NULL 1351708341 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 g2hT2k2vr8 false NULL 8.971000046360473 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 -1351708341 NULL -15601 3569 -15242.0 -15601 +NULL -354697170 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 2C1n0DNS8X false NULL -16.269000012165293 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 354697170 NULL -15601 3569 -15242.0 -15601 +NULL -1683400285 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -15.33300005773674 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1683400285 NULL -15601 3569 -15242.0 -15601 +NULL 1392345762 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 y48u41sLDS266b68X58Ji8 false NULL 7.405000047754243 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -1392345762 NULL -15601 3569 -15242.0 -15601 +NULL 1781893821 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 Rf45Knu04s4160Ic0TDdw false NULL 16.22200006111484 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -1781893821 NULL -15601 3569 -15242.0 -15601 +NULL -629005739 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 g53Oneop5UTaJ false NULL -56.25000002157344 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 629005739 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 NrCRG0ol8t3w116fK2 false NULL NULL NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -1144200805 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 Yfj785H813DA8 true NULL -29.678000039243443 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 1144200805 NULL -15601 3569 -15242.0 -15601 +NULL -1357998994 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 UYC1dkb7n5YcmFAAbT2 false NULL -8.496000046576228 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 1357998994 NULL -15601 3569 -15242.0 -15601 +NULL 808219026 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 B0L388T3mhPaRCS true NULL 4.288000027720045 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -808219026 NULL -15601 3569 -15242.0 -15601 +NULL 1960950366 NULL NULL -64.0 15601.0 1969-12-31 15:59:58.456 15601 c0ODOF64 true NULL 21.223000067256066 NULL 10.175 64.0 -128.0 -128.0 2.43391201E8 -15601.0 -1960950366 NULL -15601 3569 -15242.0 -15601 +NULL 1273456471 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 23Uv26RhfxYCNyIQS1HJn true NULL 49.65600004367661 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 -1273456471 NULL -15601 3569 -15242.0 -15601 +NULL 613322929 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 Gi2GkC27Si2F2HcPpxl30H true NULL 6.458000021035559 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 -613322929 NULL -15601 3569 -15242.0 -15601 +NULL 1640015816 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 5Sm77ix2oQa7spX true NULL 13.542000056248753 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 -1640015816 NULL -15601 3569 -15242.0 -15601 +NULL -910567691 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 87Iw7D4t61rud4M false NULL -75.35000003123037 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 910567691 NULL -15601 3569 -15242.0 -15601 +NULL 1195157304 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 hOk8gCaB70IxvBEUjn5X1 true NULL 47.82300004099113 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 -1195157304 NULL -15601 3569 -15242.0 -15601 +NULL 937353204 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 wT86Y true NULL 13.697000032149049 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 -937353204 NULL -15601 3569 -15242.0 -15601 +NULL 483904240 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 5UcDl false NULL 47.130000016596796 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 -483904240 NULL -15601 3569 -15242.0 -15601 +NULL -747159857 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 4DwyxKwiHK3nV8p6 true NULL -69.82500002562585 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 747159857 NULL -15601 3569 -15242.0 -15601 +NULL -662740282 NULL NULL 3.0 15601.0 1969-12-31 15:59:58.456 15601 GGc5G7 true NULL -70.04700002273046 NULL 1.1750000000000007 -3.0 6.0 6.0 2.43391201E8 -15601.0 662740282 NULL -15601 3569 -15242.0 -15601 +NULL -886068046 NULL NULL -52.0 15601.0 1969-12-31 15:59:58.456 15601 JGPmC0e7g1h87 false NULL -49.548000030390085 NULL 10.175 52.0 -104.0 -104.0 2.43391201E8 -15601.0 886068046 NULL -15601 3569 -15242.0 -15601 +NULL -1263796487 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 iQ38TIfb78X5Kx3s false NULL -27.3400000433453 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 1263796487 NULL -15601 3569 -15242.0 -15601 +NULL 211786821 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 60B4H0EgaA4NC5Iyy4O false NULL 28.870000007263798 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 -211786821 NULL -15601 3569 -15242.0 -15601 +NULL -5953872 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 STrL4f3N1wj false NULL -45.9270000002042 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 5953872 NULL -15601 3569 -15242.0 -15601 +NULL 21154567 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 fmKulhf41 false NULL 71.89900000072555 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 -21154567 NULL -15601 3569 -15242.0 -15601 +NULL 216288723 NULL NULL -47.0 15601.0 1969-12-31 15:59:58.456 15601 k1JK0uH false NULL 26.600000007418203 NULL 10.175 47.0 -94.0 -94.0 2.43391201E8 -15601.0 -216288723 NULL -15601 3569 -15242.0 -15601 +NULL -2108715482 NULL NULL 13.0 15601.0 1969-12-31 15:59:58.456 15601 2w0w8B85pE4jELXx false NULL -53.79700007232407 NULL 10.175 -13.0 26.0 26.0 2.43391201E8 -15601.0 2108715482 NULL -15601 3569 -15242.0 -15601 +NULL 270658833 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 n52LW25tF88Cq3WqkfrX6Y true NULL 36.51500000928297 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 -270658833 NULL -15601 3569 -15242.0 -15601 +NULL 524871590 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 tP587H755g46WG3SV false NULL 68.27300001800188 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 -524871590 NULL -15601 3569 -15242.0 -15601 +NULL 1575017812 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 s13Omr false NULL 72.21500005401947 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 -1575017812 NULL -15601 3569 -15242.0 -15601 +NULL 1195930056 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 8dvkU0qkX4qr true NULL 21.981000041017637 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -1195930056 NULL -15601 3569 -15242.0 -15601 +NULL -1278926860 NULL NULL 24.0 15601.0 1969-12-31 15:59:58.456 15601 xH6yW0I7 true NULL -56.164000043864235 NULL 10.175 -24.0 48.0 48.0 2.43391201E8 -15601.0 1278926860 NULL -15601 3569 -15242.0 -15601 +NULL 518926864 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 ewB0J6uh14RkDmdbxV40tXI false NULL 19.751000017797992 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 -518926864 NULL -15601 3569 -15242.0 -15601 +NULL -990240929 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 qt8JI7S2r0t2 false NULL -29.214000033962975 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 990240929 NULL -15601 3569 -15242.0 -15601 +NULL 1028143712 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 TN1V103235ex7r5y1UnD true NULL 24.023000035262953 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 -1028143712 NULL -15601 3569 -15242.0 -15601 +NULL -368721894 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 HcoJtE70sS7KuFuuW true NULL -23.68700001264631 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 368721894 NULL -15601 3569 -15242.0 -15601 +NULL -2125793790 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 Xt8767d0562DL58h2yksj37 true NULL -3.3100000729098156 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 2125793790 NULL -15601 3569 -15242.0 -15601 +NULL 1304453187 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 W56kQ5UX8GHpErCJ0X0PiMg true NULL 52.94800004473973 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 -1304453187 NULL -15601 3569 -15242.0 -15601 +NULL 456583571 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 6tDKNa false NULL 26.26100001565976 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 -456583571 NULL -15601 3569 -15242.0 -15601 +NULL 69448698 NULL NULL -51.0 15601.0 1969-12-31 15:59:58.456 15601 08wTUR832pDS4Hd8O40 false NULL 42.74200000238193 NULL 10.175 51.0 -102.0 -102.0 2.43391201E8 -15601.0 -69448698 NULL -15601 3569 -15242.0 -15601 +NULL -440412114 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 rMr4hfN8InCk2K45kv true NULL -23.548000015105117 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 440412114 NULL -15601 3569 -15242.0 -15601 +NULL 440096608 NULL NULL -52.0 15601.0 1969-12-31 15:59:58.456 15601 R8IJh6386ba3D3VS70FSlw6 true NULL 24.746000015094296 NULL 10.175 52.0 -104.0 -104.0 2.43391201E8 -15601.0 -440096608 NULL -15601 3569 -15242.0 -15601 +NULL 995786060 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 y33iH false NULL 77.45500003415316 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -995786060 NULL -15601 3569 -15242.0 -15601 +NULL 811631368 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 6HHDm16v6VrJA false NULL 79.45900002783708 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -811631368 NULL -15601 3569 -15242.0 -15601 +NULL -468932050 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 G2eTbpXOf false NULL -49.942000016083284 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 468932050 NULL -15601 3569 -15242.0 -15601 +NULL -1107321329 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 M40e006lkM2L true NULL -51.63000003797856 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 1107321329 NULL -15601 3569 -15242.0 -15601 +NULL -25467184 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 5EIQq8oF false NULL -41.216000000873464 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 25467184 NULL -15601 3569 -15242.0 -15601 +NULL -1846410950 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 iUa3ie0Yw3S4BW2tSB false NULL -59.98700006332763 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 1846410950 NULL -15601 3569 -15242.0 -15601 +NULL -630453835 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 t8WH3m7Jk5nSoO3EyDT0G1E true NULL -48.99100002162311 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 630453835 NULL -15601 3569 -15242.0 -15601 +NULL -1393938237 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 VT72k7T7C3N73lA10202 false NULL -70.00400004780886 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 1393938237 NULL -15601 3569 -15242.0 -15601 +NULL -1393500402 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 4UWNuEfgp false NULL -15.163000047793844 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 1393500402 NULL -15601 3569 -15242.0 -15601 +NULL -1133138233 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 NKt630 false NULL -18.305000038864023 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 1133138233 NULL -15601 3569 -15242.0 -15601 +NULL 1718435591 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 60o1F4eW1 false NULL 21.02700005893837 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 -1718435591 NULL -15601 3569 -15242.0 -15601 +NULL 414211691 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 u72VRw74UX1QLxj true NULL 62.8860000142065 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -414211691 NULL -15601 3569 -15242.0 -15601 +NULL -2043827141 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 Ydu8G8I0720hU85E53t false NULL -71.88300007009855 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 2043827141 NULL -15601 3569 -15242.0 -15601 +NULL 1221840945 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 0h046K61PUKMqHs6v4 false NULL 21.56300004190632 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -1221840945 NULL -15601 3569 -15242.0 -15601 +NULL 1827212970 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 7RSMUpu2l false NULL 48.60600006266918 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 -1827212970 NULL -15601 3569 -15242.0 -15601 +NULL -1300968933 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 o8KdKvR1YBU80TY31Fqt false NULL -61.24200004462023 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 1300968933 NULL -15601 3569 -15242.0 -15601 +NULL -941937506 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 FmeinD4GMhc3dR false NULL -74.07200003230628 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 941937506 NULL -15601 3569 -15242.0 -15601 +NULL -85097850 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 t3Ne1ggc false NULL -5.9000000029186594 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 85097850 NULL -15601 3569 -15242.0 -15601 +NULL 839217757 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 EpY8iI4vm3q3d3x0862L3 true NULL 33.75500002878323 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 -839217757 NULL -15601 3569 -15242.0 -15601 +NULL 1433953002 NULL NULL -52.0 15601.0 1969-12-31 15:59:58.456 15601 wRE3mvASgu0m8RNlK true NULL 73.76900004918127 NULL 10.175 52.0 -104.0 -104.0 2.43391201E8 -15601.0 -1433953002 NULL -15601 3569 -15242.0 -15601 +NULL -1743144280 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 VkLA5W0AsJ2v7X7 false NULL -25.54500005978582 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 1743144280 NULL -15601 3569 -15242.0 -15601 +NULL -211726367 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 nsd577xcp73fbW2nNX78wH true NULL -35.150000007261724 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 211726367 NULL -15601 3569 -15242.0 -15601 +NULL -1996001975 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 xQ2ag4X3 false NULL -21.552000068458256 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 1996001975 NULL -15601 3569 -15242.0 -15601 +NULL -1610058211 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 ETN236368gQub756Dmfp5181 true NULL -79.51700005522127 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 1610058211 NULL -15601 3569 -15242.0 -15601 +NULL -128270777 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 JFRQYgF2d57MV true NULL -76.67100000439939 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 128270777 NULL -15601 3569 -15242.0 -15601 +NULL -748287945 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 y6Lo3tYq16JX1YFaXH6 true NULL -16.732000025664547 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 748287945 NULL -15601 3569 -15242.0 -15601 +NULL -2081329290 NULL NULL 33.0 15601.0 1969-12-31 15:59:58.456 15601 vG58d false NULL -61.600000071384784 NULL 10.175 -33.0 66.0 66.0 2.43391201E8 -15601.0 2081329290 NULL -15601 3569 -15242.0 -15601 +NULL 1312374660 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 Oc6P2F1UD0D0T0haR false NULL 35.97300004501142 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -1312374660 NULL -15601 3569 -15242.0 -15601 +NULL -658899077 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 jeoldo3 false NULL -2.099000022598716 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 658899077 NULL -15601 3569 -15242.0 -15601 +NULL -1301028273 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 h43nUn6SU2lQOSXs4f5x70 true NULL -54.70400004462226 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 1301028273 NULL -15601 3569 -15242.0 -15601 +NULL -404751232 NULL NULL 24.0 15601.0 1969-12-31 15:59:58.456 15601 t674665hYSom0Xi false NULL -46.64600001388203 NULL 10.175 -24.0 48.0 48.0 2.43391201E8 -15601.0 404751232 NULL -15601 3569 -15242.0 -15601 +NULL -921789404 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 47tNFFE0l8022wydms false NULL -42.170000031615245 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 921789404 NULL -15601 3569 -15242.0 -15601 +NULL -2080305624 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 8e3Ri1wGpcM false NULL -4.0510000713496765 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 2080305624 NULL -15601 3569 -15242.0 -15601 +NULL -1167054574 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -51.497000040027274 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 1167054574 NULL -15601 3569 -15242.0 -15601 +NULL -1677882999 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 QCY0pTKdHRqrf5P1N58 true NULL -48.09500005754751 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 1677882999 NULL -15601 3569 -15242.0 -15601 +NULL -1297431786 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 1TWVYbo8A06jVpsj false NULL -79.28100004449891 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 1297431786 NULL -15601 3569 -15242.0 -15601 +NULL 1943589678 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 aO4aO true NULL 25.307000066660635 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 -1943589678 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 35kveUkKO3V1ad2 true NULL NULL NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 529529092 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 73117URk7G4v true NULL 60.33500001816162 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -529529092 NULL -15601 3569 -15242.0 -15601 +NULL 419546737 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 28ao0HxkN7J72QNhcY true NULL 46.04700001438948 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -419546737 NULL -15601 3569 -15242.0 -15601 +NULL 1328883886 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 155506i0h358vma3m1tGku false NULL 25.648000045577646 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 -1328883886 NULL -15601 3569 -15242.0 -15601 +NULL 140156598 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 p2O5Aw false NULL 43.047000004807046 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 -140156598 NULL -15601 3569 -15242.0 -15601 +NULL -1452617198 NULL NULL 79.553 15601.0 1969-12-31 15:59:58.456 15601 04XP4DrTCblC7885 false NULL -22.227000049821413 NULL 10.175 -79.553 159.106 159.106 2.43391201E8 -15601.0 1452617198 NULL -15601 3569 -15242.0 -15601 +NULL -843069884 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 agGaMK8cpJnS2qecNteXM true NULL -45.38900002891535 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 843069884 NULL -15601 3569 -15242.0 -15601 +NULL -257298466 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 DsLt4LdED7Q7 true NULL -38.99400000882474 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 257298466 NULL -15601 3569 -15242.0 -15601 +NULL 259213262 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 gA2HaQB33 true NULL 73.83700000889041 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 -259213262 NULL -15601 3569 -15242.0 -15601 +NULL -620887667 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 dd63ud0WOt0F74mu false NULL -49.68800002129501 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 620887667 NULL -15601 3569 -15242.0 -15601 +NULL 1837742836 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 U62U7O2LVYg true NULL 40.86700006303033 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -1837742836 NULL -15601 3569 -15242.0 -15601 +NULL 333745628 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 64NUjX13Fyeb7AWh5DX2D true NULL 29.667000011446703 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -333745628 NULL -15601 3569 -15242.0 -15601 +NULL -996134600 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 23HjoS18rjHCx771 false NULL -16.209000034165115 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 996134600 NULL -15601 3569 -15242.0 -15601 +NULL -202495882 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 pMCLCx64B88ew0lSr7p6R true NULL -5.187000006945141 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 202495882 NULL -15601 3569 -15242.0 -15601 +NULL 375928903 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 T7R4Jnl7s3d053wmyOrt true NULL 8.205000012893493 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -375928903 NULL -15601 3569 -15242.0 -15601 +NULL -1656847358 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 RjYdeaB false NULL -50.014000056826035 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 1656847358 NULL -15601 3569 -15242.0 -15601 +NULL 1370965887 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 dB0AI5N14Vel4oxYb false NULL 1.1550000470209625 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 -1370965887 NULL -15601 3569 -15242.0 -15601 +NULL 107241980 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 r0Owj7EwMla7 false NULL 1.479000003678152 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 -107241980 NULL -15601 3569 -15242.0 -15601 +NULL 1250832914 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 44n5KP8SW true NULL 13.455000042900679 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -1250832914 NULL -15601 3569 -15242.0 -15601 +NULL -1253747722 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 jwMBfF716565GPGb8 true NULL -79.08800004300065 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 1253747722 NULL -15601 3569 -15242.0 -15601 +NULL -1964487606 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 q5v87lPeda4U128Vg true NULL -16.631000067377386 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 1964487606 NULL -15601 3569 -15242.0 -15601 +NULL 1991822914 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 7V5hA1gBCS673CU337DA24Ce false NULL 38.74800006831492 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 -1991822914 NULL -15601 3569 -15242.0 -15601 +NULL 1766992295 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 HghnGE5gflqVwR76sX18 true NULL 39.97000006060375 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -1766992295 NULL -15601 3569 -15242.0 -15601 +NULL -1466363382 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 wLbNp726 false NULL -4.698000050292876 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 1466363382 NULL -15601 3569 -15242.0 -15601 +NULL -466156812 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 Mg8NV0cpt7B80 true NULL -18.3470000159881 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 466156812 NULL -15601 3569 -15242.0 -15601 +NULL -1259043484 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 povI4owX7P14F true NULL -77.43100004318228 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 1259043484 NULL -15601 3569 -15242.0 -15601 +NULL -343392629 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 1sHwG4L77O4cr560Mb438A true NULL -36.12200001177757 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 343392629 NULL -15601 3569 -15242.0 -15601 +NULL 53950949 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 52cUSOgt7i1PMGWG3 true NULL 13.672000001850392 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -53950949 NULL -15601 3569 -15242.0 -15601 +NULL -1970072997 NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 Keq6tT2y4kB7 false NULL -71.05400006756895 NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 1970072997 NULL -15601 3569 -15242.0 -15601 +NULL 1750152891 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 77KSI1X3EL2 false NULL 17.2450000600262 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 -1750152891 NULL -15601 3569 -15242.0 -15601 +NULL 1553995372 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 Cl82a true NULL 69.33600005329845 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -1553995372 NULL -15601 3569 -15242.0 -15601 +NULL -309614238 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 giIcM6O true NULL -8.028000010619053 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 309614238 NULL -15601 3569 -15242.0 -15601 +NULL 1202434039 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 yG1K4R5rl3Dxr8 false NULL 69.9130000412407 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -1202434039 NULL -15601 3569 -15242.0 -15601 +NULL -1434650528 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 1NuHbq7wu true NULL -79.0650000492052 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 1434650528 NULL -15601 3569 -15242.0 -15601 +NULL 1218760785 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 PxcCoxYeQ5M true NULL 74.17000004180068 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 -1218760785 NULL -15601 3569 -15242.0 -15601 +NULL -1025776200 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 sOK0TV42nMAecC7o true NULL -9.303000035181753 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 1025776200 NULL -15601 3569 -15242.0 -15601 +NULL -487954385 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 4HXsi4dv true NULL -69.3470000167357 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 487954385 NULL -15601 3569 -15242.0 -15601 +NULL 667749103 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 RWDJpR813I70rA48j3St8 false NULL 75.06100002290225 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 -667749103 NULL -15601 3569 -15242.0 -15601 +NULL -26446061 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 6RF0nrPv31V5d7y203yEhP04 false NULL -18.551000000907038 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 26446061 NULL -15601 3569 -15242.0 -15601 +NULL 2067730138 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 7od8M476cRRTyd1i false NULL 17.632000070918366 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 -2067730138 NULL -15601 3569 -15242.0 -15601 +NULL 484546535 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 e0punYXUPMa7V37IKAsPn false NULL 31.208000016618826 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 -484546535 NULL -15601 3569 -15242.0 -15601 +NULL -621636211 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 k4PB4sW7DW true NULL -79.51100002132068 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 621636211 NULL -15601 3569 -15242.0 -15601 +NULL -1473796341 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 V3e7tuWVX0gajjH6X8 true NULL -8.69600005054781 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 1473796341 NULL -15601 3569 -15242.0 -15601 +NULL 160900383 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 568U4kod3IM212hiu8KM true NULL 65.08500000551851 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -160900383 NULL -15601 3569 -15242.0 -15601 +NULL 305163101 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 cwRvPDq3hcXjg22 true NULL 20.48400001046639 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 -305163101 NULL -15601 3569 -15242.0 -15601 +NULL -1032806869 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 7s3sR2QjWXv0 true NULL -22.82200003542289 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 1032806869 NULL -15601 3569 -15242.0 -15601 +NULL 1650023180 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 7AL73c false NULL 7.907000056591983 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 -1650023180 NULL -15601 3569 -15242.0 -15601 +NULL 1311147301 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 lsqjxhMR2 true NULL 20.657000044969323 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 -1311147301 NULL -15601 3569 -15242.0 -15601 +NULL -1062767051 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 6iO7Vgh08 true NULL -67.70400003645045 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 1062767051 NULL -15601 3569 -15242.0 -15601 +NULL -62733813 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 27iT5rw true NULL -67.36600000215162 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 62733813 NULL -15601 3569 -15242.0 -15601 +NULL 1565136019 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 tO3LtSl1084g7Lp6 false NULL 34.66300005368055 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 -1565136019 NULL -15601 3569 -15242.0 -15601 +NULL -223953421 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 Jf3TV3LhLih false NULL -31.709000007681084 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 223953421 NULL -15601 3569 -15242.0 -15601 +NULL -493471535 NULL NULL -47.0 15601.0 1969-12-31 15:59:58.456 15601 YfL70dofbs6lhgKMX8kGsJ false NULL -59.69100001692493 NULL 10.175 47.0 -94.0 -94.0 2.43391201E8 -15601.0 493471535 NULL -15601 3569 -15242.0 -15601 +NULL -1927777662 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 sTA0n272vRadQdhvlwm6H4 true NULL -43.14000006611832 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 1927777662 NULL -15601 3569 -15242.0 -15601 +NULL -427240643 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 HJTchT5CPC84 true NULL -63.205000014653365 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 427240643 NULL -15601 3569 -15242.0 -15601 +NULL 192161117 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 Q6v087IOF2 false NULL 49.97000000659068 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 -192161117 NULL -15601 3569 -15242.0 -15601 +NULL 970663654 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 1bQgOIC5M1mYO false NULL 31.53700003329152 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 -970663654 NULL -15601 3569 -15242.0 -15601 +NULL 612416000 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 40at262XNm5auTvXDhreVM true NULL 61.21100002100445 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 -612416000 NULL -15601 3569 -15242.0 -15601 +NULL 1514114936 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 hr1t48Hqp0QFXiAJk6 true NULL 29.554000051930643 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 -1514114936 NULL -15601 3569 -15242.0 -15601 +NULL -189542740 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 sdHL10 false NULL -0.859000006500878 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 189542740 NULL -15601 3569 -15242.0 -15601 +NULL 1809122123 NULL NULL -1.0 15601.0 1969-12-31 15:59:58.456 15601 86Rm22yWrLRgkI6V false NULL 31.124000062048708 NULL 0.1750000000000007 1.0 -2.0 -2.0 2.43391201E8 -15601.0 -1809122123 NULL -15601 3569 -15242.0 -15601 +NULL 446614861 NULL NULL 23.0 15601.0 1969-12-31 15:59:58.456 15601 6TeJh6uj8yr false NULL 23.138000015317857 NULL 10.175 -23.0 46.0 46.0 2.43391201E8 -15601.0 -446614861 NULL -15601 3569 -15242.0 -15601 +NULL 1179135101 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 54X76o true NULL 57.68200004044161 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 -1179135101 NULL -15601 3569 -15242.0 -15601 +NULL -1198536835 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 trV5VJ8CE2 false NULL -8.277000041107044 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 1198536835 NULL -15601 3569 -15242.0 -15601 +NULL -2115132140 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 63eX32F8ps86O false NULL -46.370000072544144 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 2115132140 NULL -15601 3569 -15242.0 -15601 +NULL -557847275 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 3oIYv7OvH2vrLTHsa true NULL -0.5840000191328727 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 557847275 NULL -15601 3569 -15242.0 -15601 +NULL -2041965187 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 JE6y6UBN33n8Kcs true NULL -55.848000070034686 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 2041965187 NULL -15601 3569 -15242.0 -15601 +NULL -1493188887 NULL NULL 36.0 15601.0 1969-12-31 15:59:58.456 15601 2V30r60 false NULL -78.99200005121293 NULL 10.175 -36.0 72.0 72.0 2.43391201E8 -15601.0 1493188887 NULL -15601 3569 -15242.0 -15601 +NULL 493058527 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 QV08okL83Ug1jwOV8h74 true NULL 11.314000016910768 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 -493058527 NULL -15601 3569 -15242.0 -15601 +NULL 212818854 NULL NULL -53.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 20.801000007299194 NULL 10.175 53.0 -106.0 -106.0 2.43391201E8 -15601.0 -212818854 NULL -15601 3569 -15242.0 -15601 +NULL 1341651482 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 5kH1rO false NULL 1.572000046015546 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 -1341651482 NULL -15601 3569 -15242.0 -15601 +NULL 1448245990 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 R68avA7MskCgYOOEP true NULL 12.918000049671491 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 -1448245990 NULL -15601 3569 -15242.0 -15601 +NULL 561535341 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 MOrNN2vu2e false NULL 69.05700001925936 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -561535341 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -51.0 15601.0 1969-12-31 15:59:58.456 15601 3V8UHxN5TBU true NULL NULL NULL 10.175 51.0 -102.0 -102.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 1496148727 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 bU8s7i6y25o1OESm false NULL 70.07400005131444 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -1496148727 NULL -15601 3569 -15242.0 -15601 +NULL 1007181336 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 064GHv0UW8 true NULL 22.629000034543992 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 -1007181336 NULL -15601 3569 -15242.0 -15601 +NULL 1477361644 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 jGy644yRrN2T63m8Km3XBx2V false NULL 64.44800005067009 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -1477361644 NULL -15601 3569 -15242.0 -15601 +NULL -1971224972 NULL NULL 56.0 15601.0 1969-12-31 15:59:58.456 15601 au3Muxk02EL34sh true NULL -39.06100006760846 NULL 10.175 -56.0 112.0 112.0 2.43391201E8 -15601.0 1971224972 NULL -15601 3569 -15242.0 -15601 +NULL -1195710741 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 Mpl1s7so8 false NULL -34.602000041010115 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 1195710741 NULL -15601 3569 -15242.0 -15601 +NULL 2063265876 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 ympu07eL1bs7uXSpb05S true NULL 31.33300007076525 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -2063265876 NULL -15601 3569 -15242.0 -15601 +NULL -1106735397 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 KO3lYMSBj false NULL -27.475000037958466 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 1106735397 NULL -15601 3569 -15242.0 -15601 +NULL -205670222 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 8fxjs0MMOIa0N27 true NULL -21.381000007054013 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 205670222 NULL -15601 3569 -15242.0 -15601 +NULL 1329225687 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 V3ySf true NULL 66.96000004558937 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -1329225687 NULL -15601 3569 -15242.0 -15601 +NULL -278405900 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 AXc2FKJEWhLfD253aoO1 false NULL -73.26900000954868 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 278405900 NULL -15601 3569 -15242.0 -15601 +NULL 1911676187 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 nKgpUv0 false NULL 15.787000065566076 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -1911676187 NULL -15601 3569 -15242.0 -15601 +NULL -560714683 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 80rr6EU false NULL -0.2520000192312182 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 560714683 NULL -15601 3569 -15242.0 -15601 +NULL 1593645377 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 4L28g68B1xnrTBsnCa true NULL 63.60600005465835 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 -1593645377 NULL -15601 3569 -15242.0 -15601 +NULL -1447719201 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 UQR88o20Gf453RP true NULL -23.884000049653423 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 1447719201 NULL -15601 3569 -15242.0 -15601 +NULL 477899524 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 q6hAYOIF4604p false NULL 71.12300001639085 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 -477899524 NULL -15601 3569 -15242.0 -15601 +NULL -1523633607 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 to1SOvJDN6Y5uCs0h false NULL -24.99800005225711 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 1523633607 NULL -15601 3569 -15242.0 -15601 +NULL 451518699 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 8e7L21Y4g8xid8j true NULL 55.112000015486046 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 -451518699 NULL -15601 3569 -15242.0 -15601 +NULL -1109093265 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 oX1E4mpAYj false NULL -24.108000038039336 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 1109093265 NULL -15601 3569 -15242.0 -15601 +NULL 1251122304 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 3I62k00H8W4YkR8UVffhm true NULL 69.1940000429106 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -1251122304 NULL -15601 3569 -15242.0 -15601 +NULL 1972121187 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 6p3YH01g4Q false NULL 9.9630000676392 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 -1972121187 NULL -15601 3569 -15242.0 -15601 +NULL -1111076337 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 j7Gqg0yE8cnygM7ErU true NULL -78.47700003810735 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 1111076337 NULL -15601 3569 -15242.0 -15601 +NULL 451451749 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 gtVQSJD4bt false NULL 9.185000015483752 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 -451451749 NULL -15601 3569 -15242.0 -15601 +NULL -309692433 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 tG4UccR false NULL -2.429000010621735 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 309692433 NULL -15601 3569 -15242.0 -15601 +NULL -89010 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 7Wy08w00BpunUYJVsr05u46 true NULL -69.74600000000305 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 89010 NULL -15601 3569 -15242.0 -15601 +NULL -393066261 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 OtgfTpqxm51v6Y true NULL -58.94500001348126 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 393066261 NULL -15601 3569 -15242.0 -15601 +NULL -1761560547 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 YY83652Ij false NULL -11.704000060417457 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 1761560547 NULL -15601 3569 -15242.0 -15601 +NULL -1465766070 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 23fHhEiKL5D3voA true NULL -56.17500005027239 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 1465766070 NULL -15601 3569 -15242.0 -15601 +NULL 290481712 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 HyD5X4wA0G4Ir6Wq6gM5H true NULL 58.08100000996285 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 -290481712 NULL -15601 3569 -15242.0 -15601 +NULL 528190079 NULL NULL -43.0 15601.0 1969-12-31 15:59:58.456 15601 l2G2GiUS71rq46QjKqSVgbe false NULL 3.8780000181156993 NULL 10.175 43.0 -86.0 -86.0 2.43391201E8 -15601.0 -528190079 NULL -15601 3569 -15242.0 -15601 +NULL -319788030 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 3503D1bt0J1Ud74yX4716121 false NULL -5.51700001096799 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 319788030 NULL -15601 3569 -15242.0 -15601 +NULL 1761957770 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 lWfwbFJ6y3mL5 true NULL 26.57500006043108 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 -1761957770 NULL -15601 3569 -15242.0 -15601 +NULL -39854776 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 SjG26TSvqw3myt false NULL -75.40100000136692 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 39854776 NULL -15601 3569 -15242.0 -15601 +NULL 1621714068 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 dx274GN7a6aMOVqr5d0W false NULL 69.61600005562104 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -1621714068 NULL -15601 3569 -15242.0 -15601 +NULL -1105322173 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 cjM88EJ3P413qg4 false NULL -62.520000037909995 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 1105322173 NULL -15601 3569 -15242.0 -15601 +NULL -133287350 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 3NKHJC true NULL -37.49100000457145 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 133287350 NULL -15601 3569 -15242.0 -15601 +NULL -1972968987 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 Alqjt false NULL -13.642000067668278 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 1972968987 NULL -15601 3569 -15242.0 -15601 +NULL -1644279296 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 8FK46Fy4W5mow61w1EO false NULL -9.61300005639498 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 1644279296 NULL -15601 3569 -15242.0 -15601 +NULL -1665990202 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 wY2MC0I15H false NULL -26.830000057139614 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 1665990202 NULL -15601 3569 -15242.0 -15601 +NULL -404509269 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 E100F0lsE520GtpXYIu true NULL -4.319000013873733 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 404509269 NULL -15601 3569 -15242.0 -15601 +NULL 1815385311 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 B5RW2g5yog true NULL 11.434000062263522 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 -1815385311 NULL -15601 3569 -15242.0 -15601 +NULL 996454184 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 2IDKgpJH461h554ubuHe2 false NULL 35.808000034176075 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -996454184 NULL -15601 3569 -15242.0 -15601 +NULL -1574729892 NULL NULL -63.0 15601.0 1969-12-31 15:59:58.456 15601 5w4L1fDocLE51HE7N3c false NULL -54.522000054009595 NULL 10.175 63.0 -126.0 -126.0 2.43391201E8 -15601.0 1574729892 NULL -15601 3569 -15242.0 -15601 +NULL -484639113 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 82g6ygwAG80 true NULL -9.516000016622002 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 484639113 NULL -15601 3569 -15242.0 -15601 +NULL -1487527155 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 F1D04R4cY5JQbX3M4l6 true NULL -54.44900005101874 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 1487527155 NULL -15601 3569 -15242.0 -15601 +NULL 980331206 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 HX4NNXplV2R7G35xp true NULL 64.3180000336231 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -980331206 NULL -15601 3569 -15242.0 -15601 +NULL -1723403466 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 vVvyk true NULL -49.836000059108756 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 1723403466 NULL -15601 3569 -15242.0 -15601 +NULL -419284856 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 W2o1wfC1yw61GkMU false NULL -53.5230000143805 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 419284856 NULL -15601 3569 -15242.0 -15601 +NULL -1703837738 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 U75G6OsrKmd7KxMe true NULL -63.974000058437696 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 1703837738 NULL -15601 3569 -15242.0 -15601 +NULL 440950508 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 35V0Eq127c7Jbvs862 false NULL 2.8440000151235836 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 -440950508 NULL -15601 3569 -15242.0 -15601 +NULL 1788323480 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 B204fmP5Do5b true NULL 42.65600006133536 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 -1788323480 NULL -15601 3569 -15242.0 -15601 +NULL -946632342 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 F7A5XKmXGD false NULL -10.224000032467302 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 946632342 NULL -15601 3569 -15242.0 -15601 +NULL -75975416 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 0aQBRP67JY0gpi true NULL -73.51600000260578 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 75975416 NULL -15601 3569 -15242.0 -15601 +NULL -1803981239 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 ShjbW3q38Px24Hx false NULL -21.090000061872388 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 1803981239 NULL -15601 3569 -15242.0 -15601 +NULL 1553802956 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 ysho54gMb false NULL 12.490000053291851 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 -1553802956 NULL -15601 3569 -15242.0 -15601 +NULL -218695361 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 3T10x1IyRuV5H77 false NULL -27.244000007500745 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 218695361 NULL -15601 3569 -15242.0 -15601 +NULL 853662696 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 KX43450qk3ifahho2 true NULL 57.227000029278656 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 -853662696 NULL -15601 3569 -15242.0 -15601 +NULL -1275985495 NULL NULL -17.0 15601.0 1969-12-31 15:59:58.456 15601 IJRqL2Ec6JGceMcn6bUyuRU8 false NULL -4.233000043763354 NULL 10.175 17.0 -34.0 -34.0 2.43391201E8 -15601.0 1275985495 NULL -15601 3569 -15242.0 -15601 +NULL 622595672 NULL NULL 21.0 15601.0 1969-12-31 15:59:58.456 15601 p67gypHKaOpa true NULL 51.77800002135359 NULL 10.175 -21.0 42.0 42.0 2.43391201E8 -15601.0 -622595672 NULL -15601 3569 -15242.0 -15601 +NULL 1233573347 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 eWS267E7 true NULL 26.676000042308715 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -1233573347 NULL -15601 3569 -15242.0 -15601 +NULL 1262293897 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 w5HQR5omF5aa true NULL 34.40400004329376 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 -1262293897 NULL -15601 3569 -15242.0 -15601 +NULL -2136727102 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 18032Ok80Rh3ICJd2QqF true NULL -28.308000073284802 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 2136727102 NULL -15601 3569 -15242.0 -15601 +NULL 2025282930 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 MnGh7cJ8Tqfj5SM3i643 true NULL 62.94800006946252 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 -2025282930 NULL -15601 3569 -15242.0 -15601 +NULL -155636656 NULL NULL 61.0 15601.0 1969-12-31 15:59:58.456 15601 oISQ4 false NULL -41.883000005337976 NULL 10.175 -61.0 122.0 122.0 2.43391201E8 -15601.0 155636656 NULL -15601 3569 -15242.0 -15601 +NULL -486340511 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 tU0624wBI8WF8QTy2C true NULL -7.505000016680356 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 486340511 NULL -15601 3569 -15242.0 -15601 +NULL -692950740 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 F214U41bv false NULL -37.63800002376661 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 692950740 NULL -15601 3569 -15242.0 -15601 +NULL 829545908 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 g27N7513v6femM4d6uS1 true NULL 79.3890000284515 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -829545908 NULL -15601 3569 -15242.0 -15601 +NULL 398128194 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 qQDayoWTv0mh525F true NULL 34.555000013654876 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -398128194 NULL -15601 3569 -15242.0 -15601 +NULL -116661992 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 FIB30nWy1482081ypBNk75 false NULL -63.196000004001235 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 116661992 NULL -15601 3569 -15242.0 -15601 +NULL 2034848433 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 33.6750000697906 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -2034848433 NULL -15601 3569 -15242.0 -15601 +NULL -1338667765 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 041Ph15F true NULL -78.94300004591321 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 1338667765 NULL -15601 3569 -15242.0 -15601 +NULL 488624669 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 hRO11K27w23c true NULL 39.769000016758696 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 -488624669 NULL -15601 3569 -15242.0 -15601 +NULL -490232669 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 c0yFd2trxkcan17uDnIb5tvi true NULL -34.98000001681385 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 490232669 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 10 true NULL NULL NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 113813447 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 66S3R false NULL 72.46700000390354 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 -113813447 NULL -15601 3569 -15242.0 -15601 +NULL 1701987317 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 0UugmY0R5hI true NULL 45.75400005837423 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 -1701987317 NULL -15601 3569 -15242.0 -15601 +NULL -810446066 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 qL7PB2 false NULL -37.606000027796426 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 810446066 NULL -15601 3569 -15242.0 -15601 +NULL 1800301969 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 T45sp true NULL 77.3400000617462 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 -1800301969 NULL -15601 3569 -15242.0 -15601 +NULL -365505703 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 bnKNG5iA false NULL -1.3710000125360011 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 365505703 NULL -15601 3569 -15242.0 -15601 +NULL -2143024405 NULL NULL -29.0 15601.0 1969-12-31 15:59:58.456 15601 Ib62k3A2XLg2TL false NULL -74.93400007350078 NULL 10.175 29.0 -58.0 -58.0 2.43391201E8 -15601.0 2143024405 NULL -15601 3569 -15242.0 -15601 +NULL -1283930255 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 Q30600R1 true NULL -44.78200004403584 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 1283930255 NULL -15601 3569 -15242.0 -15601 +NULL -990904667 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 ySO0O6cvCc true NULL -56.53500003398574 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 990904667 NULL -15601 3569 -15242.0 -15601 +NULL -2058347315 NULL NULL 13.0 15601.0 1969-12-31 15:59:58.456 15601 5HN44RVUXF0ELkvPAkQntoiB true NULL -73.21700007059655 NULL 10.175 -13.0 26.0 26.0 2.43391201E8 -15601.0 2058347315 NULL -15601 3569 -15242.0 -15601 +NULL 1705300763 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 7X08u20Av7FQvjLy5L52 true NULL 29.751000058487875 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -1705300763 NULL -15601 3569 -15242.0 -15601 +NULL -775282830 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 q762VtE6 true NULL -23.13600002659041 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 775282830 NULL -15601 3569 -15242.0 -15601 +NULL 827296932 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 3J71K25Fc721kce4lIT true NULL 66.69900002837437 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 -827296932 NULL -15601 3569 -15242.0 -15601 +NULL -1558180030 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 v3VRMFWeLePKT5TRvcos true NULL -0.8770000534419751 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 1558180030 NULL -15601 3569 -15242.0 -15601 +NULL 2033485401 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 0q4ykcW1A0SyL68L2FH45a false NULL 62.77700006974385 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 -2033485401 NULL -15601 3569 -15242.0 -15601 +NULL 1102736886 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 MHUrF1wtS4FCMIT6aP5 true NULL 9.361000037821327 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 -1102736886 NULL -15601 3569 -15242.0 -15601 +NULL -1215180434 NULL NULL 3.0 15601.0 1969-12-31 15:59:58.456 15601 rD0y0ows2 true NULL -5.935000041677881 NULL 1.1750000000000007 -3.0 6.0 6.0 2.43391201E8 -15601.0 1215180434 NULL -15601 3569 -15242.0 -15601 +NULL 1563660569 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 uEyfrF4o6IXnymi1D1 false NULL 54.15400005362994 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 -1563660569 NULL -15601 3569 -15242.0 -15601 +NULL -631397801 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 m4pvt5 false NULL -39.093000021655484 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 631397801 NULL -15601 3569 -15242.0 -15601 +NULL -1072335429 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 hjSe431c8cW true NULL -49.523000036778626 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 1072335429 NULL -15601 3569 -15242.0 -15601 +NULL -370099117 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 bY0Fbj1ImV2D85h5sTar41 true NULL -25.151000012693544 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 370099117 NULL -15601 3569 -15242.0 -15601 +NULL 1364619191 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 rqO4xWRvlfV3b634HU false NULL 43.495000046803284 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 -1364619191 NULL -15601 3569 -15242.0 -15601 +NULL 1649136404 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 X3E664G5sA false NULL 9.198000056561568 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 -1649136404 NULL -15601 3569 -15242.0 -15601 +NULL 1527899325 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 BEjDfR852Hc1MF836c true NULL 31.585000052403416 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 -1527899325 NULL -15601 3569 -15242.0 -15601 +NULL 761877407 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 E865b true NULL 76.16600002613063 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 -761877407 NULL -15601 3569 -15242.0 -15601 +NULL -1414044792 NULL NULL -18.0 15601.0 1969-12-31 15:59:58.456 15601 3iHVpKa1Iy false NULL -2.0190000484984694 NULL 10.175 18.0 -36.0 -36.0 2.43391201E8 -15601.0 1414044792 NULL -15601 3569 -15242.0 -15601 +NULL 2089631890 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 g5Pyh3A true NULL 33.202000071669545 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 -2089631890 NULL -15601 3569 -15242.0 -15601 +NULL 1421812187 NULL NULL -64.0 15601.0 1969-12-31 15:59:58.456 15601 12AEw true NULL 1.205000048764873 NULL 10.175 64.0 -128.0 -128.0 2.43391201E8 -15601.0 -1421812187 NULL -15601 3569 -15242.0 -15601 +NULL -1804756106 NULL NULL -36.0 15601.0 1969-12-31 15:59:58.456 15601 BeKTyMrM8FWn6ewb false NULL -41.87000006189896 NULL 10.175 36.0 -72.0 -72.0 2.43391201E8 -15601.0 1804756106 NULL -15601 3569 -15242.0 -15601 +NULL -1116090298 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 4E0UheoualijJ1rno false NULL -52.54600003827932 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 1116090298 NULL -15601 3569 -15242.0 -15601 +NULL 1821279179 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 yPUM0wC54vq true NULL 36.32300006246567 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 -1821279179 NULL -15601 3569 -15242.0 -15601 +NULL 2144325818 NULL NULL 37.0 15601.0 1969-12-31 15:59:58.456 15601 oa1y1r12hEdKmA4w5 true NULL 0.8540000735454214 NULL 10.175 -37.0 74.0 74.0 2.43391201E8 -15601.0 -2144325818 NULL -15601 3569 -15242.0 -15601 +NULL -1580362265 NULL NULL 3.0 15601.0 1969-12-31 15:59:58.456 15601 JfvDur75VQCb53GicM7hHU false NULL -75.12200005420277 NULL 1.1750000000000007 -3.0 6.0 6.0 2.43391201E8 -15601.0 1580362265 NULL -15601 3569 -15242.0 -15601 +NULL -1167276678 NULL NULL 23.0 15601.0 1969-12-31 15:59:58.456 15601 oBiXS80va7E5rq53LfrHc false NULL -43.52100004003489 NULL 10.175 -23.0 46.0 46.0 2.43391201E8 -15601.0 1167276678 NULL -15601 3569 -15242.0 -15601 +NULL 1890350821 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 1t0CR false NULL 24.732000064834665 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 -1890350821 NULL -15601 3569 -15242.0 -15601 +NULL 925773801 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 sdS2I16K47 true NULL 27.1650000317519 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 -925773801 NULL -15601 3569 -15242.0 -15601 +NULL 10989626 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 XQkXKeHtwH7 true NULL 15.474000000376918 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -10989626 NULL -15601 3569 -15242.0 -15601 +NULL -1374485693 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 17i12pGg4fpDVOekj5 false NULL -64.22300004714168 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 1374485693 NULL -15601 3569 -15242.0 -15601 +NULL -1483320156 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 k8rB7RO86AsDDepw60 true NULL -56.74800005087445 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 1483320156 NULL -15601 3569 -15242.0 -15601 +NULL -940198586 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 GT18w true NULL -23.54600003224664 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 940198586 NULL -15601 3569 -15242.0 -15601 +NULL -899534452 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 Cb4HG6630oxk51h5F3W true NULL -41.92000003085195 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 899534452 NULL -15601 3569 -15242.0 -15601 +NULL -1465907371 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 x8Vdk4Vsl true NULL -71.04700005027723 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1465907371 NULL -15601 3569 -15242.0 -15601 +NULL 158194463 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 XhyV0PF0kbo2yqP47G1M false NULL 60.8270000054257 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 -158194463 NULL -15601 3569 -15242.0 -15601 +NULL 2034207903 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 a8cwK0jI406n6LivfvcP true NULL 64.43100006976863 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -2034207903 NULL -15601 3569 -15242.0 -15601 +NULL -1984659810 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 ouvEtgD true NULL -45.974000068069245 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 1984659810 NULL -15601 3569 -15242.0 -15601 +NULL -1135974844 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 q4N35U8ebdYFbWTcy7R80vie false NULL -7.984000038961312 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 1135974844 NULL -15601 3569 -15242.0 -15601 +NULL -2101713482 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 bPAwotrXNs5fF false NULL -70.19800007208391 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 2101713482 NULL -15601 3569 -15242.0 -15601 +NULL -203039588 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 4J1YKqEsJ2K0e85FB1Q true NULL -45.98500000696379 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 203039588 NULL -15601 3569 -15242.0 -15601 +NULL 316688105 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 r2O6q8g1p18ES4 false NULL 22.26800001086167 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -316688105 NULL -15601 3569 -15242.0 -15601 +NULL 1385428226 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 54Q740CGYW4r2 true NULL 2.5200000475169873 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -1385428226 NULL -15601 3569 -15242.0 -15601 +NULL -685821373 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 6N24JhdOx8Uu368 false NULL -51.39200002352209 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 685821373 NULL -15601 3569 -15242.0 -15601 +NULL 1882977755 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 6l8L47 true NULL 10.325000064581786 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 -1882977755 NULL -15601 3569 -15242.0 -15601 +NULL 581431028 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 GA848dL72B2dOUfpVmG77J3F false NULL 28.07500001994174 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -581431028 NULL -15601 3569 -15242.0 -15601 +NULL 472680102 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 r5Q7Ki5d4St8Buc false NULL 41.900000016211834 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 -472680102 NULL -15601 3569 -15242.0 -15601 +NULL 1679050126 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 73l03Fiy5cx14fg false NULL 53.03200005758754 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 -1679050126 NULL -15601 3569 -15242.0 -15601 +NULL -285749156 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 iHH55 false NULL -30.498000009800535 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 285749156 NULL -15601 3569 -15242.0 -15601 +NULL -1332687894 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 v18H6O1bxd true NULL -47.847000045708114 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 1332687894 NULL -15601 3569 -15242.0 -15601 +NULL -585350546 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 TEM55fi2Ly true NULL -49.31800002007617 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 585350546 NULL -15601 3569 -15242.0 -15601 +NULL -605773050 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 3RW7h8mx1UYX true NULL -25.370000020776615 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 605773050 NULL -15601 3569 -15242.0 -15601 +NULL -1351910626 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 S25uia48N4 false NULL -70.24500004636741 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 1351910626 NULL -15601 3569 -15242.0 -15601 +NULL 47514726 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 hQM83QDS5L8bY5 true NULL 26.137000001629644 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 -47514726 NULL -15601 3569 -15242.0 -15601 +NULL 1445910023 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 38VIu8r35oI8LI false NULL 40.21000004959137 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 -1445910023 NULL -15601 3569 -15242.0 -15601 +NULL 1177275310 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 4i342tHD false NULL 56.71600004037782 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 -1177275310 NULL -15601 3569 -15242.0 -15601 +NULL -973905398 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 PN27a314v6PyUpVfeiU false NULL -70.3400000334027 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 973905398 NULL -15601 3569 -15242.0 -15601 +NULL -195941743 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 ABOL5huJ5V40JR7Xy5Jh0 true NULL -78.75100000672035 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 195941743 NULL -15601 3569 -15242.0 -15601 +NULL -865531893 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 uC52w58JMib287rYV2iQxtuF true NULL -26.180000029685743 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 865531893 NULL -15601 3569 -15242.0 -15601 +NULL -667436971 NULL NULL 33.0 15601.0 1969-12-31 15:59:58.456 15601 5684o66hD1A true NULL -29.480000022891545 NULL 10.175 -33.0 66.0 66.0 2.43391201E8 -15601.0 667436971 NULL -15601 3569 -15242.0 -15601 +NULL 73960976 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 vncNr2N4c8x6u3Cqu1DqtXaS true NULL 74.58200000253669 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 -73960976 NULL -15601 3569 -15242.0 -15601 +NULL -335617169 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 31Sc0dgiT2Ag83txo7 true NULL -6.789000011510893 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 335617169 NULL -15601 3569 -15242.0 -15601 +NULL 870739658 NULL NULL 51.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 13.141000029864358 NULL 10.175 -51.0 102.0 102.0 2.43391201E8 -15601.0 -870739658 NULL -15601 3569 -15242.0 -15601 +NULL -598490358 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 grEKOf2222N33T8L5 true NULL -12.755000020526836 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 598490358 NULL -15601 3569 -15242.0 -15601 +NULL -1850457201 NULL NULL -10.0 15601.0 1969-12-31 15:59:58.456 15601 lXHyAJ2cXsq false NULL -6.748000063466407 NULL 0.1750000000000007 10.0 -20.0 -20.0 2.43391201E8 -15601.0 1850457201 NULL -15601 3569 -15242.0 -15601 +NULL -1019007115 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 6C5K3WGc2laGctSI2m0o8 true NULL -9.52000003494959 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 1019007115 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 ObGm1w false NULL NULL NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -720023732 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 Q3mmj6mG4EG8H false NULL -29.99600002469515 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 720023732 NULL -15601 3569 -15242.0 -15601 +NULL -430689331 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 1Ic5OYcpB true NULL -49.10200001477165 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 430689331 NULL -15601 3569 -15242.0 -15601 +NULL 2006229754 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 VNQIHXp5B80I false NULL 69.10700006880904 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -2006229754 NULL -15601 3569 -15242.0 -15601 +NULL 439625822 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 jV5P8135DP5GhsEf4h663 false NULL 33.40000001507815 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 -439625822 NULL -15601 3569 -15242.0 -15601 +NULL -1373443946 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 4F7q027w true NULL -63.75800004710595 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 1373443946 NULL -15601 3569 -15242.0 -15601 +NULL -184458103 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 V10T8Fo0d5HOeEM8ysObmPU4 false NULL -73.40700000632648 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 184458103 NULL -15601 3569 -15242.0 -15601 +NULL -596103241 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 32XYGA7BOMTt27DGulBeUroc false NULL -42.62600002044496 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 596103241 NULL -15601 3569 -15242.0 -15601 +NULL 1198344254 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 PY216BgK57qkoktjrjHb true NULL 25.09000004110044 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 -1198344254 NULL -15601 3569 -15242.0 -15601 +NULL -1496666324 NULL NULL -24.0 15601.0 1969-12-31 15:59:58.456 15601 NmR21ryn0FG67 false NULL -15.703000051332197 NULL 10.175 24.0 -48.0 -48.0 2.43391201E8 -15601.0 1496666324 NULL -15601 3569 -15242.0 -15601 +NULL 108834881 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 Ms3HD0o false NULL 12.760000003732785 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 -108834881 NULL -15601 3569 -15242.0 -15601 +NULL 2102419786 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 wC6H8kVc true NULL 23.11100007210814 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -2102419786 NULL -15601 3569 -15242.0 -15601 +NULL 1783533015 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 eujfW true NULL 20.65700006117106 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 -1783533015 NULL -15601 3569 -15242.0 -15601 +NULL 2128559319 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 ij7x08sm2843itVwgj7N3e false NULL 31.371000073004666 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 -2128559319 NULL -15601 3569 -15242.0 -15601 +NULL -1331125878 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 KXy5w41XCCA8oA true NULL -55.00200004565454 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 1331125878 NULL -15601 3569 -15242.0 -15601 +NULL -1768316238 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 3E6lh2b7Mc5EAYo3 true NULL -61.94400006064916 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 1768316238 NULL -15601 3569 -15242.0 -15601 +NULL -83357142 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 loyP6f1P43IaIRV00agg60cM true NULL -76.64600000285895 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 83357142 NULL -15601 3569 -15242.0 -15601 +NULL -938739544 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 4AqO5U false NULL -63.119000032196595 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 938739544 NULL -15601 3569 -15242.0 -15601 +NULL -784264135 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 BTHM1wQ6nmd7i4D62 true NULL -33.09500002689845 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 784264135 NULL -15601 3569 -15242.0 -15601 +NULL -1227267053 NULL NULL -26.28 15601.0 1969-12-31 15:59:58.456 15601 agUv2kK6dL640BK87AcUjfg5 true NULL -58.09200004209242 NULL 10.175 26.28 -52.56 -52.56 2.43391201E8 -15601.0 1227267053 NULL -15601 3569 -15242.0 -15601 +NULL 693166929 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 gs80XR412vES71aqKHCGm false NULL 1.5840000237740242 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 -693166929 NULL -15601 3569 -15242.0 -15601 +NULL 364559164 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 YiKM5PHS02HelmT2C true NULL 63.518000012503535 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 -364559164 NULL -15601 3569 -15242.0 -15601 +NULL -1427685796 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 w6BpSHK2d0 false NULL -53.10900004896632 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1427685796 NULL -15601 3569 -15242.0 -15601 +NULL -977722732 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 f87y6Si4uQ83 false NULL -53.63500003353363 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 977722732 NULL -15601 3569 -15242.0 -15601 +NULL 707803275 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 We3u7Ih60iJx1U2kH false NULL 27.538000024276016 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -707803275 NULL -15601 3569 -15242.0 -15601 +NULL 989393728 NULL NULL -28.0 15601.0 1969-12-31 15:59:58.456 15601 41k5oTFUiu5nv false NULL 67.66400003393392 NULL 10.175 28.0 -56.0 -56.0 2.43391201E8 -15601.0 -989393728 NULL -15601 3569 -15242.0 -15601 +NULL 1076941933 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 q62wg16HA70PbEpwO3f1 true NULL 37.05800003693662 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 -1076941933 NULL -15601 3569 -15242.0 -15601 +NULL -605058422 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 Sr02RjVo6gEbKjr4Ftm0d false NULL -21.969000020752105 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 605058422 NULL -15601 3569 -15242.0 -15601 +NULL 1276990360 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 584i3Q7R5P65nCfCt30B true NULL 35.29000004379782 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -1276990360 NULL -15601 3569 -15242.0 -15601 +NULL 300682807 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 D8K4E6MSC6E1d7UlX7yS6o2 true NULL 71.89100001031272 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 -300682807 NULL -15601 3569 -15242.0 -15601 +NULL 1661516996 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 7vT82OOJ7VpT5J false NULL 6.467000056986194 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 -1661516996 NULL -15601 3569 -15242.0 -15601 +NULL -1214834730 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 sqvRW6DM80 false NULL -39.27300004166602 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 1214834730 NULL -15601 3569 -15242.0 -15601 +NULL -399793337 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 0Yo1dcEr7D57no22Tiv2TXR true NULL -53.712000013711986 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 399793337 NULL -15601 3569 -15242.0 -15601 +NULL 186460538 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 HCje0r5N3C0o3 true NULL 0.29100000639516566 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -186460538 NULL -15601 3569 -15242.0 -15601 +NULL 1621296717 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 24Brw6 true NULL 53.65400005560673 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -1621296717 NULL -15601 3569 -15242.0 -15601 +NULL -1465657206 NULL NULL 57.0 15601.0 1969-12-31 15:59:58.456 15601 67e72C1HvFm3G61s3E true NULL -20.679000050268655 NULL 10.175 -57.0 114.0 114.0 2.43391201E8 -15601.0 1465657206 NULL -15601 3569 -15242.0 -15601 +NULL -2076312756 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 J0I71XNHjvS8 false NULL -60.22700007121273 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 2076312756 NULL -15601 3569 -15242.0 -15601 +NULL 283135872 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 W5d6CKH false NULL 62.548000009710904 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -283135872 NULL -15601 3569 -15242.0 -15601 +NULL 137172603 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 w0726mEF62ra5M2qw1UI65 true NULL 1.5240000047047033 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 -137172603 NULL -15601 3569 -15242.0 -15601 +NULL -1474284078 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 D0EmwVYsS1R true NULL -6.253000050564538 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 1474284078 NULL -15601 3569 -15242.0 -15601 +NULL 1049949527 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 XP4nn8i47ipR3tsL4Bua true NULL 43.51100003601084 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -1049949527 NULL -15601 3569 -15242.0 -15601 +NULL 345752927 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 RO83j2qQsq7 true NULL 76.16500001185852 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 -345752927 NULL -15601 3569 -15242.0 -15601 +NULL -813809028 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 V74j2j3Pc8OY7tl true NULL -55.63700002791177 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 813809028 NULL -15601 3569 -15242.0 -15601 +NULL -185407727 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 gXNIvywTs1JChwJd41O3ep3 true NULL -73.24600000635905 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 185407727 NULL -15601 3569 -15242.0 -15601 +NULL -1011232927 NULL NULL 16.0 15601.0 1969-12-31 15:59:58.456 15601 p0si7X0L true NULL -58.89200003468295 NULL 10.175 -16.0 32.0 32.0 2.43391201E8 -15601.0 1011232927 NULL -15601 3569 -15242.0 -15601 +NULL -1795674990 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 qywFGFaaiBJ0QqJJM06JQro true NULL -59.9260000615875 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 1795674990 NULL -15601 3569 -15242.0 -15601 +NULL 1285310382 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 H85Or4yRdt4A1 true NULL 6.785000044083176 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 -1285310382 NULL -15601 3569 -15242.0 -15601 +NULL 2020504394 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 Syoe8Gm2 false NULL 36.99900006929863 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -2020504394 NULL -15601 3569 -15242.0 -15601 +NULL 235428680 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 6mWsAi false NULL 9.11800000807466 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 -235428680 NULL -15601 3569 -15242.0 -15601 +NULL 1296727292 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 1618frAK6kL true NULL 27.09600004447475 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 -1296727292 NULL -15601 3569 -15242.0 -15601 +NULL 271210320 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 GkRP5Gp6K6SFm5O21tX1U3 false NULL 62.119000009301885 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -271210320 NULL -15601 3569 -15242.0 -15601 +NULL 1846338753 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 260x8Lpv5ILXWEPxlog248di false NULL 17.558000063325153 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 -1846338753 NULL -15601 3569 -15242.0 -15601 +NULL 1194316702 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 VftK7455nP4C2fb42Guv7I0 true NULL 2.8210000409623035 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 -1194316702 NULL -15601 3569 -15242.0 -15601 +NULL 68492077 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 h8Ml5L58R2cjwL34NxK6CE0y true NULL 46.56700000234912 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 -68492077 NULL -15601 3569 -15242.0 -15601 +NULL 185641340 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 h83p28JMDN2Ox1a false NULL 39.08500000636707 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 -185641340 NULL -15601 3569 -15242.0 -15601 +NULL 1254134497 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 x82mv false NULL 67.40200004301391 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 -1254134497 NULL -15601 3569 -15242.0 -15601 +NULL -1322538563 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 IpDn22 false NULL -9.034000045360017 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 1322538563 NULL -15601 3569 -15242.0 -15601 +NULL -1735553309 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 TXaLgi3L562jI1 true NULL -1.8050000595254687 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 1735553309 NULL -15601 3569 -15242.0 -15601 +NULL 739625813 NULL NULL 33.0 15601.0 1969-12-31 15:59:58.456 15601 JEVyBv2IqG1xPJASdCL8 false NULL 13.137000025367456 NULL 10.175 -33.0 66.0 66.0 2.43391201E8 -15601.0 -739625813 NULL -15601 3569 -15242.0 -15601 +NULL -1016256928 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 7arS506d1YXayI false NULL -49.28300003485526 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 1016256928 NULL -15601 3569 -15242.0 -15601 +NULL 716349726 NULL NULL -50.0 15601.0 1969-12-31 15:59:58.456 15601 0Q7LP3644p true NULL 20.19500002456914 NULL 10.175 50.0 -100.0 -100.0 2.43391201E8 -15601.0 -716349726 NULL -15601 3569 -15242.0 -15601 +NULL 1105763794 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 ExDDp5f2lgt8O7VUcf12q81T true NULL 5.264000037925143 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 -1105763794 NULL -15601 3569 -15242.0 -15601 +NULL 1476533372 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 Q37LCWVlT8TkMm2f3h7j0d false NULL 18.731000050641683 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 -1476533372 NULL -15601 3569 -15242.0 -15601 +NULL -1784005728 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 56015OKS42DG3ju4KW0a558 true NULL -29.731000061187274 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 1784005728 NULL -15601 3569 -15242.0 -15601 +NULL -198456342 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 GLUkX0100q true NULL -7.421000006806594 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 198456342 NULL -15601 3569 -15242.0 -15601 +NULL -1224290649 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 T7YaUc10ta true NULL -50.03400004199034 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 1224290649 NULL -15601 3569 -15242.0 -15601 +NULL -1954992185 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 ldRTj2t54A6XCI3yDe6 false NULL -41.711000067051714 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 1954992185 NULL -15601 3569 -15242.0 -15601 +NULL 2082686808 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 fxhEtyu6d6bFhsfAV1132v false NULL 7.6550000714313455 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -2082686808 NULL -15601 3569 -15242.0 -15601 +NULL -484557615 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 4E1jb true NULL -53.341000016619205 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 484557615 NULL -15601 3569 -15242.0 -15601 +NULL 909613130 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 70.79700003119763 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 -909613130 NULL -15601 3569 -15242.0 -15601 +NULL 272368436 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 047TAc3t6f6rU8M7Dk7Gh8 false NULL 45.54500000934161 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 -272368436 NULL -15601 3569 -15242.0 -15601 +NULL -2030132877 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 10mF5gYR5Fey1vTEHx true NULL -61.303000069628865 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 2030132877 NULL -15601 3569 -15242.0 -15601 +NULL 1544127003 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 46cPsh false NULL 11.327000052959988 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 -1544127003 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 Lptx5Gx2Mw5PLl4hSL6T67F false NULL NULL NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL 862568803 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 8Vs552xiccF5j3n60 true NULL 46.771000029584116 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 -862568803 NULL -15601 3569 -15242.0 -15601 +NULL -1555938533 NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 Af3LT15L8Onw true NULL -68.7580000533651 NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 1555938533 NULL -15601 3569 -15242.0 -15601 +NULL 317708856 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 6WUSYOYu false NULL 28.72500001089668 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -317708856 NULL -15601 3569 -15242.0 -15601 +NULL -1293795844 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 66NbK5Ke true NULL -27.593000044374207 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 1293795844 NULL -15601 3569 -15242.0 -15601 +NULL -1551649760 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 8rt58A3QR04YRX4t false NULL -77.541000053218 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 1551649760 NULL -15601 3569 -15242.0 -15601 +NULL 357043363 NULL NULL -55.0 15601.0 1969-12-31 15:59:58.456 15601 BClgHeB true NULL 32.19300001224576 NULL 10.175 55.0 -110.0 -110.0 2.43391201E8 -15601.0 -357043363 NULL -15601 3569 -15242.0 -15601 +NULL 1563934122 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 26VAMx7 true NULL 24.387000053639326 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -1563934122 NULL -15601 3569 -15242.0 -15601 +NULL 172978219 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 Fo0lvObXB13uFiJ538N1I7EI true NULL 5.519000005932753 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -172978219 NULL -15601 3569 -15242.0 -15601 +NULL 1174850100 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 sr1R5q2 false NULL 19.921000040294643 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -1174850100 NULL -15601 3569 -15242.0 -15601 +NULL -414129290 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 Ma0cUc3gxu236hG false NULL -78.79400001420368 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 414129290 NULL -15601 3569 -15242.0 -15601 +NULL 1779870001 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 YN4su true NULL 24.542000061045428 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 -1779870001 NULL -15601 3569 -15242.0 -15601 +NULL 1450853557 NULL NULL -2.0 15601.0 1969-12-31 15:59:58.456 15601 5EBH67Oqi47O true NULL 71.23700004976092 NULL 0.1750000000000007 2.0 -4.0 -4.0 2.43391201E8 -15601.0 -1450853557 NULL -15601 3569 -15242.0 -15601 +NULL 248304930 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 mkmf53R3P true NULL 49.197000008516284 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -248304930 NULL -15601 3569 -15242.0 -15601 +NULL 796380856 NULL NULL -36.0 15601.0 1969-12-31 15:59:58.456 15601 GG48LXS1XF8 false NULL 36.66500002731402 NULL 10.175 36.0 -72.0 -72.0 2.43391201E8 -15601.0 -796380856 NULL -15601 3569 -15242.0 -15601 +NULL -1269033095 NULL NULL 3.0 15601.0 1969-12-31 15:59:58.456 15601 sx8uYo1 true NULL -59.1150000435249 NULL 1.1750000000000007 -3.0 6.0 6.0 2.43391201E8 -15601.0 1269033095 NULL -15601 3569 -15242.0 -15601 +NULL -1022657523 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 Ym27dR7t0Txx8Syq40cdvJD5 false NULL -48.56200003507479 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 1022657523 NULL -15601 3569 -15242.0 -15601 +NULL -1998625094 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 UG6g10Lb571g true NULL -39.48300006854822 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 1998625094 NULL -15601 3569 -15242.0 -15601 +NULL 1802490164 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 34ByCIyiD2b3RM true NULL 7.969000061821248 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 -1802490164 NULL -15601 3569 -15242.0 -15601 +NULL 570984089 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 2EgCJP76SeDBsFg6w false NULL 68.58800001958343 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -570984089 NULL -15601 3569 -15242.0 -15601 +NULL -1307656088 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 lFC3iu086i56F0RdO0l5Ff13 false NULL -70.61500004484958 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 1307656088 NULL -15601 3569 -15242.0 -15601 +NULL 492608996 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 1cySK1D066 false NULL 34.31700001689535 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 -492608996 NULL -15601 3569 -15242.0 -15601 +NULL -57200424 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 HmC2gaY true NULL -66.83400000196184 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 57200424 NULL -15601 3569 -15242.0 -15601 +NULL -1583014792 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 Qq1cBHJkF7A3y3v5crIN0fJ true NULL -66.44300005429375 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 1583014792 NULL -15601 3569 -15242.0 -15601 +NULL -1138394041 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 6U81A8U3S false NULL -77.80700003904428 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 1138394041 NULL -15601 3569 -15242.0 -15601 +NULL -27952228 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 nDiXC6k3TlMV4s4yI4k true NULL -8.602000000958697 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 27952228 NULL -15601 3569 -15242.0 -15601 +NULL -1061994141 NULL NULL 56.0 15601.0 1969-12-31 15:59:58.456 15601 465xOUe8A4186sH true NULL -15.099000036423945 NULL 10.175 -56.0 112.0 112.0 2.43391201E8 -15601.0 1061994141 NULL -15601 3569 -15242.0 -15601 +NULL -532238997 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 W6w0xHjP false NULL -71.94300001825457 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 532238997 NULL -15601 3569 -15242.0 -15601 +NULL 1056441941 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 DBTgG3H false NULL 57.628000036233516 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 -1056441941 NULL -15601 3569 -15242.0 -15601 +NULL -1177680836 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 ABv6FN1qbww204XIw3Pk32nF false NULL -21.52200004039173 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 1177680836 NULL -15601 3569 -15242.0 -15601 +NULL 1771152988 NULL NULL -22.0 15601.0 1969-12-31 15:59:58.456 15601 o0661U81SWA01xgg60U false NULL 31.517000060746454 NULL 10.175 22.0 -44.0 -44.0 2.43391201E8 -15601.0 -1771152988 NULL -15601 3569 -15242.0 -15601 +NULL -546830045 NULL NULL -51.0 15601.0 1969-12-31 15:59:58.456 15601 wYhPSR false NULL -65.554000018755 NULL 10.175 51.0 -102.0 -102.0 2.43391201E8 -15601.0 546830045 NULL -15601 3569 -15242.0 -15601 +NULL -429050254 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 1Rnl53uFEkUaP567 true NULL -2.5610000147154324 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 429050254 NULL -15601 3569 -15242.0 -15601 +NULL 1556590849 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 Jto1Ej2BS true NULL 50.15800005338747 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 -1556590849 NULL -15601 3569 -15242.0 -15601 +NULL -400080827 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 V3L2j5d3q true NULL -39.17000001372185 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 400080827 NULL -15601 3569 -15242.0 -15601 +NULL 505524678 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 IYlXj3xg true NULL 48.10800001733833 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -505524678 NULL -15601 3569 -15242.0 -15601 +NULL 1428011023 NULL NULL 60.0 15601.0 1969-12-31 15:59:58.456 15601 Y20HmnH71A88V4 false NULL 67.44500004897748 NULL 10.175 -60.0 120.0 120.0 2.43391201E8 -15601.0 -1428011023 NULL -15601 3569 -15242.0 -15601 +NULL -2050820665 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 BBP8rjueJ6qT2UgiU51yh false NULL -12.10000007033841 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 2050820665 NULL -15601 3569 -15242.0 -15601 +NULL 988888 NULL NULL -25.0 15601.0 1969-12-31 15:59:58.456 15601 GWyjg3VFq1 true NULL 44.210000000033915 NULL 10.175 25.0 -50.0 -50.0 2.43391201E8 -15601.0 -988888 NULL -15601 3569 -15242.0 -15601 +NULL 956522842 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 S731TWfDrNnVe8p2yuE1k true NULL 3.9460000328065234 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -956522842 NULL -15601 3569 -15242.0 -15601 +NULL 1375317436 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 ju7I6y6dlU32rKY6Qogs true NULL 1.0550000471702106 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -1375317436 NULL -15601 3569 -15242.0 -15601 +NULL -911417577 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 OgJ3DltBHB87rMQt2d true NULL -17.098000031259517 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 911417577 NULL -15601 3569 -15242.0 -15601 +NULL -1493703726 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 7adFqAqlKXtTQ true NULL -50.976000051230585 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 1493703726 NULL -15601 3569 -15242.0 -15601 +NULL -1456078486 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 vG75G1Dg0ssHUX true NULL -38.75000004994013 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 1456078486 NULL -15601 3569 -15242.0 -15601 +NULL 829192702 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 3uojQvrD6m41To false NULL 9.156000028439394 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 -829192702 NULL -15601 3569 -15242.0 -15601 +NULL -1711666077 NULL NULL 54.0 15601.0 1969-12-31 15:59:58.456 15601 8367JQap6U744J2 true NULL -69.56200005870619 NULL 10.175 -54.0 108.0 108.0 2.43391201E8 -15601.0 1711666077 NULL -15601 3569 -15242.0 -15601 +NULL 1551262646 NULL NULL 52.0 15601.0 1969-12-31 15:59:58.456 15601 0ltFl7 false NULL 68.43900005320472 NULL 10.175 -52.0 104.0 104.0 2.43391201E8 -15601.0 -1551262646 NULL -15601 3569 -15242.0 -15601 +NULL -590153501 NULL NULL -17.0 15601.0 1969-12-31 15:59:58.456 15601 2uvcn0tEsP42wySb0LWC875U false NULL -71.4960000202409 NULL 10.175 17.0 -34.0 -34.0 2.43391201E8 -15601.0 590153501 NULL -15601 3569 -15242.0 -15601 +NULL 682869093 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 6ej7IPl1axJbEoLTlQd2V true NULL 62.77500002342083 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 -682869093 NULL -15601 3569 -15242.0 -15601 +NULL 788564623 NULL NULL 18.0 15601.0 1969-12-31 15:59:58.456 15601 o60nD06BYR6GlAE7w3E0rMAu false NULL 45.02100002704594 NULL 10.175 -18.0 36.0 36.0 2.43391201E8 -15601.0 -788564623 NULL -15601 3569 -15242.0 -15601 +NULL 595414579 NULL NULL -12.0 15601.0 1969-12-31 15:59:58.456 15601 Ek2sC17CCXFw1Fdq1c3N7o1 true NULL 70.94700002042134 NULL 10.175 12.0 -24.0 -24.0 2.43391201E8 -15601.0 -595414579 NULL -15601 3569 -15242.0 -15601 +NULL -1714949058 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 I7MI02kTvL36N true NULL -57.35800005881879 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 1714949058 NULL -15601 3569 -15242.0 -15601 +NULL -941884962 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 00d5kr1wEB7evExG false NULL -35.05200003230448 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 941884962 NULL -15601 3569 -15242.0 -15601 +NULL 1521898163 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 N887uW7KRb6LMp true NULL 29.69300005219759 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -1521898163 NULL -15601 3569 -15242.0 -15601 +NULL 1903410305 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 BR5F00 false NULL 8.699000065282576 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -1903410305 NULL -15601 3569 -15242.0 -15601 +NULL 946637795 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 En0gIyb3UWw7Bg5Cs false NULL 53.62000003246749 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 -946637795 NULL -15601 3569 -15242.0 -15601 +NULL 2066094917 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 VHe5j0T1o21J806LMb8ay1 true NULL 8.547000070862282 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 -2066094917 NULL -15601 3569 -15242.0 -15601 +NULL 504525087 NULL NULL -3.0 15601.0 1969-12-31 15:59:58.456 15601 PJoW4 true NULL 40.55300001730404 NULL 1.1750000000000007 3.0 -6.0 -6.0 2.43391201E8 -15601.0 -504525087 NULL -15601 3569 -15242.0 -15601 +NULL 1976926280 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 to2uhdoY5 false NULL 22.210000067804003 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 -1976926280 NULL -15601 3569 -15242.0 -15601 +NULL 627141836 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 71w84QYjROpI1LRs true NULL 0.48700002150951605 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 -627141836 NULL -15601 3569 -15242.0 -15601 +NULL 79643966 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 4c7SDx6WePBLWjdjH1o7ix true NULL 36.9210000027316 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 -79643966 NULL -15601 3569 -15242.0 -15601 +NULL 850073759 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 d04EJ6630g678OmO true NULL 74.26900002915556 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -850073759 NULL -15601 3569 -15242.0 -15601 +NULL 1921019802 NULL NULL 2.0 15601.0 1969-12-31 15:59:58.456 15601 CvUplJQ5P60W8 false NULL 51.38400006588654 NULL 0.1750000000000007 -2.0 4.0 4.0 2.43391201E8 -15601.0 -1921019802 NULL -15601 3569 -15242.0 -15601 +NULL -1985550487 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 egIrkAh2Omq true NULL -47.58600006809979 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 1985550487 NULL -15601 3569 -15242.0 -15601 +NULL -991138235 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 w4HVGo true NULL -56.92700003399375 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 991138235 NULL -15601 3569 -15242.0 -15601 +NULL -1022679553 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 E2Kbx50LJ7amwF true NULL -42.381000035075544 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 1022679553 NULL -15601 3569 -15242.0 -15601 +NULL -1040843741 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 74B2Y5Q false NULL -52.997000035698534 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 1040843741 NULL -15601 3569 -15242.0 -15601 +NULL 1582500035 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 IMC05lv4PYLJb2n3r7T false NULL 17.353000054276094 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 -1582500035 NULL -15601 3569 -15242.0 -15601 +NULL 509177858 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 PEBBi false NULL 74.79500001746362 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 -509177858 NULL -15601 3569 -15242.0 -15601 +NULL 1524488145 NULL NULL -16.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 4.672000052286421 NULL 10.175 16.0 -32.0 -32.0 2.43391201E8 -15601.0 -1524488145 NULL -15601 3569 -15242.0 -15601 +NULL -1044215393 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 0JA4aw00Rkv1mSy false NULL -10.198000035814175 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 1044215393 NULL -15601 3569 -15242.0 -15601 +NULL 1563271651 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 p55PrkpmAH2888xC062b2wp8 true NULL 70.7710000536166 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 -1563271651 NULL -15601 3569 -15242.0 -15601 +NULL -1621359391 NULL NULL -8.0 15601.0 1969-12-31 15:59:58.456 15601 kVvF7P51a2r2Vy54nHf false NULL -39.89000005560888 NULL 2.1750000000000007 8.0 -16.0 -16.0 2.43391201E8 -15601.0 1621359391 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 1L2401UOQ236aqX6dCr404H true NULL NULL NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -994591123 NULL NULL -35.0 15601.0 1969-12-31 15:59:58.456 15601 YaD841mDwJGjwjRgGtNU2 false NULL -26.515000034112177 NULL 10.175 35.0 -70.0 -70.0 2.43391201E8 -15601.0 994591123 NULL -15601 3569 -15242.0 -15601 +NULL -2074134645 NULL NULL -52.0 15601.0 1969-12-31 15:59:58.456 15601 mLOwRXI true NULL -30.814000071138025 NULL 10.175 52.0 -104.0 -104.0 2.43391201E8 -15601.0 2074134645 NULL -15601 3569 -15242.0 -15601 +NULL -1560616588 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 OI5Fo true NULL -9.593000053525543 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 1560616588 NULL -15601 3569 -15242.0 -15601 +NULL -51344670 NULL NULL 26.0 15601.0 1969-12-31 15:59:58.456 15601 nP1eLkf6WdqFIHYkf false NULL -50.058000001761 NULL 10.175 -26.0 52.0 52.0 2.43391201E8 -15601.0 51344670 NULL -15601 3569 -15242.0 -15601 +NULL 1915758648 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 3a6E43HeD false NULL 55.486000065706094 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 -1915758648 NULL -15601 3569 -15242.0 -15601 +NULL -1040575969 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 KV5evP72y5O6w7j true NULL -56.39500003568935 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 1040575969 NULL -15601 3569 -15242.0 -15601 +NULL -912039001 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 4P1l3UF37p8CvAKi5qA false NULL -52.61500003128083 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 912039001 NULL -15601 3569 -15242.0 -15601 +NULL -1841324115 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 mEvlGNpu6yd1t false NULL -2.913000063153163 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 1841324115 NULL -15601 3569 -15242.0 -15601 +NULL 208571945 NULL NULL 27.0 15601.0 1969-12-31 15:59:58.456 15601 375tWcaL false NULL 48.706000007153534 NULL 10.175 -27.0 54.0 54.0 2.43391201E8 -15601.0 -208571945 NULL -15601 3569 -15242.0 -15601 +NULL -170140038 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 fxw1oB07EpNBYU36mq8k8e true NULL -36.90000000583541 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 170140038 NULL -15601 3569 -15242.0 -15601 +NULL 972217430 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 yoiKbhYl2DdJj6AQp2vL3Hl1 false NULL 57.89400003334481 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -972217430 NULL -15601 3569 -15242.0 -15601 +NULL -1931941399 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 sPq2s6pTnY8d6D1s00 true NULL -55.673000066261125 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 1931941399 NULL -15601 3569 -15242.0 -15601 +NULL -1954298743 NULL NULL 14.0 15601.0 1969-12-31 15:59:58.456 15601 8NgNgkpB06N7bMGgBs5QJ true NULL -63.21200006702793 NULL 10.175 -14.0 28.0 28.0 2.43391201E8 -15601.0 1954298743 NULL -15601 3569 -15242.0 -15601 +NULL 1575089695 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 ss true NULL 39.303000054021936 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 -1575089695 NULL -15601 3569 -15242.0 -15601 +NULL 1419034476 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 FGD08uu4La5qPEl false NULL 42.3060000486696 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 -1419034476 NULL -15601 3569 -15242.0 -15601 +NULL 1405133773 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 rVv1m2DknKVOS1l8T false NULL 32.76100004819284 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 -1405133773 NULL -15601 3569 -15242.0 -15601 +NULL 1511977977 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 i0022dNCj10c55 true NULL 23.24000005185735 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -1511977977 NULL -15601 3569 -15242.0 -15601 +NULL -839522912 NULL NULL 49.0 15601.0 1969-12-31 15:59:58.456 15601 km0o6S5JL67K false NULL -23.447000028793695 NULL 10.175 -49.0 98.0 98.0 2.43391201E8 -15601.0 839522912 NULL -15601 3569 -15242.0 -15601 +NULL 1518898051 NULL NULL 11.0 15601.0 1969-12-31 15:59:58.456 15601 Gs7PDk false NULL 20.429000052094693 NULL 10.175 -11.0 22.0 22.0 2.43391201E8 -15601.0 -1518898051 NULL -15601 3569 -15242.0 -15601 +NULL 53656310 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 XgGvxqJL7ioDnQ4Bue6spR true NULL 38.984000001840286 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 -53656310 NULL -15601 3569 -15242.0 -15601 +NULL -2052415815 NULL NULL 29.0 15601.0 1969-12-31 15:59:58.456 15601 70CwR7G80qU0a true NULL -44.89700007039312 NULL 10.175 -29.0 58.0 58.0 2.43391201E8 -15601.0 2052415815 NULL -15601 3569 -15242.0 -15601 +NULL 299090584 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 70Kvn2dL1ONDAGv22fni5S true NULL 22.633000010258115 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 -299090584 NULL -15601 3569 -15242.0 -15601 +NULL 347970254 NULL NULL 25.0 15601.0 1969-12-31 15:59:58.456 15601 glh68j4RvL7l36QVT false NULL 22.396000011934575 NULL 10.175 -25.0 50.0 50.0 2.43391201E8 -15601.0 -347970254 NULL -15601 3569 -15242.0 -15601 +NULL 299342203 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 5DJnb false NULL 15.494000010266745 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -299342203 NULL -15601 3569 -15242.0 -15601 +NULL 954086950 NULL NULL 31.0 15601.0 1969-12-31 15:59:58.456 15601 348A6IBn true NULL 24.806000032722977 NULL 10.175 -31.0 62.0 62.0 2.43391201E8 -15601.0 -954086950 NULL -15601 3569 -15242.0 -15601 +NULL 923495645 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 8fhS6JqUfN true NULL 30.426000031673766 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -923495645 NULL -15601 3569 -15242.0 -15601 +NULL -1423925704 NULL NULL 62.0 15601.0 1969-12-31 15:59:58.456 15601 gI3E65J true NULL -33.65400004883736 NULL 10.175 -62.0 124.0 124.0 2.43391201E8 -15601.0 1423925704 NULL -15601 3569 -15242.0 -15601 +NULL -1152127938 NULL NULL -27.0 15601.0 1969-12-31 15:59:58.456 15601 QrFWcQo7 true NULL -24.440000039515326 NULL 10.175 27.0 -54.0 -54.0 2.43391201E8 -15601.0 1152127938 NULL -15601 3569 -15242.0 -15601 +NULL -191560572 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 Gk6NYea0882752C true NULL -50.56700000657008 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 191560572 NULL -15601 3569 -15242.0 -15601 +NULL 1329082102 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 5t0xD81bv100c5Tsy0T true NULL 75.12500004558444 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -1329082102 NULL -15601 3569 -15242.0 -15601 +NULL -748476723 NULL NULL 34.0 15601.0 1969-12-31 15:59:58.456 15601 eVHNH83v12dU1vT43JUO4u true NULL -15.463000025671022 NULL 10.175 -34.0 68.0 68.0 2.43391201E8 -15601.0 748476723 NULL -15601 3569 -15242.0 -15601 +NULL -1864500604 NULL NULL -32.0 15601.0 1969-12-31 15:59:58.456 15601 Vt166H6HUcc true NULL -77.76400006394806 NULL 10.175 32.0 -64.0 -64.0 2.43391201E8 -15601.0 1864500604 NULL -15601 3569 -15242.0 -15601 +NULL 1619226365 NULL NULL -45.0 15601.0 1969-12-31 15:59:58.456 15601 PIKnd8tj154 false NULL 68.47900005553572 NULL 10.175 45.0 -90.0 -90.0 2.43391201E8 -15601.0 -1619226365 NULL -15601 3569 -15242.0 -15601 +NULL 2049798602 NULL NULL 53.0 15601.0 1969-12-31 15:59:58.456 15601 y3V0I7K6621nUG3p684bL3N false NULL 46.044000070303355 NULL 10.175 -53.0 106.0 106.0 2.43391201E8 -15601.0 -2049798602 NULL -15601 3569 -15242.0 -15601 +NULL 292020569 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 dcd7gQLSqn5XP4rsnYU true NULL 41.84900001001563 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 -292020569 NULL -15601 3569 -15242.0 -15601 +NULL 1477993160 NULL NULL 6.0 15601.0 1969-12-31 15:59:58.456 15601 xukgs2431agM true NULL 9.18100005069175 NULL 4.175000000000001 -6.0 12.0 12.0 2.43391201E8 -15601.0 -1477993160 NULL -15601 3569 -15242.0 -15601 +NULL -1620061206 NULL NULL 9.0 15601.0 1969-12-31 15:59:58.456 15601 8R8xyd522O4QL6chM true NULL -0.7440000555643564 NULL 1.1750000000000007 -9.0 18.0 18.0 2.43391201E8 -15601.0 1620061206 NULL -15601 3569 -15242.0 -15601 +NULL -1198622822 NULL NULL 35.0 15601.0 1969-12-31 15:59:58.456 15601 LrcpM true NULL -78.03700004110999 NULL 10.175 -35.0 70.0 70.0 2.43391201E8 -15601.0 1198622822 NULL -15601 3569 -15242.0 -15601 +NULL -1530632114 NULL NULL 40.0 15601.0 1969-12-31 15:59:58.456 15601 x404cgW015e278SIh2J4Jx5 false NULL -15.929000052497145 NULL 10.175 -40.0 80.0 80.0 2.43391201E8 -15601.0 1530632114 NULL -15601 3569 -15242.0 -15601 +NULL 68899019 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 MO74jra6B1534xeWwCNp0k5 true NULL 74.97200000236307 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 -68899019 NULL -15601 3569 -15242.0 -15601 +NULL -786134704 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 1Ewed8Vw3iVfeeaXWE2g7 false NULL -72.4060000269626 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 786134704 NULL -15601 3569 -15242.0 -15601 +NULL -1003335119 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 uyj5fb5NgLKRxm64xa true NULL -34.073000034412075 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 1003335119 NULL -15601 3569 -15242.0 -15601 +NULL -1972121622 NULL NULL 1.0 15601.0 1969-12-31 15:59:58.456 15601 Hu8U10iq3 false NULL -47.198000067639214 NULL 0.1750000000000007 -1.0 2.0 2.0 2.43391201E8 -15601.0 1972121622 NULL -15601 3569 -15242.0 -15601 +NULL 1100120303 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 t5QJyAQ5JT615S8083 false NULL 4.084000037731585 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -1100120303 NULL -15601 3569 -15242.0 -15601 +NULL -1683701844 NULL NULL -56.0 15601.0 1969-12-31 15:59:58.456 15601 5SVe8AEjY848Rf true NULL -68.46300005774708 NULL 10.175 56.0 -112.0 -112.0 2.43391201E8 -15601.0 1683701844 NULL -15601 3569 -15242.0 -15601 +NULL 68454489 NULL NULL 7.0 15601.0 1969-12-31 15:59:58.456 15601 AaqE4i62EBu0EEc0j true NULL 7.583000002347831 NULL 3.1750000000000007 -7.0 14.0 14.0 2.43391201E8 -15601.0 -68454489 NULL -15601 3569 -15242.0 -15601 +NULL -1377611623 NULL NULL 61.0 15601.0 1969-12-31 15:59:58.456 15601 k7kkwRm6KDn1pu false NULL -38.641000047248895 NULL 10.175 -61.0 122.0 122.0 2.43391201E8 -15601.0 1377611623 NULL -15601 3569 -15242.0 -15601 +NULL -2040027963 NULL NULL 51.0 15601.0 1969-12-31 15:59:58.456 15601 428fBlpfi false NULL -26.951000069968245 NULL 10.175 -51.0 102.0 102.0 2.43391201E8 -15601.0 2040027963 NULL -15601 3569 -15242.0 -15601 +NULL -41530125 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 56ac8 false NULL -38.221000001424386 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 41530125 NULL -15601 3569 -15242.0 -15601 +NULL 1755717265 NULL NULL 61.0 15601.0 1969-12-31 15:59:58.456 15601 yF3Fvo76H6kIpv false NULL 56.660000060217044 NULL 10.175 -61.0 122.0 122.0 2.43391201E8 -15601.0 -1755717265 NULL -15601 3569 -15242.0 -15601 +NULL -1556827241 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 12gbSP4px465TdXmV5F2apmC true NULL -10.642000053395577 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 1556827241 NULL -15601 3569 -15242.0 -15601 +NULL 1825963236 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 uWU0etU5Unl true NULL 12.68300006262632 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 -1825963236 NULL -15601 3569 -15242.0 -15601 +NULL 1492034515 NULL NULL 50.0 15601.0 1969-12-31 15:59:58.456 15601 uKtGKE3Bao0o6k06 false NULL 21.022000051173336 NULL 10.175 -50.0 100.0 100.0 2.43391201E8 -15601.0 -1492034515 NULL -15601 3569 -15242.0 -15601 +NULL 1247409916 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 ki4RR7535 false NULL 21.939000042783277 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 -1247409916 NULL -15601 3569 -15242.0 -15601 +NULL -1809291815 NULL NULL -64.0 15601.0 1969-12-31 15:59:58.456 15601 1G71L true NULL -36.57500006205453 NULL 10.175 64.0 -128.0 -128.0 2.43391201E8 -15601.0 1809291815 NULL -15601 3569 -15242.0 -15601 +NULL 37567484 NULL NULL -27.0 15601.0 1969-12-31 15:59:58.456 15601 UVo71u40can1RQJ0MTNPS true NULL 11.704000001288478 NULL 10.175 27.0 -54.0 -54.0 2.43391201E8 -15601.0 -37567484 NULL -15601 3569 -15242.0 -15601 +NULL 701594431 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 2wgGraY3CIxDy8AxH3um15GE true NULL 56.529000024063066 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -701594431 NULL -15601 3569 -15242.0 -15601 +NULL 847428763 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 r5C4tqIkrKj0yc false NULL 56.41300002906485 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 -847428763 NULL -15601 3569 -15242.0 -15601 +NULL 333141293 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 3I6hScTcbL false NULL 58.808000011425975 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 -333141293 NULL -15601 3569 -15242.0 -15601 +NULL -1730738390 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 K3DGd0 false NULL -28.130000059360327 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 1730738390 NULL -15601 3569 -15242.0 -15601 +NULL -2030835158 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 C53Tn5 true NULL -48.41900006965295 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 2030835158 NULL -15601 3569 -15242.0 -15601 +NULL 625462718 NULL NULL -46.0 15601.0 1969-12-31 15:59:58.456 15601 pX43VuW10c4 true NULL 7.658000021451926 NULL 10.175 46.0 -92.0 -92.0 2.43391201E8 -15601.0 -625462718 NULL -15601 3569 -15242.0 -15601 +NULL 1638071199 NULL NULL 20.0 15601.0 1969-12-31 15:59:58.456 15601 IAFkV5cK0Jh10Im806u true NULL 69.62700005618206 NULL 10.175 -20.0 40.0 40.0 2.43391201E8 -15601.0 -1638071199 NULL -15601 3569 -15242.0 -15601 +NULL 701736845 NULL NULL -30.0 15601.0 1969-12-31 15:59:58.456 15601 66O6v0Vf6jvnQs2Ps62hYr4 false NULL 70.65900002406795 NULL 10.175 30.0 -60.0 -60.0 2.43391201E8 -15601.0 -701736845 NULL -15601 3569 -15242.0 -15601 +NULL -1138820207 NULL NULL -38.0 15601.0 1969-12-31 15:59:58.456 15601 V37l2corMwuEU0F2I4R false NULL -78.3860000390589 NULL 10.175 38.0 -76.0 -76.0 2.43391201E8 -15601.0 1138820207 NULL -15601 3569 -15242.0 -15601 +NULL -1512449609 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 y8iXg77amSjODxsCQD3u1 true NULL -65.05600005187353 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 1512449609 NULL -15601 3569 -15242.0 -15601 +NULL -216777441 NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 54gc6c4vFnE7BduQcdm true NULL -50.521000007434964 NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 216777441 NULL -15601 3569 -15242.0 -15601 +NULL -795361000 NULL NULL 48.0 15601.0 1969-12-31 15:59:58.456 15601 qU5j6JSxVJ218 true NULL -50.12500002727904 NULL 10.175 -48.0 96.0 96.0 2.43391201E8 -15601.0 795361000 NULL -15601 3569 -15242.0 -15601 +NULL -1726415169 NULL NULL -62.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL -35.36200005921205 NULL 10.175 62.0 -124.0 -124.0 2.43391201E8 -15601.0 1726415169 NULL -15601 3569 -15242.0 -15601 +NULL 1265051089 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 yqXw7J7 true NULL 78.53000004338833 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 -1265051089 NULL -15601 3569 -15242.0 -15601 +NULL 2129132384 NULL NULL -39.0 15601.0 1969-12-31 15:59:58.456 15601 32gboqrESN35shM21v4Y true NULL 76.11200007302432 NULL 10.175 39.0 -78.0 -78.0 2.43391201E8 -15601.0 -2129132384 NULL -15601 3569 -15242.0 -15601 +NULL -652336471 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 1geCYToEJ2C true NULL -41.28100002237363 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 652336471 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL -9.0 15601.0 1969-12-31 15:59:58.456 15601 NaTC1s58bEK true NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -1666377780 NULL NULL -48.0 15601.0 1969-12-31 15:59:58.456 15601 iHV8CyE3682 true NULL -22.614000057152907 NULL 10.175 48.0 -96.0 -96.0 2.43391201E8 -15601.0 1666377780 NULL -15601 3569 -15242.0 -15601 +NULL -1864716928 NULL NULL -23.0 15601.0 1969-12-31 15:59:58.456 15601 1J2G60o false NULL -17.604000063955482 NULL 10.175 23.0 -46.0 -46.0 2.43391201E8 -15601.0 1864716928 NULL -15601 3569 -15242.0 -15601 +NULL -264600574 NULL NULL -21.0 15601.0 1969-12-31 15:59:58.456 15601 ob3uQu6g true NULL -56.677000009075186 NULL 10.175 21.0 -42.0 -42.0 2.43391201E8 -15601.0 264600574 NULL -15601 3569 -15242.0 -15601 +NULL 270402394 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 wH3XC3mR8UyM5Mh2jew5r0i3 true NULL 76.38700000927417 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 -270402394 NULL -15601 3569 -15242.0 -15601 +NULL -780348314 NULL NULL 44.0 15601.0 1969-12-31 15:59:58.456 15601 LLeNMJ3ml true NULL -49.41400002676414 NULL 10.175 -44.0 88.0 88.0 2.43391201E8 -15601.0 780348314 NULL -15601 3569 -15242.0 -15601 +NULL 1114673625 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 I0S8mgt10Gm true NULL 59.37000003823073 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 -1114673625 NULL -15601 3569 -15242.0 -15601 +NULL -1043251982 NULL NULL 10.0 15601.0 1969-12-31 15:59:58.456 15601 0ORX152g18fL0nI10TVqI false NULL -65.58100003578113 NULL 0.1750000000000007 -10.0 20.0 20.0 2.43391201E8 -15601.0 1043251982 NULL -15601 3569 -15242.0 -15601 +NULL -590921449 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 ApHibcqSn8Oo335QmfLfWnYF false NULL -14.83400002026724 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 590921449 NULL -15601 3569 -15242.0 -15601 +NULL -338704173 NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 8I7242Peq34tib true NULL -36.17700001161677 NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 338704173 NULL -15601 3569 -15242.0 -15601 +NULL -304247740 NULL NULL -57.0 15601.0 1969-12-31 15:59:58.456 15601 30abVOkSw false NULL -75.85500001043499 NULL 10.175 57.0 -114.0 -114.0 2.43391201E8 -15601.0 304247740 NULL -15601 3569 -15242.0 -15601 +NULL 98841361 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 7rem6u7WK00EsD1mq6gp80 false NULL 20.17300000339003 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -98841361 NULL -15601 3569 -15242.0 -15601 +NULL 1592489073 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 74YmI3NrkE60Skh0247Cef false NULL 62.461000054618694 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 -1592489073 NULL -15601 3569 -15242.0 -15601 +NULL 676428086 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 3Uyh75B8Qwn false NULL 64.42000002319992 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -676428086 NULL -15601 3569 -15242.0 -15601 +NULL 1533958255 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 Dk66H false NULL 45.99900005261122 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 -1533958255 NULL -15601 3569 -15242.0 -15601 +NULL 1990160147 NULL NULL 22.0 15601.0 1969-12-31 15:59:58.456 15601 puCW22aWIxS62h1S1eK6sJ true NULL 9.001000068257895 NULL 10.175 -22.0 44.0 44.0 2.43391201E8 -15601.0 -1990160147 NULL -15601 3569 -15242.0 -15601 +NULL -1568412240 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 42egcL8i65 false NULL -24.464000053792915 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 1568412240 NULL -15601 3569 -15242.0 -15601 +NULL 1139675920 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 Ftd0f531WF17cjTI2O true NULL 39.76500003908825 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 -1139675920 NULL -15601 3569 -15242.0 -15601 +NULL -480294523 NULL NULL -41.0 15601.0 1969-12-31 15:59:58.456 15601 5fTGTHvaK true NULL -47.50500001647299 NULL 10.175 41.0 -82.0 -82.0 2.43391201E8 -15601.0 480294523 NULL -15601 3569 -15242.0 -15601 +NULL 543831209 NULL NULL -59.0 15601.0 1969-12-31 15:59:58.456 15601 7KGMko8S5y3g5jq true NULL 59.44200001865215 NULL 10.175 59.0 -118.0 -118.0 2.43391201E8 -15601.0 -543831209 NULL -15601 3569 -15242.0 -15601 +NULL -1879970002 NULL NULL 12.0 15601.0 1969-12-31 15:59:58.456 15601 m2a017XH0R4dO4rThho true NULL -76.70200006447863 NULL 10.175 -12.0 24.0 24.0 2.43391201E8 -15601.0 1879970002 NULL -15601 3569 -15242.0 -15601 +NULL 419609353 NULL NULL -15.0 15601.0 1969-12-31 15:59:58.456 15601 Sfe4pA7B3f5x false NULL 53.83600001439163 NULL 10.175 15.0 -30.0 -30.0 2.43391201E8 -15601.0 -419609353 NULL -15601 3569 -15242.0 -15601 +NULL 1778089631 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 0vC4nYJsnNgXvL5 false NULL 50.682000060984365 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -1778089631 NULL -15601 3569 -15242.0 -15601 +NULL -1220505630 NULL NULL 47.0 15601.0 1969-12-31 15:59:58.456 15601 3STg8jD7jqGBM52TjVsB46Ab false NULL -3.668000041860523 NULL 10.175 -47.0 94.0 94.0 2.43391201E8 -15601.0 1220505630 NULL -15601 3569 -15242.0 -15601 +NULL -933775134 NULL NULL -42.0 15601.0 1969-12-31 15:59:58.456 15601 85i7Iq6mS56rOtT28bhNjy false NULL -78.53100003202633 NULL 10.175 42.0 -84.0 -84.0 2.43391201E8 -15601.0 933775134 NULL -15601 3569 -15242.0 -15601 +NULL 1981706992 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 45ehHO1 true NULL 76.22800006796797 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 -1981706992 NULL -15601 3569 -15242.0 -15601 +NULL -1575589254 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 I086Kg80pX true NULL -5.463000054039071 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 1575589254 NULL -15601 3569 -15242.0 -15601 +NULL 1179505870 NULL NULL -13.0 15601.0 1969-12-31 15:59:58.456 15601 Ubb7l false NULL 30.149000040454325 NULL 10.175 13.0 -26.0 -26.0 2.43391201E8 -15601.0 -1179505870 NULL -15601 3569 -15242.0 -15601 +NULL 473839931 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 3g5v51lNv true NULL 67.71300001625161 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -473839931 NULL -15601 3569 -15242.0 -15601 +NULL 1524423680 NULL NULL 38.0 15601.0 1969-12-31 15:59:58.456 15601 7QuAXV6VYT7q false NULL 57.15500005228421 NULL 10.175 -38.0 76.0 76.0 2.43391201E8 -15601.0 -1524423680 NULL -15601 3569 -15242.0 -15601 +NULL -1888902550 NULL NULL -5.0 15601.0 1969-12-31 15:59:58.456 15601 u1Fk5xG71QSrrxall true NULL -16.097000064784993 NULL 0.1750000000000007 5.0 -10.0 -10.0 2.43391201E8 -15601.0 1888902550 NULL -15601 3569 -15242.0 -15601 +NULL 1522333028 NULL NULL 5.0 15601.0 1969-12-31 15:59:58.456 15601 n64yAe7s false NULL 57.995000052212504 NULL 0.1750000000000007 -5.0 10.0 10.0 2.43391201E8 -15601.0 -1522333028 NULL -15601 3569 -15242.0 -15601 +NULL -643533009 NULL NULL -19.0 15601.0 1969-12-31 15:59:58.456 15601 S1gQ06M353rQ5vm2a24EMN true NULL -73.3670000220717 NULL 10.175 19.0 -38.0 -38.0 2.43391201E8 -15601.0 643533009 NULL -15601 3569 -15242.0 -15601 +NULL 808737125 NULL NULL -26.28 15601.0 1969-12-31 15:59:58.456 15601 SvKL2lM7lc false NULL 54.15200002773781 NULL 10.175 26.28 -52.56 -52.56 2.43391201E8 -15601.0 -808737125 NULL -15601 3569 -15242.0 -15601 +NULL -57923441 NULL NULL -20.0 15601.0 1969-12-31 15:59:58.456 15601 3h42BQqfR5c74WLa false NULL -26.61700000198664 NULL 10.175 20.0 -40.0 -40.0 2.43391201E8 -15601.0 57923441 NULL -15601 3569 -15242.0 -15601 +NULL -358755931 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 cvh1bKh1rHg5uPdR7E true NULL -62.7620000123045 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 358755931 NULL -15601 3569 -15242.0 -15601 +NULL 986909074 NULL NULL -11.0 15601.0 1969-12-31 15:59:58.456 15601 3Xs32r0n4BU2f2tiC true NULL 12.9600000338487 NULL 10.175 11.0 -22.0 -22.0 2.43391201E8 -15601.0 -986909074 NULL -15601 3569 -15242.0 -15601 +NULL -819636483 NULL NULL 55.0 15601.0 1969-12-31 15:59:58.456 15601 hTK0Tu6Lyo881R8S0b true NULL -14.728000028111637 NULL 10.175 -55.0 110.0 110.0 2.43391201E8 -15601.0 819636483 NULL -15601 3569 -15242.0 -15601 +NULL 30909765 NULL NULL -44.0 15601.0 1969-12-31 15:59:58.456 15601 EcpSw7QRSrw40ueJm false NULL 3.7210000010601334 NULL 10.175 44.0 -88.0 -88.0 2.43391201E8 -15601.0 -30909765 NULL -15601 3569 -15242.0 -15601 +NULL 1158473216 NULL NULL -17.0 15601.0 1969-12-31 15:59:58.456 15601 HC8S2Tyv8RF true NULL 75.60700003973295 NULL 10.175 17.0 -34.0 -34.0 2.43391201E8 -15601.0 -1158473216 NULL -15601 3569 -15242.0 -15601 +NULL -903925845 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 pOATk4umbs0Hy true NULL -29.767000031002567 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 903925845 NULL -15601 3569 -15242.0 -15601 +NULL 1129363554 NULL NULL 59.0 15601.0 1969-12-31 15:59:58.456 15601 OgJuBiLW71S false NULL 49.60200003873456 NULL 10.175 -59.0 118.0 118.0 2.43391201E8 -15601.0 -1129363554 NULL -15601 3569 -15242.0 -15601 +NULL -689749024 NULL NULL 45.0 15601.0 1969-12-31 15:59:58.456 15601 n1nB1TXdm2CfC6G75oIMM false NULL -11.676000023656798 NULL 10.175 -45.0 90.0 90.0 2.43391201E8 -15601.0 689749024 NULL -15601 3569 -15242.0 -15601 +NULL 868023288 NULL NULL -34.0 15601.0 1969-12-31 15:59:58.456 15601 pSJp676K5 false NULL 59.87900002977119 NULL 10.175 34.0 -68.0 -68.0 2.43391201E8 -15601.0 -868023288 NULL -15601 3569 -15242.0 -15601 +NULL 1835949827 NULL NULL -58.0 15601.0 1969-12-31 15:59:58.456 15601 b3RuQE56Bpw false NULL 76.93400006296883 NULL 10.175 58.0 -116.0 -116.0 2.43391201E8 -15601.0 -1835949827 NULL -15601 3569 -15242.0 -15601 +NULL 2060956712 NULL NULL 8.0 15601.0 1969-12-31 15:59:58.456 15601 OtS4TXC3o8opoEsRtv5Sj true NULL 52.26400007068605 NULL 2.1750000000000007 -8.0 16.0 16.0 2.43391201E8 -15601.0 -2060956712 NULL -15601 3569 -15242.0 -15601 +NULL -293394791 NULL NULL 4.0 15601.0 1969-12-31 15:59:58.456 15601 Fwf6Sac6mM2Q5tj38H false NULL -65.32700001006276 NULL 2.1750000000000007 -4.0 8.0 8.0 2.43391201E8 -15601.0 293394791 NULL -15601 3569 -15242.0 -15601 +NULL -438779645 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 nO67pfo61hm6it1 false NULL -61.661000015049126 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 438779645 NULL -15601 3569 -15242.0 -15601 +NULL -402367872 NULL NULL 17.0 15601.0 1969-12-31 15:59:58.456 15601 3U24COBBS7q3TeS3m false NULL -14.973000013800288 NULL 10.175 -17.0 34.0 34.0 2.43391201E8 -15601.0 402367872 NULL -15601 3569 -15242.0 -15601 +NULL 1380425571 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 770AYojc7s false NULL 37.92500004734541 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -1380425571 NULL -15601 3569 -15242.0 -15601 +NULL -122247742 NULL NULL 42.0 15601.0 1969-12-31 15:59:58.456 15601 4Rq1pXQeEsPt true NULL -78.85400000419281 NULL 10.175 -42.0 84.0 84.0 2.43391201E8 -15601.0 122247742 NULL -15601 3569 -15242.0 -15601 +NULL 724330421 NULL NULL -7.0 15601.0 1969-12-31 15:59:58.456 15601 Y6mE20661Ek61Mf7mYtCQV5 false NULL 37.78800002484286 NULL 3.1750000000000007 7.0 -14.0 -14.0 2.43391201E8 -15601.0 -724330421 NULL -15601 3569 -15242.0 -15601 +NULL 926099123 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 X27PKe6lm1EmNx6tkEGfQ false NULL 56.94800003176306 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 -926099123 NULL -15601 3569 -15242.0 -15601 +NULL 913861995 NULL NULL -4.0 15601.0 1969-12-31 15:59:58.456 15601 1434C61RVhlDmptMem1X true NULL 10.067000031343355 NULL 2.1750000000000007 4.0 -8.0 -8.0 2.43391201E8 -15601.0 -913861995 NULL -15601 3569 -15242.0 -15601 +NULL 1977536065 NULL NULL -61.0 15601.0 1969-12-31 15:59:58.456 15601 371wKbMGY2 false NULL 33.46500006782492 NULL 10.175 61.0 -122.0 -122.0 2.43391201E8 -15601.0 -1977536065 NULL -15601 3569 -15242.0 -15601 +NULL 1122350878 NULL NULL 15.0 15601.0 1969-12-31 15:59:58.456 15601 jPk4fH12221A28 true NULL 50.10500003849404 NULL 10.175 -15.0 30.0 30.0 2.43391201E8 -15601.0 -1122350878 NULL -15601 3569 -15242.0 -15601 +NULL 270888813 NULL NULL 3.0 15601.0 1969-12-31 15:59:58.456 15601 W087uQpM6uJ2G5aB false NULL 28.79200000929086 NULL 1.1750000000000007 -3.0 6.0 6.0 2.43391201E8 -15601.0 -270888813 NULL -15601 3569 -15242.0 -15601 +NULL -2022905886 NULL NULL -26.0 15601.0 1969-12-31 15:59:58.456 15601 y3xnVjfS5g77 false NULL -62.588000069380996 NULL 10.175 26.0 -52.0 -52.0 2.43391201E8 -15601.0 2022905886 NULL -15601 3569 -15242.0 -15601 +NULL 1580847931 NULL NULL 0.0 15601.0 1969-12-31 15:59:58.456 15601 wQ06R8m6G2SA57UICse true NULL 70.05700005421943 NULL NaN -0.0 0.0 0.0 2.43391201E8 -15601.0 -1580847931 NULL -15601 3569 -15242.0 -15601 +NULL -46453649 NULL NULL -31.0 15601.0 1969-12-31 15:59:58.456 15601 O77TCNDlf8w true NULL -27.051000001593252 NULL 10.175 31.0 -62.0 -62.0 2.43391201E8 -15601.0 46453649 NULL -15601 3569 -15242.0 -15601 +NULL -1754189160 NULL NULL -54.0 15601.0 1969-12-31 15:59:58.456 15601 R4WtD3 false NULL -5.684000060164635 NULL 10.175 54.0 -108.0 -108.0 2.43391201E8 -15601.0 1754189160 NULL -15601 3569 -15242.0 -15601 +NULL -626007306 NULL NULL -40.0 15601.0 1969-12-31 15:59:58.456 15601 wjhRixqupg6DoX6GLPY1233 true NULL -55.3730000214706 NULL 10.175 40.0 -80.0 -80.0 2.43391201E8 -15601.0 626007306 NULL -15601 3569 -15242.0 -15601 +NULL 1194813198 NULL NULL 32.0 15601.0 1969-12-31 15:59:58.456 15601 6xam34x8s05c60D8BXMDCP false NULL 8.548000040979332 NULL 10.175 -32.0 64.0 64.0 2.43391201E8 -15601.0 -1194813198 NULL -15601 3569 -15242.0 -15601 +NULL 19993315 NULL NULL -6.0 15601.0 1969-12-31 15:59:58.456 15601 W3QY4I4LLu6yX true NULL 55.04000000068572 NULL 4.175000000000001 6.0 -12.0 -12.0 2.43391201E8 -15601.0 -19993315 NULL -15601 3569 -15242.0 -15601 +NULL -408304573 NULL NULL 19.0 15601.0 1969-12-31 15:59:58.456 15601 3DCKPI43L3d true NULL -73.3480000140039 NULL 10.175 -19.0 38.0 38.0 2.43391201E8 -15601.0 408304573 NULL -15601 3569 -15242.0 -15601 +NULL -1852182045 NULL NULL 28.0 15601.0 1969-12-31 15:59:58.456 15601 2hyiY02c4fV168hNxjdGqo true NULL -62.15500006352556 NULL 10.175 -28.0 56.0 56.0 2.43391201E8 -15601.0 1852182045 NULL -15601 3569 -15242.0 -15601 +NULL -519753851 NULL NULL -60.0 15601.0 1969-12-31 15:59:58.456 15601 b3d7vMe6giBB2hQM28H5q false NULL -53.316000017826354 NULL 10.175 60.0 -120.0 -120.0 2.43391201E8 -15601.0 519753851 NULL -15601 3569 -15242.0 -15601 +NULL -1447184932 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 o1yRb6hf2B2DRvifN60ATmM true NULL -32.8320000496351 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 1447184932 NULL -15601 3569 -15242.0 -15601 +NULL 805666814 NULL NULL 58.0 15601.0 1969-12-31 15:59:58.456 15601 Wpi2820uS61uJ7Gn7xu822MA false NULL 11.63400002763251 NULL 10.175 -58.0 116.0 116.0 2.43391201E8 -15601.0 -805666814 NULL -15601 3569 -15242.0 -15601 +NULL 345989051 NULL NULL 39.0 15601.0 1969-12-31 15:59:58.456 15601 NULL NULL NULL 7.308000011866625 NULL 10.175 -39.0 78.0 78.0 2.43391201E8 -15601.0 -345989051 NULL -15601 3569 -15242.0 -15601 +NULL -1863202490 NULL NULL -14.0 15601.0 1969-12-31 15:59:58.456 15601 7Q2u1kLd7Mfy1 false NULL -30.06500006390354 NULL 10.175 14.0 -28.0 -28.0 2.43391201E8 -15601.0 1863202490 NULL -15601 3569 -15242.0 -15601 +NULL 2113671499 NULL NULL 43.0 15601.0 1969-12-31 15:59:58.456 15601 Db7CaO true NULL 78.00300007249405 NULL 10.175 -43.0 86.0 86.0 2.43391201E8 -15601.0 -2113671499 NULL -15601 3569 -15242.0 -15601 +NULL -1063470233 NULL NULL 46.0 15601.0 1969-12-31 15:59:58.456 15601 6Qtj3B0piVu true NULL -1.184000036474572 NULL 10.175 -46.0 92.0 92.0 2.43391201E8 -15601.0 1063470233 NULL -15601 3569 -15242.0 -15601 +NULL NULL NULL NULL 41.0 15601.0 1969-12-31 15:59:58.456 15601 Xy07hchP3S32iW6YG3cn3 true NULL NULL NULL 10.175 -41.0 82.0 82.0 2.43391201E8 -15601.0 NULL NULL -15601 NULL -15242.0 -15601 +NULL -1870761879 NULL NULL -33.0 15601.0 1969-12-31 15:59:58.456 15601 hRl163NpsDKR2HX6c3BgrS true NULL -54.34600006416281 NULL 10.175 33.0 -66.0 -66.0 2.43391201E8 -15601.0 1870761879 NULL -15601 3569 -15242.0 -15601 +NULL -197652849 NULL NULL -49.0 15601.0 1969-12-31 15:59:58.456 15601 GlQD5lVNjayU21uPxj7x6 true NULL -79.27400000677903 NULL 10.175 49.0 -98.0 -98.0 2.43391201E8 -15601.0 197652849 NULL -15601 3569 -15242.0 -15601 +NULL -919690155 NULL NULL 30.0 15601.0 1969-12-31 15:59:58.456 15601 77tF4t false NULL -37.734000031543246 NULL 10.175 -30.0 60.0 60.0 2.43391201E8 -15601.0 919690155 NULL -15601 3569 -15242.0 -15601 +NULL -1274229243 NULL NULL -37.0 15601.0 1969-12-31 15:59:58.456 15601 Hv27a0qU14MJB7 true NULL -43.81400004370312 NULL 10.175 37.0 -74.0 -74.0 2.43391201E8 -15601.0 1274229243 NULL -15601 3569 -15242.0 -15601 +253665376 NULL 1cGVWH7n1QU true 54.0 6556.0 1969-12-31 15:59:54.197 6556 NULL NULL NULL NULL NULL 10.175 -54.0 108.0 108.0 4.2981136E7 -6556.0 NULL NULL -6556 NULL -6197.0 -6556 +253665376 NULL 1cGVWH7n1QU true -10.0 13893.0 1969-12-31 15:59:48.606 13893 NULL NULL NULL NULL NULL 0.1750000000000007 10.0 -20.0 -20.0 1.93015449E8 -13893.0 NULL NULL -13893 NULL -13534.0 -13893 +253665376 NULL 1cGVWH7n1QU true 42.0 10242.0 1969-12-31 15:59:46.737 10242 NULL NULL NULL NULL NULL 10.175 -42.0 84.0 84.0 1.04898564E8 -10242.0 NULL NULL -10242 NULL -9883.0 -10242 +253665376 NULL 1cGVWH7n1QU true -41.0 7588.0 1969-12-31 15:59:45.527 7588 NULL NULL NULL NULL NULL 10.175 41.0 -82.0 -82.0 5.7577744E7 -7588.0 NULL NULL -7588 NULL -7229.0 -7588 +253665376 NULL 1cGVWH7n1QU true 10.0 12857.0 1969-12-31 15:59:50.571 12857 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 1.65302449E8 -12857.0 NULL NULL -12857 NULL -12498.0 -12857 +253665376 NULL 1cGVWH7n1QU true 23.0 6546.0 1969-12-31 15:59:53.978 6546 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 4.2850116E7 -6546.0 NULL NULL -6546 NULL -6187.0 -6546 +253665376 NULL 1cGVWH7n1QU true 56.0 10922.0 1969-12-31 15:59:51.88 10922 NULL NULL NULL NULL NULL 10.175 -56.0 112.0 112.0 1.19290084E8 -10922.0 NULL NULL -10922 NULL -10563.0 -10922 +253665376 NULL 1cGVWH7n1QU true 29.0 7060.0 1969-12-31 15:59:50.789 7060 NULL NULL NULL NULL NULL 10.175 -29.0 58.0 58.0 4.98436E7 -7060.0 NULL NULL -7060 NULL -6701.0 -7060 +253665376 NULL 1cGVWH7n1QU true 5.0 6513.0 1969-12-31 15:59:45.112 6513 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 4.2419169E7 -6513.0 NULL NULL -6513 NULL -6154.0 -6513 +253665376 NULL 1cGVWH7n1QU true -43.0 2921.0 1969-12-31 15:59:49.622 2921 NULL NULL NULL NULL NULL 10.175 43.0 -86.0 -86.0 8532241.0 -2921.0 NULL NULL -2921 NULL -2562.0 -2921 +253665376 NULL 1cGVWH7n1QU true 61.0 4370.0 1969-12-31 15:59:51.785 4370 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 1.90969E7 -4370.0 NULL NULL -4370 NULL -4011.0 -4370 +253665376 NULL 1cGVWH7n1QU true -46.0 15932.0 1969-12-31 15:59:50.556 15932 NULL NULL NULL NULL NULL 10.175 46.0 -92.0 -92.0 2.53828624E8 -15932.0 NULL NULL -15932 NULL -15573.0 -15932 +253665376 NULL 1cGVWH7n1QU true 25.0 2578.0 1969-12-31 15:59:47.524 2578 NULL NULL NULL NULL NULL 10.175 -25.0 50.0 50.0 6646084.0 -2578.0 NULL NULL -2578 NULL -2219.0 -2578 +253665376 NULL 1cGVWH7n1QU true 7.0 11319.0 1969-12-31 15:59:47.726 11319 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 1.28119761E8 -11319.0 NULL NULL -11319 NULL -10960.0 -11319 +253665376 NULL 1cGVWH7n1QU true -40.0 3030.0 1969-12-31 15:59:52.041 3030 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 9180900.0 -3030.0 NULL NULL -3030 NULL -2671.0 -3030 +253665376 NULL 1cGVWH7n1QU true -12.0 14347.0 1969-12-31 15:59:58.062 14347 NULL NULL NULL NULL NULL 10.175 12.0 -24.0 -24.0 2.05836409E8 -14347.0 NULL NULL -14347 NULL -13988.0 -14347 +253665376 NULL 1cGVWH7n1QU true -9.0 6036.0 1969-12-31 15:59:54.24 6036 NULL NULL NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 3.6433296E7 -6036.0 NULL NULL -6036 NULL -5677.0 -6036 +253665376 NULL 1cGVWH7n1QU true -12.0 5663.0 1969-12-31 15:59:56.482 5663 NULL NULL NULL NULL NULL 10.175 12.0 -24.0 -24.0 3.2069569E7 -5663.0 NULL NULL -5663 NULL -5304.0 -5663 +253665376 NULL 1cGVWH7n1QU true -53.0 16212.0 1969-12-31 15:59:49.418 16212 NULL NULL NULL NULL NULL 10.175 53.0 -106.0 -106.0 2.62828944E8 -16212.0 NULL NULL -16212 NULL -15853.0 -16212 +253665376 NULL 1cGVWH7n1QU true 21.0 12936.0 1969-12-31 15:59:57.821 12936 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 1.67340096E8 -12936.0 NULL NULL -12936 NULL -12577.0 -12936 +253665376 NULL 1cGVWH7n1QU true 21.0 9444.0 1969-12-31 15:59:50.116 9444 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 8.9189136E7 -9444.0 NULL NULL -9444 NULL -9085.0 -9444 +253665376 NULL 1cGVWH7n1QU true -35.0 5815.0 1969-12-31 15:59:57.581 5815 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 3.3814225E7 -5815.0 NULL NULL -5815 NULL -5456.0 -5815 +253665376 NULL 1cGVWH7n1QU true 58.0 5786.0 1969-12-31 15:59:44.21 5786 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 3.3477796E7 -5786.0 NULL NULL -5786 NULL -5427.0 -5786 +253665376 NULL 1cGVWH7n1QU true 15.0 10827.0 1969-12-31 15:59:57.92 10827 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 1.17223929E8 -10827.0 NULL NULL -10827 NULL -10468.0 -10827 +253665376 NULL 1cGVWH7n1QU true -4.0 10149.0 1969-12-31 15:59:50.207 10149 NULL NULL NULL NULL NULL 2.1750000000000007 4.0 -8.0 -8.0 1.03002201E8 -10149.0 NULL NULL -10149 NULL -9790.0 -10149 +253665376 NULL 1cGVWH7n1QU true 48.0 12849.0 1969-12-31 15:59:46.777 12849 NULL NULL NULL NULL NULL 10.175 -48.0 96.0 96.0 1.65096801E8 -12849.0 NULL NULL -12849 NULL -12490.0 -12849 +253665376 NULL 1cGVWH7n1QU true 18.0 14744.0 1969-12-31 15:59:52.731 14744 NULL NULL NULL NULL NULL 10.175 -18.0 36.0 36.0 2.17385536E8 -14744.0 NULL NULL -14744 NULL -14385.0 -14744 +253665376 NULL 1cGVWH7n1QU true 11.0 5885.0 1969-12-31 15:59:57.064 5885 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 3.4633225E7 -5885.0 NULL NULL -5885 NULL -5526.0 -5885 +253665376 NULL 1cGVWH7n1QU true -14.0 9929.0 1969-12-31 15:59:56.088 9929 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 9.8585041E7 -9929.0 NULL NULL -9929 NULL -9570.0 -9929 +253665376 NULL 1cGVWH7n1QU true -20.0 6793.0 1969-12-31 15:59:51.04 6793 NULL NULL NULL NULL NULL 10.175 20.0 -40.0 -40.0 4.6144849E7 -6793.0 NULL NULL -6793 NULL -6434.0 -6793 +253665376 NULL 1cGVWH7n1QU true 11.0 8896.0 1969-12-31 15:59:48.206 8896 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 7.9138816E7 -8896.0 NULL NULL -8896 NULL -8537.0 -8896 +253665376 NULL 1cGVWH7n1QU true -47.0 16036.0 1969-12-31 15:59:52.574 16036 NULL NULL NULL NULL NULL 10.175 47.0 -94.0 -94.0 2.57153296E8 -16036.0 NULL NULL -16036 NULL -15677.0 -16036 +253665376 NULL 1cGVWH7n1QU true 41.0 9539.0 1969-12-31 15:59:54.791 9539 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 9.0992521E7 -9539.0 NULL NULL -9539 NULL -9180.0 -9539 +253665376 NULL 1cGVWH7n1QU true -25.0 13539.0 1969-12-31 15:59:48.005 13539 NULL NULL NULL NULL NULL 10.175 25.0 -50.0 -50.0 1.83304521E8 -13539.0 NULL NULL -13539 NULL -13180.0 -13539 +253665376 NULL 1cGVWH7n1QU true -29.0 7022.0 1969-12-31 15:59:55.614 7022 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 4.9308484E7 -7022.0 NULL NULL -7022 NULL -6663.0 -7022 +253665376 NULL 1cGVWH7n1QU true -18.0 7249.0 1969-12-31 15:59:48.161 7249 NULL NULL NULL NULL NULL 10.175 18.0 -36.0 -36.0 5.2548001E7 -7249.0 NULL NULL -7249 NULL -6890.0 -7249 +253665376 NULL 1cGVWH7n1QU true -29.0 9052.0 1969-12-31 15:59:48.003 9052 NULL NULL NULL NULL NULL 10.175 29.0 -58.0 -58.0 8.1938704E7 -9052.0 NULL NULL -9052 NULL -8693.0 -9052 +253665376 NULL 1cGVWH7n1QU true 15.0 7077.0 1969-12-31 15:59:45.227 7077 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 5.0083929E7 -7077.0 NULL NULL -7077 NULL -6718.0 -7077 +253665376 NULL 1cGVWH7n1QU true 28.0 6349.0 1969-12-31 15:59:44.816 6349 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 4.0309801E7 -6349.0 NULL NULL -6349 NULL -5990.0 -6349 +253665376 NULL 1cGVWH7n1QU true -30.0 15516.0 1969-12-31 15:59:44.859 15516 NULL NULL NULL NULL NULL 10.175 30.0 -60.0 -60.0 2.40746256E8 -15516.0 NULL NULL -15516 NULL -15157.0 -15516 +253665376 NULL 1cGVWH7n1QU true 61.0 5451.0 1969-12-31 15:59:46.842 5451 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 2.9713401E7 -5451.0 NULL NULL -5451 NULL -5092.0 -5451 +253665376 NULL 1cGVWH7n1QU true -35.0 12059.0 1969-12-31 15:59:48.709 12059 NULL NULL NULL NULL NULL 10.175 35.0 -70.0 -70.0 1.45419481E8 -12059.0 NULL NULL -12059 NULL -11700.0 -12059 +253665376 NULL 1cGVWH7n1QU true -31.0 6654.0 1969-12-31 15:59:46.871 6654 NULL NULL NULL NULL NULL 10.175 31.0 -62.0 -62.0 4.4275716E7 -6654.0 NULL NULL -6654 NULL -6295.0 -6654 +253665376 NULL 1cGVWH7n1QU true -40.0 15620.0 1969-12-31 15:59:54.923 15620 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 2.439844E8 -15620.0 NULL NULL -15620 NULL -15261.0 -15620 +253665376 NULL 1cGVWH7n1QU true -64.0 6183.0 1969-12-31 15:59:44.416 6183 NULL NULL NULL NULL NULL 10.175 64.0 -128.0 -128.0 3.8229489E7 -6183.0 NULL NULL -6183 NULL -5824.0 -6183 +253665376 NULL 1cGVWH7n1QU true -14.0 10310.0 1969-12-31 15:59:52.78 10310 NULL NULL NULL NULL NULL 10.175 14.0 -28.0 -28.0 1.062961E8 -10310.0 NULL NULL -10310 NULL -9951.0 -10310 +253665376 NULL 1cGVWH7n1QU true -37.0 10496.0 1969-12-31 15:59:58.2 10496 NULL NULL NULL NULL NULL 10.175 37.0 -74.0 -74.0 1.10166016E8 -10496.0 NULL NULL -10496 NULL -10137.0 -10496 +253665376 NULL 1cGVWH7n1QU true 2.0 5929.0 1969-12-31 15:59:55.408 5929 NULL NULL NULL NULL NULL 0.1750000000000007 -2.0 4.0 4.0 3.5153041E7 -5929.0 NULL NULL -5929 NULL -5570.0 -5929 +253665376 NULL 1cGVWH7n1QU true 26.0 6297.0 1969-12-31 15:59:53.027 6297 NULL NULL NULL NULL NULL 10.175 -26.0 52.0 52.0 3.9652209E7 -6297.0 NULL NULL -6297 NULL -5938.0 -6297 +253665376 NULL 1cGVWH7n1QU true 33.0 12375.0 1969-12-31 15:59:52.387 12375 NULL NULL NULL NULL NULL 10.175 -33.0 66.0 66.0 1.53140625E8 -12375.0 NULL NULL -12375 NULL -12016.0 -12375 +253665376 NULL 1cGVWH7n1QU true 15.0 3555.0 1969-12-31 15:59:44.559 3555 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 1.2638025E7 -3555.0 NULL NULL -3555 NULL -3196.0 -3555 +253665376 NULL 1cGVWH7n1QU true -1.0 2643.0 1969-12-31 15:59:55.941 2643 NULL NULL NULL NULL NULL 0.1750000000000007 1.0 -2.0 -2.0 6985449.0 -2643.0 NULL NULL -2643 NULL -2284.0 -2643 +253665376 NULL 1cGVWH7n1QU true 1.0 14530.0 1969-12-31 15:59:47.363 14530 NULL NULL NULL NULL NULL 0.1750000000000007 -1.0 2.0 2.0 2.111209E8 -14530.0 NULL NULL -14530 NULL -14171.0 -14530 +253665376 NULL 1cGVWH7n1QU true -41.0 11014.0 1969-12-31 15:59:46.308 11014 NULL NULL NULL NULL NULL 10.175 41.0 -82.0 -82.0 1.21308196E8 -11014.0 NULL NULL -11014 NULL -10655.0 -11014 +253665376 NULL 1cGVWH7n1QU true 0.0 9304.0 1969-12-31 15:59:51.838 9304 NULL NULL NULL NULL NULL NaN -0.0 0.0 0.0 8.6564416E7 -9304.0 NULL NULL -9304 NULL -8945.0 -9304 +253665376 NULL 1cGVWH7n1QU true 11.0 13947.0 1969-12-31 15:59:57.171 13947 NULL NULL NULL NULL NULL 10.175 -11.0 22.0 22.0 1.94518809E8 -13947.0 NULL NULL -13947 NULL -13588.0 -13947 +253665376 NULL 1cGVWH7n1QU true 46.0 10663.0 1969-12-31 15:59:51.843 10663 NULL NULL NULL NULL NULL 10.175 -46.0 92.0 92.0 1.13699569E8 -10663.0 NULL NULL -10663 NULL -10304.0 -10663 +253665376 NULL 1cGVWH7n1QU true -44.0 16227.0 1969-12-31 15:59:50.958 16227 NULL NULL NULL NULL NULL 10.175 44.0 -88.0 -88.0 2.63315529E8 -16227.0 NULL NULL -16227 NULL -15868.0 -16227 +253665376 NULL 1cGVWH7n1QU true 22.0 10802.0 1969-12-31 15:59:49.951 10802 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 1.16683204E8 -10802.0 NULL NULL -10802 NULL -10443.0 -10802 +253665376 NULL 1cGVWH7n1QU true 5.0 12417.0 1969-12-31 15:59:49.4 12417 NULL NULL NULL NULL NULL 0.1750000000000007 -5.0 10.0 10.0 1.54181889E8 -12417.0 NULL NULL -12417 NULL -12058.0 -12417 +253665376 NULL 1cGVWH7n1QU true 57.0 11302.0 1969-12-31 15:59:45.654 11302 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 1.27735204E8 -11302.0 NULL NULL -11302 NULL -10943.0 -11302 +253665376 NULL 1cGVWH7n1QU true -41.0 9442.0 1969-12-31 15:59:57.284 9442 NULL NULL NULL NULL NULL 10.175 41.0 -82.0 -82.0 8.9151364E7 -9442.0 NULL NULL -9442 NULL -9083.0 -9442 +253665376 NULL 1cGVWH7n1QU true 43.0 4128.0 1969-12-31 15:59:43.982 4128 NULL NULL NULL NULL NULL 10.175 -43.0 86.0 86.0 1.7040384E7 -4128.0 NULL NULL -4128 NULL -3769.0 -4128 +253665376 NULL 1cGVWH7n1QU true 45.0 16285.0 1969-12-31 15:59:47.121 16285 NULL NULL NULL NULL NULL 10.175 -45.0 90.0 90.0 2.65201225E8 -16285.0 NULL NULL -16285 NULL -15926.0 -16285 +253665376 NULL 1cGVWH7n1QU true 28.0 6248.0 1969-12-31 15:59:47.818 6248 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 3.9037504E7 -6248.0 NULL NULL -6248 NULL -5889.0 -6248 +253665376 NULL 1cGVWH7n1QU true 54.0 10451.0 1969-12-31 15:59:46.126 10451 NULL NULL NULL NULL NULL 10.175 -54.0 108.0 108.0 1.09223401E8 -10451.0 NULL NULL -10451 NULL -10092.0 -10451 +253665376 NULL 1cGVWH7n1QU true -40.0 11168.0 1969-12-31 15:59:49.334 11168 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 1.24724224E8 -11168.0 NULL NULL -11168 NULL -10809.0 -11168 +253665376 NULL 1cGVWH7n1QU true -8.0 8076.0 1969-12-31 15:59:44.037 8076 NULL NULL NULL NULL NULL 2.1750000000000007 8.0 -16.0 -16.0 6.5221776E7 -8076.0 NULL NULL -8076 NULL -7717.0 -8076 +253665376 NULL 1cGVWH7n1QU true -52.0 6321.0 1969-12-31 15:59:46.027 6321 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 3.9955041E7 -6321.0 NULL NULL -6321 NULL -5962.0 -6321 +253665376 NULL 1cGVWH7n1QU true 40.0 9926.0 1969-12-31 15:59:48.2 9926 NULL NULL NULL NULL NULL 10.175 -40.0 80.0 80.0 9.8525476E7 -9926.0 NULL NULL -9926 NULL -9567.0 -9926 +253665376 NULL 1cGVWH7n1QU true -20.0 4003.0 1969-12-31 15:59:55.486 4003 NULL NULL NULL NULL NULL 10.175 20.0 -40.0 -40.0 1.6024009E7 -4003.0 NULL NULL -4003 NULL -3644.0 -4003 +253665376 NULL 1cGVWH7n1QU true 38.0 15423.0 1969-12-31 15:59:53.241 15423 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 2.37868929E8 -15423.0 NULL NULL -15423 NULL -15064.0 -15423 +253665376 NULL 1cGVWH7n1QU true -36.0 7511.0 1969-12-31 15:59:47.624 7511 NULL NULL NULL NULL NULL 10.175 36.0 -72.0 -72.0 5.6415121E7 -7511.0 NULL NULL -7511 NULL -7152.0 -7511 +253665376 NULL 1cGVWH7n1QU true -24.0 10273.0 1969-12-31 15:59:50.433 10273 NULL NULL NULL NULL NULL 10.175 24.0 -48.0 -48.0 1.05534529E8 -10273.0 NULL NULL -10273 NULL -9914.0 -10273 +253665376 NULL 1cGVWH7n1QU true -2.0 4087.0 1969-12-31 15:59:51.348 4087 NULL NULL NULL NULL NULL 0.1750000000000007 2.0 -4.0 -4.0 1.6703569E7 -4087.0 NULL NULL -4087 NULL -3728.0 -4087 +253665376 NULL 1cGVWH7n1QU true 15.0 8429.0 1969-12-31 15:59:57.854 8429 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 7.1048041E7 -8429.0 NULL NULL -8429 NULL -8070.0 -8429 +253665376 NULL 1cGVWH7n1QU true 30.0 14821.0 1969-12-31 15:59:54.872 14821 NULL NULL NULL NULL NULL 10.175 -30.0 60.0 60.0 2.19662041E8 -14821.0 NULL NULL -14821 NULL -14462.0 -14821 +253665376 NULL 1cGVWH7n1QU true -18.0 5661.0 1969-12-31 15:59:56.313 5661 NULL NULL NULL NULL NULL 10.175 18.0 -36.0 -36.0 3.2046921E7 -5661.0 NULL NULL -5661 NULL -5302.0 -5661 +253665376 NULL 1cGVWH7n1QU true 58.0 5028.0 1969-12-31 15:59:57.328 5028 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 2.5280784E7 -5028.0 NULL NULL -5028 NULL -4669.0 -5028 +253665376 NULL 1cGVWH7n1QU true 6.0 9802.0 1969-12-31 15:59:48.069 9802 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 9.6079204E7 -9802.0 NULL NULL -9802 NULL -9443.0 -9802 +253665376 NULL 1cGVWH7n1QU true -21.0 8096.0 1969-12-31 15:59:48.648 8096 NULL NULL NULL NULL NULL 10.175 21.0 -42.0 -42.0 6.5545216E7 -8096.0 NULL NULL -8096 NULL -7737.0 -8096 +253665376 NULL 1cGVWH7n1QU true -55.0 5941.0 1969-12-31 15:59:47.693 5941 NULL NULL NULL NULL NULL 10.175 55.0 -110.0 -110.0 3.5295481E7 -5941.0 NULL NULL -5941 NULL -5582.0 -5941 +253665376 NULL 1cGVWH7n1QU true 52.0 7276.0 1969-12-31 15:59:52.42 7276 NULL NULL NULL NULL NULL 10.175 -52.0 104.0 104.0 5.2940176E7 -7276.0 NULL NULL -7276 NULL -6917.0 -7276 +253665376 NULL 1cGVWH7n1QU true -8.0 12870.0 1969-12-31 15:59:44.029 12870 NULL NULL NULL NULL NULL 2.1750000000000007 8.0 -16.0 -16.0 1.656369E8 -12870.0 NULL NULL -12870 NULL -12511.0 -12870 +253665376 NULL 1cGVWH7n1QU true -38.0 16146.0 1969-12-31 15:59:55.808 16146 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 2.60693316E8 -16146.0 NULL NULL -16146 NULL -15787.0 -16146 +253665376 NULL 1cGVWH7n1QU true -25.0 11528.0 1969-12-31 15:59:46.069 11528 NULL NULL NULL NULL NULL 10.175 25.0 -50.0 -50.0 1.32894784E8 -11528.0 NULL NULL -11528 NULL -11169.0 -11528 +253665376 NULL 1cGVWH7n1QU true -47.0 11583.0 1969-12-31 15:59:46.941 11583 NULL NULL NULL NULL NULL 10.175 47.0 -94.0 -94.0 1.34165889E8 -11583.0 NULL NULL -11583 NULL -11224.0 -11583 +253665376 NULL 1cGVWH7n1QU true 59.0 10861.0 1969-12-31 15:59:43.676 10861 NULL NULL NULL NULL NULL 10.175 -59.0 118.0 118.0 1.17961321E8 -10861.0 NULL NULL -10861 NULL -10502.0 -10861 +253665376 NULL 1cGVWH7n1QU true -16.0 5977.0 1969-12-31 15:59:54.157 5977 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 3.5724529E7 -5977.0 NULL NULL -5977 NULL -5618.0 -5977 +253665376 NULL 1cGVWH7n1QU true 57.0 12560.0 1969-12-31 15:59:51.33 12560 NULL NULL NULL NULL NULL 10.175 -57.0 114.0 114.0 1.577536E8 -12560.0 NULL NULL -12560 NULL -12201.0 -12560 +253665376 NULL 1cGVWH7n1QU true 52.0 14239.0 1969-12-31 15:59:45.866 14239 NULL NULL NULL NULL NULL 10.175 -52.0 104.0 104.0 2.02749121E8 -14239.0 NULL NULL -14239 NULL -13880.0 -14239 +253665376 NULL 1cGVWH7n1QU true 41.0 5641.0 1969-12-31 15:59:50.748 5641 NULL NULL NULL NULL NULL 10.175 -41.0 82.0 82.0 3.1820881E7 -5641.0 NULL NULL -5641 NULL -5282.0 -5641 +253665376 NULL 1cGVWH7n1QU true 38.0 16240.0 1969-12-31 15:59:49.259 16240 NULL NULL NULL NULL NULL 10.175 -38.0 76.0 76.0 2.637376E8 -16240.0 NULL NULL -16240 NULL -15881.0 -16240 +253665376 NULL 1cGVWH7n1QU true -50.0 10484.0 1969-12-31 15:59:43.906 10484 NULL NULL NULL NULL NULL 10.175 50.0 -100.0 -100.0 1.09914256E8 -10484.0 NULL NULL -10484 NULL -10125.0 -10484 +253665376 NULL 1cGVWH7n1QU true 42.0 6760.0 1969-12-31 15:59:48.681 6760 NULL NULL NULL NULL NULL 10.175 -42.0 84.0 84.0 4.56976E7 -6760.0 NULL NULL -6760 NULL -6401.0 -6760 +253665376 NULL 1cGVWH7n1QU true -38.0 8072.0 1969-12-31 15:59:56.917 8072 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 6.5157184E7 -8072.0 NULL NULL -8072 NULL -7713.0 -8072 +253665376 NULL 1cGVWH7n1QU true -23.0 3145.0 1969-12-31 15:59:49.146 3145 NULL NULL NULL NULL NULL 10.175 23.0 -46.0 -46.0 9891025.0 -3145.0 NULL NULL -3145 NULL -2786.0 -3145 +253665376 NULL 1cGVWH7n1QU true 61.0 14806.0 1969-12-31 15:59:48.832 14806 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 2.19217636E8 -14806.0 NULL NULL -14806 NULL -14447.0 -14806 +253665376 NULL 1cGVWH7n1QU true -56.0 5000.0 1969-12-31 15:59:56.166 5000 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.5E7 -5000.0 NULL NULL -5000 NULL -4641.0 -5000 +253665376 NULL 1cGVWH7n1QU true -34.0 16276.0 1969-12-31 15:59:56.146 16276 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 2.64908176E8 -16276.0 NULL NULL -16276 NULL -15917.0 -16276 +253665376 NULL 1cGVWH7n1QU true NULL 2834.0 1969-12-31 15:59:48.539 2834 NULL NULL NULL NULL NULL NULL NULL NULL NULL 8031556.0 -2834.0 NULL NULL -2834 NULL -2475.0 -2834 +253665376 NULL 1cGVWH7n1QU true 53.0 2922.0 1969-12-31 15:59:50.305 2922 NULL NULL NULL NULL NULL 10.175 -53.0 106.0 106.0 8538084.0 -2922.0 NULL NULL -2922 NULL -2563.0 -2922 +253665376 NULL 1cGVWH7n1QU true -22.0 3522.0 1969-12-31 15:59:50.516 3522 NULL NULL NULL NULL NULL 10.175 22.0 -44.0 -44.0 1.2404484E7 -3522.0 NULL NULL -3522 NULL -3163.0 -3522 +253665376 NULL 1cGVWH7n1QU true -38.0 4153.0 1969-12-31 15:59:49.148 4153 NULL NULL NULL NULL NULL 10.175 38.0 -76.0 -76.0 1.7247409E7 -4153.0 NULL NULL -4153 NULL -3794.0 -4153 +253665376 NULL 1cGVWH7n1QU true -53.0 2710.0 1969-12-31 15:59:56.323 2710 NULL NULL NULL NULL NULL 10.175 53.0 -106.0 -106.0 7344100.0 -2710.0 NULL NULL -2710 NULL -2351.0 -2710 +253665376 NULL 1cGVWH7n1QU true -9.0 10576.0 1969-12-31 15:59:56.255 10576 NULL NULL NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 1.11851776E8 -10576.0 NULL NULL -10576 NULL -10217.0 -10576 +253665376 NULL 1cGVWH7n1QU true -18.0 12400.0 1969-12-31 15:59:45.217 12400 NULL NULL NULL NULL NULL 10.175 18.0 -36.0 -36.0 1.5376E8 -12400.0 NULL NULL -12400 NULL -12041.0 -12400 +253665376 NULL 1cGVWH7n1QU true 19.0 14761.0 1969-12-31 15:59:54.835 14761 NULL NULL NULL NULL NULL 10.175 -19.0 38.0 38.0 2.17887121E8 -14761.0 NULL NULL -14761 NULL -14402.0 -14761 +253665376 NULL 1cGVWH7n1QU true 23.0 14822.0 1969-12-31 15:59:49.275 14822 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 2.19691684E8 -14822.0 NULL NULL -14822 NULL -14463.0 -14822 +253665376 NULL 1cGVWH7n1QU true 42.0 5654.0 1969-12-31 15:59:50.045 5654 NULL NULL NULL NULL NULL 10.175 -42.0 84.0 84.0 3.1967716E7 -5654.0 NULL NULL -5654 NULL -5295.0 -5654 +253665376 NULL 1cGVWH7n1QU true 15.0 5406.0 1969-12-31 15:59:54.463 5406 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 2.9224836E7 -5406.0 NULL NULL -5406 NULL -5047.0 -5406 +253665376 NULL 1cGVWH7n1QU true -59.0 5687.0 1969-12-31 15:59:56.192 5687 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 3.2341969E7 -5687.0 NULL NULL -5687 NULL -5328.0 -5687 +253665376 NULL 1cGVWH7n1QU true 27.0 5323.0 1969-12-31 15:59:52.588 5323 NULL NULL NULL NULL NULL 10.175 -27.0 54.0 54.0 2.8334329E7 -5323.0 NULL NULL -5323 NULL -4964.0 -5323 +253665376 NULL 1cGVWH7n1QU true 60.0 6666.0 1969-12-31 15:59:55.166 6666 NULL NULL NULL NULL NULL 10.175 -60.0 120.0 120.0 4.4435556E7 -6666.0 NULL NULL -6666 NULL -6307.0 -6666 +253665376 NULL 1cGVWH7n1QU true 22.0 8683.0 1969-12-31 15:59:51.95 8683 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 7.5394489E7 -8683.0 NULL NULL -8683 NULL -8324.0 -8683 +253665376 NULL 1cGVWH7n1QU true -40.0 7636.0 1969-12-31 15:59:52.511 7636 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 5.8308496E7 -7636.0 NULL NULL -7636 NULL -7277.0 -7636 +253665376 NULL 1cGVWH7n1QU true -46.0 6802.0 1969-12-31 15:59:52.106 6802 NULL NULL NULL NULL NULL 10.175 46.0 -92.0 -92.0 4.6267204E7 -6802.0 NULL NULL -6802 NULL -6443.0 -6802 +253665376 NULL 1cGVWH7n1QU true -41.0 16219.0 1969-12-31 15:59:58.003 16219 NULL NULL NULL NULL NULL 10.175 41.0 -82.0 -82.0 2.63055961E8 -16219.0 NULL NULL -16219 NULL -15860.0 -16219 +253665376 NULL 1cGVWH7n1QU true -15.0 3152.0 1969-12-31 15:59:58.664 3152 NULL NULL NULL NULL NULL 10.175 15.0 -30.0 -30.0 9935104.0 -3152.0 NULL NULL -3152 NULL -2793.0 -3152 +253665376 NULL 1cGVWH7n1QU true 23.0 12526.0 1969-12-31 15:59:57.08 12526 NULL NULL NULL NULL NULL 10.175 -23.0 46.0 46.0 1.56900676E8 -12526.0 NULL NULL -12526 NULL -12167.0 -12526 +253665376 NULL 1cGVWH7n1QU true -34.0 6090.0 1969-12-31 15:59:45.435 6090 NULL NULL NULL NULL NULL 10.175 34.0 -68.0 -68.0 3.70881E7 -6090.0 NULL NULL -6090 NULL -5731.0 -6090 +253665376 NULL 1cGVWH7n1QU true -9.0 12348.0 1969-12-31 15:59:57.68 12348 NULL NULL NULL NULL NULL 1.1750000000000007 9.0 -18.0 -18.0 1.52473104E8 -12348.0 NULL NULL -12348 NULL -11989.0 -12348 +253665376 NULL 1cGVWH7n1QU true -21.0 13684.0 1969-12-31 15:59:56.519 13684 NULL NULL NULL NULL NULL 10.175 21.0 -42.0 -42.0 1.87251856E8 -13684.0 NULL NULL -13684 NULL -13325.0 -13684 +253665376 NULL 1cGVWH7n1QU true -13.0 3799.0 1969-12-31 15:59:57.508 3799 NULL NULL NULL NULL NULL 10.175 13.0 -26.0 -26.0 1.4432401E7 -3799.0 NULL NULL -3799 NULL -3440.0 -3799 +253665376 NULL 1cGVWH7n1QU true 58.0 15549.0 1969-12-31 15:59:53.046 15549 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 2.41771401E8 -15549.0 NULL NULL -15549 NULL -15190.0 -15549 +253665376 NULL 1cGVWH7n1QU true -52.0 7599.0 1969-12-31 15:59:46.329 7599 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 5.7744801E7 -7599.0 NULL NULL -7599 NULL -7240.0 -7599 +253665376 NULL 1cGVWH7n1QU true -51.0 15101.0 1969-12-31 15:59:54.249 15101 NULL NULL NULL NULL NULL 10.175 51.0 -102.0 -102.0 2.28040201E8 -15101.0 NULL NULL -15101 NULL -14742.0 -15101 +253665376 NULL 1cGVWH7n1QU true -60.0 11579.0 1969-12-31 15:59:57.433 11579 NULL NULL NULL NULL NULL 10.175 60.0 -120.0 -120.0 1.34073241E8 -11579.0 NULL NULL -11579 NULL -11220.0 -11579 +253665376 NULL 1cGVWH7n1QU true 4.0 7287.0 1969-12-31 15:59:57.587 7287 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 5.3100369E7 -7287.0 NULL NULL -7287 NULL -6928.0 -7287 +253665376 NULL 1cGVWH7n1QU true 15.0 11459.0 1969-12-31 15:59:58.572 11459 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 1.31308681E8 -11459.0 NULL NULL -11459 NULL -11100.0 -11459 +253665376 NULL 1cGVWH7n1QU true 13.0 8549.0 1969-12-31 15:59:54.49 8549 NULL NULL NULL NULL NULL 10.175 -13.0 26.0 26.0 7.3085401E7 -8549.0 NULL NULL -8549 NULL -8190.0 -8549 +253665376 NULL 1cGVWH7n1QU true 46.0 7207.0 1969-12-31 15:59:54.71 7207 NULL NULL NULL NULL NULL 10.175 -46.0 92.0 92.0 5.1940849E7 -7207.0 NULL NULL -7207 NULL -6848.0 -7207 +253665376 NULL 1cGVWH7n1QU true -11.0 2601.0 1969-12-31 15:59:54.053 2601 NULL NULL NULL NULL NULL 10.175 11.0 -22.0 -22.0 6765201.0 -2601.0 NULL NULL -2601 NULL -2242.0 -2601 +253665376 NULL 1cGVWH7n1QU true -62.0 15153.0 1969-12-31 15:59:46.865 15153 NULL NULL NULL NULL NULL 10.175 62.0 -124.0 -124.0 2.29613409E8 -15153.0 NULL NULL -15153 NULL -14794.0 -15153 +253665376 NULL 1cGVWH7n1QU true 61.0 2986.0 1969-12-31 15:59:50.399 2986 NULL NULL NULL NULL NULL 10.175 -61.0 122.0 122.0 8916196.0 -2986.0 NULL NULL -2986 NULL -2627.0 -2986 +253665376 NULL 1cGVWH7n1QU true 40.0 3192.0 1969-12-31 15:59:58.167 3192 NULL NULL NULL NULL NULL 10.175 -40.0 80.0 80.0 1.0188864E7 -3192.0 NULL NULL -3192 NULL -2833.0 -3192 +253665376 NULL 1cGVWH7n1QU true 58.0 6823.0 1969-12-31 15:59:55.94 6823 NULL NULL NULL NULL NULL 10.175 -58.0 116.0 116.0 4.6553329E7 -6823.0 NULL NULL -6823 NULL -6464.0 -6823 +253665376 NULL 1cGVWH7n1QU true 28.0 16337.0 1969-12-31 15:59:53.09 16337 NULL NULL NULL NULL NULL 10.175 -28.0 56.0 56.0 2.66897569E8 -16337.0 NULL NULL -16337 NULL -15978.0 -16337 +253665376 NULL 1cGVWH7n1QU true -36.0 12136.0 1969-12-31 15:59:50.537 12136 NULL NULL NULL NULL NULL 10.175 36.0 -72.0 -72.0 1.47282496E8 -12136.0 NULL NULL -12136 NULL -11777.0 -12136 +253665376 NULL 1cGVWH7n1QU true 21.0 14388.0 1969-12-31 15:59:43.76 14388 NULL NULL NULL NULL NULL 10.175 -21.0 42.0 42.0 2.07014544E8 -14388.0 NULL NULL -14388 NULL -14029.0 -14388 +253665376 NULL 1cGVWH7n1QU true 8.0 15324.0 1969-12-31 15:59:50.574 15324 NULL NULL NULL NULL NULL 2.1750000000000007 -8.0 16.0 16.0 2.34824976E8 -15324.0 NULL NULL -15324 NULL -14965.0 -15324 +253665376 NULL 1cGVWH7n1QU true -30.0 10058.0 1969-12-31 15:59:49.359 10058 NULL NULL NULL NULL NULL 10.175 30.0 -60.0 -60.0 1.01163364E8 -10058.0 NULL NULL -10058 NULL -9699.0 -10058 +253665376 NULL 1cGVWH7n1QU true -52.0 8868.0 1969-12-31 15:59:45.116 8868 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 7.8641424E7 -8868.0 NULL NULL -8868 NULL -8509.0 -8868 +253665376 NULL 1cGVWH7n1QU true -16.0 2933.0 1969-12-31 15:59:48.166 2933 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 8602489.0 -2933.0 NULL NULL -2933 NULL -2574.0 -2933 +253665376 NULL 1cGVWH7n1QU true -57.0 9388.0 1969-12-31 15:59:47.272 9388 NULL NULL NULL NULL NULL 10.175 57.0 -114.0 -114.0 8.8134544E7 -9388.0 NULL NULL -9388 NULL -9029.0 -9388 +253665376 NULL 1cGVWH7n1QU true -60.0 8341.0 1969-12-31 15:59:57.368 8341 NULL NULL NULL NULL NULL 10.175 60.0 -120.0 -120.0 6.9572281E7 -8341.0 NULL NULL -8341 NULL -7982.0 -8341 +253665376 NULL 1cGVWH7n1QU true -10.0 13078.0 1969-12-31 15:59:51.062 13078 NULL NULL NULL NULL NULL 0.1750000000000007 10.0 -20.0 -20.0 1.71034084E8 -13078.0 NULL NULL -13078 NULL -12719.0 -13078 +253665376 NULL 1cGVWH7n1QU true 53.0 14889.0 1969-12-31 15:59:45.016 14889 NULL NULL NULL NULL NULL 10.175 -53.0 106.0 106.0 2.21682321E8 -14889.0 NULL NULL -14889 NULL -14530.0 -14889 +253665376 NULL 1cGVWH7n1QU true 33.0 9476.0 1969-12-31 15:59:44.728 9476 NULL NULL NULL NULL NULL 10.175 -33.0 66.0 66.0 8.9794576E7 -9476.0 NULL NULL -9476 NULL -9117.0 -9476 +253665376 NULL 1cGVWH7n1QU true -39.0 3958.0 1969-12-31 15:59:44.717 3958 NULL NULL NULL NULL NULL 10.175 39.0 -78.0 -78.0 1.5665764E7 -3958.0 NULL NULL -3958 NULL -3599.0 -3958 +253665376 NULL 1cGVWH7n1QU true 52.0 6923.0 1969-12-31 15:59:58.534 6923 NULL NULL NULL NULL NULL 10.175 -52.0 104.0 104.0 4.7927929E7 -6923.0 NULL NULL -6923 NULL -6564.0 -6923 +253665376 NULL 1cGVWH7n1QU true -21.0 3847.0 1969-12-31 15:59:56.289 3847 NULL NULL NULL NULL NULL 10.175 21.0 -42.0 -42.0 1.4799409E7 -3847.0 NULL NULL -3847 NULL -3488.0 -3847 +253665376 NULL 1cGVWH7n1QU true -30.0 13978.0 1969-12-31 15:59:50.041 13978 NULL NULL NULL NULL NULL 10.175 30.0 -60.0 -60.0 1.95384484E8 -13978.0 NULL NULL -13978 NULL -13619.0 -13978 +253665376 NULL 1cGVWH7n1QU true 50.0 4261.0 1969-12-31 15:59:51.358 4261 NULL NULL NULL NULL NULL 10.175 -50.0 100.0 100.0 1.8156121E7 -4261.0 NULL NULL -4261 NULL -3902.0 -4261 +253665376 NULL 1cGVWH7n1QU true 13.0 4151.0 1969-12-31 15:59:47.459 4151 NULL NULL NULL NULL NULL 10.175 -13.0 26.0 26.0 1.7230801E7 -4151.0 NULL NULL -4151 NULL -3792.0 -4151 +253665376 NULL 1cGVWH7n1QU true -62.0 12420.0 1969-12-31 15:59:56.9 12420 NULL NULL NULL NULL NULL 10.175 62.0 -124.0 -124.0 1.542564E8 -12420.0 NULL NULL -12420 NULL -12061.0 -12420 +253665376 NULL 1cGVWH7n1QU true -24.0 5645.0 1969-12-31 15:59:49.108 5645 NULL NULL NULL NULL NULL 10.175 24.0 -48.0 -48.0 3.1866025E7 -5645.0 NULL NULL -5645 NULL -5286.0 -5645 +253665376 NULL 1cGVWH7n1QU true 54.0 13117.0 1969-12-31 15:59:58.443 13117 NULL NULL NULL NULL NULL 10.175 -54.0 108.0 108.0 1.72055689E8 -13117.0 NULL NULL -13117 NULL -12758.0 -13117 +253665376 NULL 1cGVWH7n1QU true 55.0 12269.0 1969-12-31 15:59:49.067 12269 NULL NULL NULL NULL NULL 10.175 -55.0 110.0 110.0 1.50528361E8 -12269.0 NULL NULL -12269 NULL -11910.0 -12269 +253665376 NULL 1cGVWH7n1QU true -37.0 6898.0 1969-12-31 15:59:56.773 6898 NULL NULL NULL NULL NULL 10.175 37.0 -74.0 -74.0 4.7582404E7 -6898.0 NULL NULL -6898 NULL -6539.0 -6898 +253665376 NULL 1cGVWH7n1QU true -16.0 10553.0 1969-12-31 15:59:53.348 10553 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 1.11365809E8 -10553.0 NULL NULL -10553 NULL -10194.0 -10553 +253665376 NULL 1cGVWH7n1QU true 6.0 7182.0 1969-12-31 15:59:54.331 7182 NULL NULL NULL NULL NULL 4.175000000000001 -6.0 12.0 12.0 5.1581124E7 -7182.0 NULL NULL -7182 NULL -6823.0 -7182 +253665376 NULL 1cGVWH7n1QU true -61.0 8031.0 1969-12-31 15:59:49.909 8031 NULL NULL NULL NULL NULL 10.175 61.0 -122.0 -122.0 6.4496961E7 -8031.0 NULL NULL -8031 NULL -7672.0 -8031 +253665376 NULL 1cGVWH7n1QU true -40.0 16352.0 1969-12-31 15:59:52.028 16352 NULL NULL NULL NULL NULL 10.175 40.0 -80.0 -80.0 2.67387904E8 -16352.0 NULL NULL -16352 NULL -15993.0 -16352 +253665376 NULL 1cGVWH7n1QU true 22.0 10174.0 1969-12-31 15:59:48.296 10174 NULL NULL NULL NULL NULL 10.175 -22.0 44.0 44.0 1.03510276E8 -10174.0 NULL NULL -10174 NULL -9815.0 -10174 +253665376 NULL 1cGVWH7n1QU true -52.0 3797.0 1969-12-31 15:59:52.835 3797 NULL NULL NULL NULL NULL 10.175 52.0 -104.0 -104.0 1.4417209E7 -3797.0 NULL NULL -3797 NULL -3438.0 -3797 +253665376 NULL 1cGVWH7n1QU true 24.0 16189.0 1969-12-31 15:59:54.119 16189 NULL NULL NULL NULL NULL 10.175 -24.0 48.0 48.0 2.62083721E8 -16189.0 NULL NULL -16189 NULL -15830.0 -16189 +253665376 NULL 1cGVWH7n1QU true -45.0 4617.0 1969-12-31 15:59:51.17 4617 NULL NULL NULL NULL NULL 10.175 45.0 -90.0 -90.0 2.1316689E7 -4617.0 NULL NULL -4617 NULL -4258.0 -4617 +253665376 NULL 1cGVWH7n1QU true 13.0 11673.0 1969-12-31 15:59:49.035 11673 NULL NULL NULL NULL NULL 10.175 -13.0 26.0 26.0 1.36258929E8 -11673.0 NULL NULL -11673 NULL -11314.0 -11673 +253665376 NULL 1cGVWH7n1QU true -56.0 15509.0 1969-12-31 15:59:52.567 15509 NULL NULL NULL NULL NULL 10.175 56.0 -112.0 -112.0 2.40529081E8 -15509.0 NULL NULL -15509 NULL -15150.0 -15509 +253665376 NULL 1cGVWH7n1QU true -39.0 14872.0 1969-12-31 15:59:47.69 14872 NULL NULL NULL NULL NULL 10.175 39.0 -78.0 -78.0 2.21176384E8 -14872.0 NULL NULL -14872 NULL -14513.0 -14872 +253665376 NULL 1cGVWH7n1QU true -16.0 11350.0 1969-12-31 15:59:58.273 11350 NULL NULL NULL NULL NULL 10.175 16.0 -32.0 -32.0 1.288225E8 -11350.0 NULL NULL -11350 NULL -10991.0 -11350 +253665376 NULL 1cGVWH7n1QU true -47.0 12034.0 1969-12-31 15:59:44.109 12034 NULL NULL NULL NULL NULL 10.175 47.0 -94.0 -94.0 1.44817156E8 -12034.0 NULL NULL -12034 NULL -11675.0 -12034 +253665376 NULL 1cGVWH7n1QU true 10.0 9373.0 1969-12-31 15:59:54.779 9373 NULL NULL NULL NULL NULL 0.1750000000000007 -10.0 20.0 20.0 8.7853129E7 -9373.0 NULL NULL -9373 NULL -9014.0 -9373 +253665376 NULL 1cGVWH7n1QU true -15.0 7813.0 1969-12-31 15:59:53.167 7813 NULL NULL NULL NULL NULL 10.175 15.0 -30.0 -30.0 6.1042969E7 -7813.0 NULL NULL -7813 NULL -7454.0 -7813 +253665376 NULL 1cGVWH7n1QU true 49.0 12363.0 1969-12-31 15:59:49.932 12363 NULL NULL NULL NULL NULL 10.175 -49.0 98.0 98.0 1.52843769E8 -12363.0 NULL NULL -12363 NULL -12004.0 -12363 +253665376 NULL 1cGVWH7n1QU true -49.0 3815.0 1969-12-31 15:59:49.91 3815 NULL NULL NULL NULL NULL 10.175 49.0 -98.0 -98.0 1.4554225E7 -3815.0 NULL NULL -3815 NULL -3456.0 -3815 +253665376 NULL 1cGVWH7n1QU true 47.0 5190.0 1969-12-31 15:59:49.921 5190 NULL NULL NULL NULL NULL 10.175 -47.0 94.0 94.0 2.69361E7 -5190.0 NULL NULL -5190 NULL -4831.0 -5190 +253665376 NULL 1cGVWH7n1QU true -59.0 16270.0 1969-12-31 15:59:53.721 16270 NULL NULL NULL NULL NULL 10.175 59.0 -118.0 -118.0 2.647129E8 -16270.0 NULL NULL -16270 NULL -15911.0 -16270 +253665376 NULL 1cGVWH7n1QU true 7.0 4673.0 1969-12-31 15:59:53.738 4673 NULL NULL NULL NULL NULL 3.1750000000000007 -7.0 14.0 14.0 2.1836929E7 -4673.0 NULL NULL -4673 NULL -4314.0 -4673 +253665376 NULL 1cGVWH7n1QU true NULL 7914.0 1969-12-31 15:59:57.663 7914 NULL NULL NULL NULL NULL NULL NULL NULL NULL 6.2631396E7 -7914.0 NULL NULL -7914 NULL -7555.0 -7914 +253665376 NULL 1cGVWH7n1QU true -28.0 13833.0 1969-12-31 15:59:44.235 13833 NULL NULL NULL NULL NULL 10.175 28.0 -56.0 -56.0 1.91351889E8 -13833.0 NULL NULL -13833 NULL -13474.0 -13833 +253665376 NULL 1cGVWH7n1QU true 15.0 9235.0 1969-12-31 15:59:44.542 9235 NULL NULL NULL NULL NULL 10.175 -15.0 30.0 30.0 8.5285225E7 -9235.0 NULL NULL -9235 NULL -8876.0 -9235 +253665376 NULL 1cGVWH7n1QU true 4.0 3725.0 1969-12-31 15:59:49.71 3725 NULL NULL NULL NULL NULL 2.1750000000000007 -4.0 8.0 8.0 1.3875625E7 -3725.0 NULL NULL -3725 NULL -3366.0 -3725 +253665376 NULL 1cGVWH7n1QU true 19.0 12183.0 1969-12-31 15:59:58.417 12183 NULL NULL NULL NULL NULL 10.175 -19.0 38.0 38.0 1.48425489E8 -12183.0 NULL NULL -12183 NULL -11824.0 -12183 +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- TargetTypeClasses: String, Bool, Double, Long, Timestamp +-- Functions: Sum, Max, Avg, Var, StDevP, VarP +-- ArithmeticOps: Add, Subtract, Divide, Multiply, Remainder +-- FilterOps: NotEqual, GreaterThanOrEqual, Like, LessThanOrEqual, Equal, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: String, Bool, Double, Long, Timestamp +-- Functions: Sum, Max, Avg, Var, StDevP, VarP +-- ArithmeticOps: Add, Subtract, Divide, Multiply, Remainder +-- FilterOps: NotEqual, GreaterThanOrEqual, Like, LessThanOrEqual, Equal, GreaterThan +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL cint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean2)) (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp2)) (TOK_SELEXPR (TOK_TABLE_OR_COL cdouble)) (TOK_SELEXPR (TOK_TABLE_OR_COL cfloat)) (TOK_SELEXPR (TOK_TABLE_OR_COL cbigint)) (TOK_SELEXPR (TOK_TABLE_OR_COL csmallint)) (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean1)) (TOK_SELEXPR (+ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (+ (- (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL ctinyint)) (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (/ (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (* (+ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL csmallint)) (- (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (+ (- (TOK_TABLE_OR_COL cdouble)) (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (/ (- 1.389) (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (% (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (+ (TOK_TABLE_OR_COL csmallint) (+ (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL csmallint))))) (TOK_WHERE (OR (OR (OR (AND (> (TOK_TABLE_OR_COL csmallint) (- 26.28)) (LIKE (TOK_TABLE_OR_COL cstring2) 'ss')) (AND (<= (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cbigint)) (AND (>= (TOK_TABLE_OR_COL cstring1) 'ss') (!= (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cdouble))))) (= (TOK_TABLE_OR_COL ctinyint) (- 89010))) (AND (<= (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL cfloat)) (<= (- 26.28) (TOK_TABLE_OR_COL csmallint))))) (TOK_ORDERBY (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cboolean1)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cstring1)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL ctimestamp2)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cfloat)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cbigint)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cstring1)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cdouble)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cint)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL csmallint)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cdouble))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (((((csmallint > (- 26.28)) and (cstring2 like 'ss')) or ((cdouble <= cbigint) and ((cstring1 >= 'ss') and (cint <> cdouble)))) or (ctinyint = (- 89010))) or ((cbigint <= cfloat) and ((- 26.28) <= csmallint))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cint + type: int + expr: cstring1 + type: string + expr: cboolean2 + type: boolean + expr: ctimestamp2 + type: timestamp + expr: cdouble + type: double + expr: cfloat + type: float + expr: cbigint + type: bigint + expr: csmallint + type: smallint + expr: cboolean1 + type: boolean + expr: (cint + csmallint) + type: int + expr: (cbigint - ctinyint) + type: bigint + expr: (- cbigint) + type: bigint + expr: (- cfloat) + type: float + expr: ((cbigint - ctinyint) + cbigint) + type: bigint + expr: (cdouble / cdouble) + type: double + expr: (- cdouble) + type: double + expr: ((cint + csmallint) * (- cbigint)) + type: bigint + expr: ((- cdouble) + cbigint) + type: double + expr: ((- 1.389) / ctinyint) + type: double + expr: (cbigint % cdouble) + type: double + expr: (- csmallint) + type: smallint + expr: (csmallint + (cint + csmallint)) + type: int + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col8 + type: boolean + expr: _col1 + type: string + expr: _col3 + type: timestamp + expr: _col5 + type: float + expr: _col6 + type: bigint + expr: _col1 + type: string + expr: _col4 + type: double + expr: _col0 + type: int + expr: _col7 + type: smallint + expr: _col4 + type: double + sort order: ++++++++++ + tag: -1 + value expressions: + expr: _col0 + type: int + expr: _col1 + type: string + expr: _col2 + type: boolean + expr: _col3 + type: timestamp + expr: _col4 + type: double + expr: _col5 + type: float + expr: _col6 + type: bigint + expr: _col7 + type: smallint + expr: _col8 + type: boolean + expr: _col9 + type: int + expr: _col10 + type: bigint + expr: _col11 + type: bigint + expr: _col12 + type: float + expr: _col13 + type: bigint + expr: _col14 + type: double + expr: _col15 + type: double + expr: _col16 + type: bigint + expr: _col17 + type: double + expr: _col18 + type: double + expr: _col19 + type: double + expr: _col20 + type: smallint + expr: _col21 + type: int + Vectorized execution: true + Reduce Operator Tree: + Extract + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT cint, + cstring1, + cboolean2, + ctimestamp2, + cdouble, + cfloat, + cbigint, + csmallint, + cboolean1, + (cint + csmallint), + (cbigint - ctinyint), + (-(cbigint)), + (-(cfloat)), + ((cbigint - ctinyint) + cbigint), + (cdouble / cdouble), + (-(cdouble)), + ((cint + csmallint) * (-(cbigint))), + ((-(cdouble)) + cbigint), + (-1.389 / ctinyint), + (cbigint % cdouble), + (-(csmallint)), + (csmallint + (cint + csmallint)) +FROM alltypesorc +WHERE (((csmallint > -26.28) + AND (cstring2 LIKE 'ss')) + OR ((cdouble <= cbigint) + AND ((cstring1 >= 'ss') + AND (cint != cdouble))) + OR (ctinyint = -89010) + OR ((cbigint <= cfloat) + AND (-26.28 <= csmallint))) +ORDER BY cboolean1, cstring1, ctimestamp2, cfloat, cbigint, cstring1, cdouble, cint, csmallint, cdouble +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -64.0 -1809291815 15601 NULL NULL -1809291751 1809291815 64.0 -3618583566 1.0 -15601.0 NULL -1.809307416E9 0.021703125 -12643.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -63.0 -1996001975 15601 NULL NULL -1996001912 1996001975 63.0 -3992003887 1.0 -15601.0 NULL -1.996017576E9 0.02204761904761905 -10035.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -63.0 -1574729892 15601 NULL NULL -1574729829 1574729892 63.0 -3149459721 1.0 -15601.0 NULL -1.574745493E9 0.02204761904761905 -11755.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -63.0 -1167054574 15601 NULL NULL -1167054511 1167054574 63.0 -2334109085 1.0 -15601.0 NULL -1.167070175E9 0.02204761904761905 -6168.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -63.0 -721244708 15601 NULL NULL -721244645 721244708 63.0 -1442489353 1.0 -15601.0 NULL -7.21260309E8 0.02204761904761905 -10478.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -63.0 -200542601 15601 NULL NULL -200542538 200542601 63.0 -401085139 1.0 -15601.0 NULL -2.00558202E8 0.02204761904761905 -7347.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -62.0 -1726415169 15601 NULL NULL -1726415107 1726415169 62.0 -3452830276 1.0 -15601.0 NULL -1.72643077E9 0.022403225806451613 -8509.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -62.0 -1592016120 15601 NULL NULL -1592016058 1592016120 62.0 -3184032178 1.0 -15601.0 NULL -1.592031721E9 0.022403225806451613 -12075.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -62.0 667693308 15601 NULL NULL 667693370 -667693308 62.0 1335386678 1.0 -15601.0 NULL 6.67677707E8 0.022403225806451613 1710.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -61.0 -1022679553 15601 NULL NULL -1022679492 1022679553 61.0 -2045359045 1.0 -15601.0 NULL -1.022695154E9 0.02277049180327869 -2801.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -61.0 -982179838 15601 NULL NULL -982179777 982179838 61.0 -1964359615 1.0 -15601.0 NULL -9.82195439E8 0.02277049180327869 -3282.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -61.0 -854893578 15601 NULL NULL -854893517 854893578 61.0 -1709787095 1.0 -15601.0 NULL -8.54909179E8 0.02277049180327869 -5581.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -60.0 -2041965187 15601 NULL NULL -2041965127 2041965187 60.0 -4083930314 1.0 -15601.0 NULL -2.041980788E9 0.02315 -12701.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -60.0 -1743144280 15601 NULL NULL -1743144220 1743144280 60.0 -3486288500 1.0 -15601.0 NULL -1.743159881E9 0.02315 -13348.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -60.0 -1016256928 15601 NULL NULL -1016256868 1016256928 60.0 -2032513796 1.0 -15601.0 NULL -1.016272529E9 0.02315 -7788.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -60.0 -903925845 15601 NULL NULL -903925785 903925845 60.0 -1807851630 1.0 -15601.0 NULL -9.03941446E8 0.02315 -3905.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -60.0 -519753851 15601 NULL NULL -519753791 519753851 60.0 -1039507642 1.0 -15601.0 NULL -5.19769452E8 0.02315 -6536.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -60.0 -5953872 15601 NULL NULL -5953812 5953872 60.0 -11907684 1.0 -15601.0 NULL -5969473.0 0.02315 -9891.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -59.0 -2021724111 15601 NULL NULL -2021724052 2021724111 59.0 -4043448163 1.0 -15601.0 NULL -2.021739712E9 0.02354237288135593 -6122.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -59.0 -1315413812 15601 NULL NULL -1315413753 1315413812 59.0 -2630827565 1.0 -15601.0 NULL -1.315429413E9 0.02354237288135593 -15497.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -59.0 -133287350 15601 NULL NULL -133287291 133287350 59.0 -266574641 1.0 -15601.0 NULL -1.33302951E8 0.02354237288135593 -8007.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -58.0 -1560616588 15601 NULL NULL -1560616530 1560616588 58.0 -3121233118 1.0 -15601.0 NULL -1.560632189E9 0.023948275862068966 -1755.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -58.0 -1072335429 15601 NULL NULL -1072335371 1072335429 58.0 -2144670800 1.0 -15601.0 NULL -1.07235103E9 0.023948275862068966 -694.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -57.0 -2123576095 15601 NULL NULL -2123576038 2123576095 57.0 -4247152133 1.0 -15601.0 NULL -2.123591696E9 0.02436842105263158 -14778.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -57.0 -1698345590 15601 NULL NULL -1698345533 1698345590 57.0 -3396691123 1.0 -15601.0 NULL -1.698361191E9 0.02436842105263158 -5129.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -57.0 -1057361026 15601 NULL NULL -1057360969 1057361026 57.0 -2114721995 1.0 -15601.0 NULL -1.057376627E9 0.02436842105263158 -3251.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -57.0 -585350546 15601 NULL NULL -585350489 585350546 57.0 -1170701035 1.0 -15601.0 NULL -5.85366147E8 0.02436842105263158 -1026.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -57.0 -365505703 15601 NULL NULL -365505646 365505703 57.0 -731011349 1.0 -15601.0 NULL -3.65521304E8 0.02436842105263158 -5475.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -57.0 -304247740 15601 NULL NULL -304247683 304247740 57.0 -608495423 1.0 -15601.0 NULL -3.04263341E8 0.02436842105263158 -12639.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -56.0 -1683701844 15601 NULL NULL -1683701788 1683701844 56.0 -3367403632 1.0 -15601.0 NULL -1.683717445E9 0.02480357142857143 -10722.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -56.0 -1466363382 15601 NULL NULL -1466363326 1466363382 56.0 -2932726708 1.0 -15601.0 NULL -1.466378983E9 0.02480357142857143 -9791.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -56.0 -1105322173 15601 NULL NULL -1105322117 1105322173 56.0 -2210644290 1.0 -15601.0 NULL -1.105337774E9 0.02480357142857143 -6924.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -56.0 -971846497 15601 NULL NULL -971846441 971846497 56.0 -1943692938 1.0 -15601.0 NULL -9.71862098E8 0.02480357142857143 -13404.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -56.0 -865054294 15601 NULL NULL -865054238 865054294 56.0 -1730108532 1.0 -15601.0 NULL -8.65069895E8 0.02480357142857143 -10046.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -55.0 -1483320156 15601 NULL NULL -1483320101 1483320156 55.0 -2966640257 1.0 -15601.0 NULL -1.483335757E9 0.025254545454545453 -8278.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -55.0 -1338667765 15601 NULL NULL -1338667710 1338667765 55.0 -2677335475 1.0 -15601.0 NULL -1.338683366E9 0.025254545454545453 -8359.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -55.0 -1062767051 15601 NULL NULL -1062766996 1062767051 55.0 -2125534047 1.0 -15601.0 NULL -1.062782652E9 0.025254545454545453 -11330.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -54.0 -1984659810 15601 NULL NULL -1984659756 1984659810 54.0 -3969319566 1.0 -15601.0 NULL -1.984675411E9 0.025722222222222223 -9797.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -54.0 -1795674990 15601 NULL NULL -1795674936 1795674990 54.0 -3591349926 1.0 -15601.0 NULL -1.795690591E9 0.025722222222222223 -15491.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -54.0 -1754189160 15601 NULL NULL -1754189106 1754189160 54.0 -3508378266 1.0 -15601.0 NULL -1.754204761E9 0.025722222222222223 -12720.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -54.0 -1114169807 15601 NULL NULL -1114169753 1114169807 54.0 -2228339560 1.0 -15601.0 NULL -1.114185408E9 0.025722222222222223 -8791.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -54.0 -989710558 15601 NULL NULL -989710504 989710558 54.0 -1979421062 1.0 -15601.0 NULL -9.89726159E8 0.025722222222222223 -14320.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -54.0 -641670659 15601 NULL NULL -641670605 641670659 54.0 -1283341264 1.0 -15601.0 NULL -6.4168626E8 0.025722222222222223 -1529.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -52.0 -2097289702 15601 NULL NULL -2097289650 2097289702 52.0 -4194579352 1.0 -15601.0 NULL -2.097305303E9 0.02671153846153846 -469.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -52.0 -2074134645 15601 NULL NULL -2074134593 2074134645 52.0 -4148269238 1.0 -15601.0 NULL -2.074150246E9 0.02671153846153846 -12897.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -52.0 -886068046 15601 NULL NULL -886067994 886068046 52.0 -1772136040 1.0 -15601.0 NULL -8.86083647E8 0.02671153846153846 -9251.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -51.0 -546830045 15601 NULL NULL -546829994 546830045 51.0 -1093660039 1.0 -15601.0 NULL -5.46845646E8 0.02723529411764706 -14995.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -50.0 -596103241 15601 NULL NULL -596103191 596103241 50.0 -1192206432 1.0 -15601.0 NULL -5.96118842E8 0.02778 -4632.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -50.0 -458110015 15601 NULL NULL -458109965 458110015 50.0 -916219980 1.0 -15601.0 NULL -4.58125616E8 0.02778 -2251.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -49.0 -1841324115 15601 NULL NULL -1841324066 1841324115 49.0 -3682648181 1.0 -15601.0 NULL -1.841339716E9 0.028346938775510203 -489.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -49.0 -990904667 15601 NULL NULL -990904618 990904667 49.0 -1981809285 1.0 -15601.0 NULL -9.90920268E8 0.028346938775510203 -7152.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -49.0 -668597606 15601 NULL NULL -668597557 668597606 49.0 -1337195163 1.0 -15601.0 NULL -6.68613207E8 0.028346938775510203 -1150.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -49.0 -230127703 15601 NULL NULL -230127654 230127703 49.0 -460255357 1.0 -15601.0 NULL -2.30143304E8 0.028346938775510203 -12953.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -49.0 -211726367 15601 NULL NULL -211726318 211726367 49.0 -423452685 1.0 -15601.0 NULL -2.11741968E8 0.028346938775510203 -5196.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -49.0 -197652849 15601 NULL NULL -197652800 197652849 49.0 -395305649 1.0 -15601.0 NULL -1.9766845E8 0.028346938775510203 -3780.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -49.0 -57200424 15601 NULL NULL -57200375 57200424 49.0 -114400799 1.0 -15601.0 NULL -5.7216025E7 0.028346938775510203 -7158.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -48.0 -1683400285 15601 NULL NULL -1683400237 1683400285 48.0 -3366800522 1.0 -15601.0 NULL -1.683415886E9 0.0289375 -5582.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -48.0 -1666377780 15601 NULL NULL -1666377732 1666377780 48.0 -3332755512 1.0 -15601.0 NULL -1.666393381E9 0.0289375 -3768.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -48.0 -1465907371 15601 NULL NULL -1465907323 1465907371 48.0 -2931814694 1.0 -15601.0 NULL -1.465922972E9 0.0289375 -6209.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -48.0 -1427685796 15601 NULL NULL -1427685748 1427685796 48.0 -2855371544 1.0 -15601.0 NULL -1.427701397E9 0.0289375 -7084.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -48.0 -1294837001 15601 NULL NULL -1294836953 1294837001 48.0 -2589673954 1.0 -15601.0 NULL -1.294852602E9 0.0289375 -804.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -48.0 -1228417392 15601 NULL NULL -1228417344 1228417392 48.0 -2456834736 1.0 -15601.0 NULL -1.228432993E9 0.0289375 -10253.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -48.0 -803222928 15601 NULL NULL -803222880 803222928 48.0 -1606445808 1.0 -15601.0 NULL -8.03238529E8 0.0289375 -5443.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -48.0 -652336471 15601 NULL NULL -652336423 652336471 48.0 -1304672894 1.0 -15601.0 NULL -6.52352072E8 0.0289375 -11858.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -47.0 -1828371599 15601 NULL NULL -1828371552 1828371599 47.0 -3656743151 1.0 -15601.0 NULL -1.8283872E9 0.029553191489361703 -12404.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -47.0 -493471535 15601 NULL NULL -493471488 493471535 47.0 -986943023 1.0 -15601.0 NULL -4.93487136E8 0.029553191489361703 -11905.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -47.0 -436916225 15601 NULL NULL -436916178 436916225 47.0 -873832403 1.0 -15601.0 NULL -4.36931826E8 0.029553191489361703 -10220.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -46.0 -468932050 15601 NULL NULL -468932004 468932050 46.0 -937864054 1.0 -15601.0 NULL -4.68947651E8 0.030195652173913044 -12793.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -46.0 -208932264 15601 NULL NULL -208932218 208932264 46.0 -417864482 1.0 -15601.0 NULL -2.08947865E8 0.030195652173913044 -3672.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -45.0 -1291025659 15601 NULL NULL -1291025614 1291025659 45.0 -2582051273 1.0 -15601.0 NULL -1.29104126E9 0.030866666666666667 -11707.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -45.0 -1022657523 15601 NULL NULL -1022657478 1022657523 45.0 -2045315001 1.0 -15601.0 NULL -1.022673124E9 0.030866666666666667 -11973.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -45.0 -831227593 15601 NULL NULL -831227548 831227593 45.0 -1662455141 1.0 -15601.0 NULL -8.31243194E8 0.030866666666666667 -6313.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -44.0 -1551649760 15601 NULL NULL -1551649716 1551649760 44.0 -3103299476 1.0 -15601.0 NULL -1.551665361E9 0.03156818181818182 -5502.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -1447719201 15601 NULL NULL -1447719157 1447719201 44.0 -2895438358 1.0 -15601.0 NULL -1.447734802E9 0.03156818181818182 -8805.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -44.0 -1416000760 15601 NULL NULL -1416000716 1416000760 44.0 -2832001476 1.0 -15601.0 NULL -1.416016361E9 0.03156818181818182 -7197.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -1032806869 15601 NULL NULL -1032806825 1032806869 44.0 -2065613694 1.0 -15601.0 NULL -1.03282247E9 0.03156818181818182 -5068.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -44.0 -772919195 15601 NULL NULL -772919151 772919195 44.0 -1545838346 1.0 -15601.0 NULL -7.72934796E8 0.03156818181818182 -14453.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -429050254 15601 NULL NULL -429050210 429050254 44.0 -858100464 1.0 -15601.0 NULL -4.29065855E8 0.03156818181818182 -7153.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -399793337 15601 NULL NULL -399793293 399793337 44.0 -799586630 1.0 -15601.0 NULL -3.99808938E8 0.03156818181818182 -2111.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -358755931 15601 NULL NULL -358755887 358755931 44.0 -717511818 1.0 -15601.0 NULL -3.58771532E8 0.03156818181818182 -10936.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -44.0 -75975416 15601 NULL NULL -75975372 75975416 44.0 -151950788 1.0 -15601.0 NULL -7.5991017E7 0.03156818181818182 -14147.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -43.0 -1111076337 15601 NULL NULL -1111076294 1111076337 43.0 -2222152631 1.0 -15601.0 NULL -1.111091938E9 0.03230232558139535 -4319.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -43.0 -223687300 15601 NULL NULL -223687257 223687300 43.0 -447374557 1.0 -15601.0 NULL -2.23702901E8 0.03230232558139535 -162.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -42.0 -2129158440 15601 NULL NULL -2129158398 2129158440 42.0 -4258316838 1.0 -15601.0 NULL -2.129174041E9 0.03307142857142857 -11965.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -42.0 -1434650528 15601 NULL NULL -1434650486 1434650528 42.0 -2869301014 1.0 -15601.0 NULL -1.434666129E9 0.03307142857142857 -13770.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -42.0 -1003335119 15601 NULL NULL -1003335077 1003335119 42.0 -2006670196 1.0 -15601.0 NULL -1.00335072E9 0.03307142857142857 -3607.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -42.0 -933775134 15601 NULL NULL -933775092 933775134 42.0 -1867550226 1.0 -15601.0 NULL -9.33790735E8 0.03307142857142857 -8481.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -41.0 -1512449609 15601 NULL NULL -1512449568 1512449609 41.0 -3024899177 1.0 -15601.0 NULL -1.51246521E9 0.03387804878048781 -10664.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -41.0 -1064437283 15601 NULL NULL -1064437242 1064437283 41.0 -2128874525 1.0 -15601.0 NULL -1.064452884E9 0.03387804878048781 -12255.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -41.0 -626924299 15601 NULL NULL -626924258 626924299 41.0 -1253848557 1.0 -15601.0 NULL -6.269399E8 0.03387804878048781 -13715.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -41.0 -560714683 15601 NULL NULL -560714642 560714683 41.0 -1121429325 1.0 -15601.0 NULL -5.60730284E8 0.03387804878048781 -14743.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -41.0 -480294523 15601 NULL NULL -480294482 480294523 41.0 -960589005 1.0 -15601.0 NULL -4.80310124E8 0.03387804878048781 -2137.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -40.0 -1723403466 15601 NULL NULL -1723403426 1723403466 40.0 -3446806892 1.0 -15601.0 NULL -1.723419067E9 0.034725 -7799.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -40.0 -1523633607 15601 NULL NULL -1523633567 1523633607 40.0 -3047267174 1.0 -15601.0 NULL -1.523649208E9 0.034725 -8745.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -40.0 -691840768 15601 NULL NULL -691840728 691840768 40.0 -1383681496 1.0 -15601.0 NULL -6.91856369E8 0.034725 -14423.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -40.0 -626007306 15601 NULL NULL -626007266 626007306 40.0 -1252014572 1.0 -15601.0 NULL -6.26022907E8 0.034725 -1580.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -39.0 -1651489748 15601 NULL NULL -1651489709 1651489748 39.0 -3302979457 1.0 -15601.0 NULL -1.651505349E9 0.03561538461538462 -14691.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -39.0 -775351902 15601 NULL NULL -775351863 775351902 39.0 -1550703765 1.0 -15601.0 NULL -7.75367503E8 0.03561538461538462 -13404.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -39.0 -682718731 15601 NULL NULL -682718692 682718731 39.0 -1365437423 1.0 -15601.0 NULL -6.82734332E8 0.03561538461538462 -3370.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -39.0 -176425309 15601 NULL NULL -176425270 176425309 39.0 -352850579 1.0 -15601.0 NULL -1.7644091E8 0.03561538461538462 -9201.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -38.0 -1858689000 15601 NULL NULL -1858688962 1858689000 38.0 -3717377962 1.0 -15601.0 NULL -1.858704601E9 0.03655263157894737 -1461.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -38.0 -1138820207 15601 NULL NULL -1138820169 1138820207 38.0 -2277640376 1.0 -15601.0 NULL -1.138835808E9 0.03655263157894737 -9611.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 -38.0 -6432 15601 NULL NULL -6394 6432 38.0 -12826 1.0 -15601.0 NULL -22033.0 0.03655263157894737 -6432.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -37.0 -1665990202 15601 NULL NULL -1665990165 1665990202 37.0 -3331980367 1.0 -15601.0 NULL -1.666005803E9 0.03754054054054054 -6215.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -37.0 -1474993355 15601 NULL NULL -1474993318 1474993355 37.0 -2949986673 1.0 -15601.0 NULL -1.475008956E9 0.03754054054054054 -12411.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -37.0 -1373443946 15601 NULL NULL -1373443909 1373443946 37.0 -2746887855 1.0 -15601.0 NULL -1.373459547E9 0.03754054054054054 -9911.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -37.0 -1274229243 15601 NULL NULL -1274229206 1274229243 37.0 -2548458449 1.0 -15601.0 NULL -1.274244844E9 0.03754054054054054 -1967.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -37.0 -218695361 15601 NULL NULL -218695324 218695361 37.0 -437390685 1.0 -15601.0 NULL -2.18710962E8 0.03754054054054054 -543.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -36.0 -1804756106 15601 NULL NULL -1804756070 1804756106 36.0 -3609512176 1.0 -15601.0 NULL -1.804771707E9 0.03858333333333333 -1224.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -36.0 -1655350680 15601 NULL NULL -1655350644 1655350680 36.0 -3310701324 1.0 -15601.0 NULL -1.655366281E9 0.03858333333333333 -6575.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -35.0 -1000935343 15601 NULL NULL -1000935308 1000935343 35.0 -2001870651 1.0 -15601.0 NULL -1.000950944E9 0.03968571428571429 -6385.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -35.0 -994591123 15601 NULL NULL -994591088 994591123 35.0 -1989182211 1.0 -15601.0 NULL -9.94606724E8 0.03968571428571429 -11772.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -35.0 -621636211 15601 NULL NULL -621636176 621636211 35.0 -1243272387 1.0 -15601.0 NULL -6.21651812E8 0.03968571428571429 -14366.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -34.0 -1225938733 15601 NULL NULL -1225938699 1225938733 34.0 -2451877432 1.0 -15601.0 NULL -1.225954334E9 0.04085294117647059 -12153.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -34.0 -1177680836 15601 NULL NULL -1177680802 1177680836 34.0 -2355361638 1.0 -15601.0 NULL -1.177696437E9 0.04085294117647059 -8149.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -34.0 -671949185 15601 NULL NULL -671949151 671949185 34.0 -1343898336 1.0 -15601.0 NULL -6.71964786E8 0.04085294117647059 -14115.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -33.0 -2080305624 15601 NULL NULL -2080305591 2080305624 33.0 -4160611215 1.0 -15601.0 NULL -2.080321225E9 0.04209090909090909 -5880.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -33.0 -1870761879 15601 NULL NULL -1870761846 1870761879 33.0 -3741523725 1.0 -15601.0 NULL -1.87077748E9 0.04209090909090909 -14767.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -33.0 -1583014792 15601 NULL NULL -1583014759 1583014792 33.0 -3166029551 1.0 -15601.0 NULL -1.583030393E9 0.04209090909090909 -12524.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -33.0 -1465766070 15601 NULL NULL -1465766037 1465766070 33.0 -2931532107 1.0 -15601.0 NULL -1.465781671E9 0.04209090909090909 -5317.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -33.0 -1447184932 15601 NULL NULL -1447184899 1447184932 33.0 -2894369831 1.0 -15601.0 NULL -1.447200533E9 0.04209090909090909 -4970.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -33.0 -226993201 15601 NULL NULL -226993168 226993201 33.0 -453986369 1.0 -15601.0 NULL -2.27008802E8 0.04209090909090909 -14252.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -33.0 -6432 15601 NULL NULL -6399 6432 33.0 -12831 1.0 -15601.0 NULL -22033.0 0.04209090909090909 -6432.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -32.0 -2105144474 15601 NULL NULL -2105144442 2105144474 32.0 -4210288916 1.0 -15601.0 NULL -2.105160075E9 0.04340625 -7938.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -32.0 -1864500604 15601 NULL NULL -1864500572 1864500604 32.0 -3729001176 1.0 -15601.0 NULL -1.864516205E9 0.04340625 -9493.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -32.0 -1473796341 15601 NULL NULL -1473796309 1473796341 32.0 -2947592650 1.0 -15601.0 NULL -1.473811942E9 0.04340625 -1073.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -32.0 -938739544 15601 NULL NULL -938739512 938739544 32.0 -1877479056 1.0 -15601.0 NULL -9.38755145E8 0.04340625 -11773.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -31.0 -2030835158 15601 NULL NULL -2030835127 2030835158 31.0 -4061670285 1.0 -15601.0 NULL -2.030850759E9 0.044806451612903225 -6185.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -31.0 -1784005728 15601 NULL NULL -1784005697 1784005728 31.0 -3568011425 1.0 -15601.0 NULL -1.784021329E9 0.044806451612903225 -176.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -31.0 -1357998994 15601 NULL NULL -1357998963 1357998994 31.0 -2715997957 1.0 -15601.0 NULL -1.358014595E9 0.044806451612903225 -9949.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -31.0 -773540513 15601 NULL NULL -773540482 773540513 31.0 -1547080995 1.0 -15601.0 NULL -7.73556114E8 0.044806451612903225 -11731.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -31.0 -198456342 15601 NULL NULL -198456311 198456342 31.0 -396912653 1.0 -15601.0 NULL -1.98471943E8 0.044806451612903225 -11622.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -31.0 -46453649 15601 NULL NULL -46453618 46453649 31.0 -92907267 1.0 -15601.0 NULL -4.646925E7 0.044806451612903225 -9472.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -30.0 -1617443296 15601 NULL NULL -1617443266 1617443296 30.0 -3234886562 1.0 -15601.0 NULL -1.617458897E9 0.0463 -9621.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -30.0 -532238997 15601 NULL NULL -532238967 532238997 30.0 -1064477964 1.0 -15601.0 NULL -5.32254598E8 0.0463 -10882.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -29.0 -2143024405 15601 NULL NULL -2143024376 2143024405 29.0 -4286048781 1.0 -15601.0 NULL -2.143040006E9 0.04789655172413793 -8641.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -29.0 -1912094416 15601 NULL NULL -1912094387 1912094416 29.0 -3824188803 1.0 -15601.0 NULL -1.912110017E9 0.04789655172413793 -4654.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -29.0 -1703837738 15601 NULL NULL -1703837709 1703837738 29.0 -3407675447 1.0 -15601.0 NULL -1.703853339E9 0.04789655172413793 -5725.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -29.0 -1355363882 15601 NULL NULL -1355363853 1355363882 29.0 -2710727735 1.0 -15601.0 NULL -1.355379483E9 0.04789655172413793 -11406.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -29.0 -427240643 15601 NULL NULL -427240614 427240643 29.0 -854481257 1.0 -15601.0 NULL -4.27256244E8 0.04789655172413793 -7258.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -29.0 -393066261 15601 NULL NULL -393066232 393066261 29.0 -786132493 1.0 -15601.0 NULL -3.93081862E8 0.04789655172413793 -14667.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -28.0 -1297431786 15601 NULL NULL -1297431758 1297431786 28.0 -2594863544 1.0 -15601.0 NULL -1.297447387E9 0.04960714285714286 -5823.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -28.0 -870417768 15601 NULL NULL -870417740 870417768 28.0 -1740835508 1.0 -15601.0 NULL -8.70433369E8 0.04960714285714286 -6776.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -28.0 -357908629 15601 NULL NULL -357908601 357908629 28.0 -715817230 1.0 -15601.0 NULL -3.5792423E8 0.04960714285714286 -6088.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -28.0 -309692433 15601 NULL NULL -309692405 309692433 28.0 -619384838 1.0 -15601.0 NULL -3.09708034E8 0.04960714285714286 -12583.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -27.0 -1152127938 15601 NULL NULL -1152127911 1152127938 27.0 -2304255849 1.0 -15601.0 NULL -1.152143539E9 0.051444444444444445 -9689.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -26.28 -1227267053 15601 NULL NULL -1227267030 1227267053 26.28 -2454534083 1.0 -15601.0 NULL -1.227282654E9 0.06039130434782609 -14388.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -26.0 -2022905886 15601 NULL NULL -2022905860 2022905886 26.0 -4045811746 1.0 -15601.0 NULL -2.022921487E9 0.05342307692307692 -2221.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -26.0 -1931941399 15601 NULL NULL -1931941373 1931941399 26.0 -3863882772 1.0 -15601.0 NULL -1.931957E9 0.05342307692307692 -7165.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -26.0 -1301028273 15601 NULL NULL -1301028247 1301028273 26.0 -2602056520 1.0 -15601.0 NULL -1.301043874E9 0.05342307692307692 -14080.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -26.0 -404509269 15601 NULL NULL -404509243 404509269 26.0 -809018512 1.0 -15601.0 NULL -4.0452487E8 0.05342307692307692 -6541.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -26.0 -354697170 15601 NULL NULL -354697144 354697170 26.0 -709394314 1.0 -15601.0 NULL -3.54712771E8 0.05342307692307692 -8435.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -26.0 -257298466 15601 NULL NULL -257298440 257298466 26.0 -514596906 1.0 -15601.0 NULL -2.57314067E8 0.05342307692307692 -6774.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -25.0 -892983643 15601 NULL NULL -892983618 892983643 25.0 -1785967261 1.0 -15601.0 NULL -8.92999244E8 0.05556 -13605.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -25.0 -414129290 15601 NULL NULL -414129265 414129290 25.0 -828258555 1.0 -15601.0 NULL -4.14144891E8 0.05556 -745.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -24.0 -1496666324 15601 NULL NULL -1496666300 1496666324 24.0 -2993332624 1.0 -15601.0 NULL -1.496681925E9 0.057875 -15591.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -24.0 -402193022 15601 NULL NULL -402192998 402193022 24.0 -804386020 1.0 -15601.0 NULL -4.02208623E8 0.057875 -14843.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -24.0 -278405900 15601 NULL NULL -278405876 278405900 24.0 -556811776 1.0 -15601.0 NULL -2.78421501E8 0.057875 -6055.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -24.0 -214199588 15601 NULL NULL -214199564 214199588 24.0 -428399152 1.0 -15601.0 NULL -2.14215189E8 0.057875 -13459.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -23.0 -2104361963 15601 NULL NULL -2104361940 2104361963 23.0 -4208723903 1.0 -15601.0 NULL -2.104377564E9 0.06039130434782609 -5477.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -23.0 -1864716928 15601 NULL NULL -1864716905 1864716928 23.0 -3729433833 1.0 -15601.0 NULL -1.864732529E9 0.06039130434782609 -7403.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -23.0 -1196406048 15601 NULL NULL -1196406025 1196406048 23.0 -2392812073 1.0 -15601.0 NULL -1.196421649E9 0.06039130434782609 -12161.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -23.0 -1046520269 15601 NULL NULL -1046520246 1046520269 23.0 -2093040515 1.0 -15601.0 NULL -1.04653587E9 0.06039130434782609 -5189.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -23.0 -557847275 15601 NULL NULL -557847252 557847275 23.0 -1115694527 1.0 -15601.0 NULL -5.57862876E8 0.06039130434782609 -2318.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -23.0 -287502046 15601 NULL NULL -287502023 287502046 23.0 -575004069 1.0 -15601.0 NULL -2.87517647E8 0.06039130434782609 -6818.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -22.0 -1843534244 15601 NULL NULL -1843534222 1843534244 22.0 -3687068466 1.0 -15601.0 NULL -1.843549845E9 0.06313636363636364 -10877.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -22.0 -1803981239 15601 NULL NULL -1803981217 1803981239 22.0 -3607962456 1.0 -15601.0 NULL -1.80399684E9 0.06313636363636364 -6407.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -22.0 -1138394041 15601 NULL NULL -1138394019 1138394041 22.0 -2276788060 1.0 -15601.0 NULL -1.138409642E9 0.06313636363636364 -4672.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -22.0 -116661992 15601 NULL NULL -116661970 116661992 22.0 -233323962 1.0 -15601.0 NULL -1.16677593E8 0.06313636363636364 -13315.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -21.0 -1025776200 15601 NULL NULL -1025776179 1025776200 21.0 -2051552379 1.0 -15601.0 NULL -1.025791801E9 0.06614285714285714 -10450.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -21.0 -813809028 15601 NULL NULL -813809007 813809028 21.0 -1627618035 1.0 -15601.0 NULL -8.13824629E8 0.06614285714285714 -14065.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -21.0 -617977476 15601 NULL NULL -617977455 617977476 21.0 -1235954931 1.0 -15601.0 NULL -6.17993077E8 0.06614285714285714 -6265.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -21.0 -264600574 15601 NULL NULL -264600553 264600574 21.0 -529201127 1.0 -15601.0 NULL -2.64616175E8 0.06614285714285714 -7614.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -20.0 -1914520574 15601 NULL NULL -1914520554 1914520574 20.0 -3829041128 1.0 -15601.0 NULL -1.914536175E9 0.06945 -12657.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -20.0 -1569241661 15601 NULL NULL -1569241641 1569241661 20.0 -3138483302 1.0 -15601.0 NULL -1.569257262E9 0.06945 -15076.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -1293754251 15601 NULL NULL -1293754231 1293754251 20.0 -2587508482 1.0 -15601.0 NULL -1.293769852E9 0.06945 -10124.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -990240929 15601 NULL NULL -990240909 990240929 20.0 -1980481838 1.0 -15601.0 NULL -9.9025653E8 0.06945 -14257.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -20.0 -258993110 15601 NULL NULL -258993090 258993110 20.0 -517986200 1.0 -15601.0 NULL -2.59008711E8 0.06945 -909.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -125514283 15601 NULL NULL -125514263 125514283 20.0 -251028546 1.0 -15601.0 NULL -1.25529884E8 0.06945 -4238.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -88020940 15601 NULL NULL -88020920 88020940 20.0 -176041860 1.0 -15601.0 NULL -8.8036541E7 0.06945 -98.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -57923441 15601 NULL NULL -57923421 57923441 20.0 -115846862 1.0 -15601.0 NULL -5.7939042E7 0.06945 -12529.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -20.0 -41530125 15601 NULL NULL -41530105 41530125 20.0 -83060230 1.0 -15601.0 NULL -4.1545726E7 0.06945 -263.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -1575589254 15601 NULL NULL -1575589235 1575589254 19.0 -3151178489 1.0 -15601.0 NULL -1.575604855E9 0.07310526315789474 -13062.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -19.0 -1322538563 15601 NULL NULL -1322538544 1322538563 19.0 -2645077107 1.0 -15601.0 NULL -1.322554164E9 0.07310526315789474 -10591.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -1293795844 15601 NULL NULL -1293795825 1293795844 19.0 -2587591669 1.0 -15601.0 NULL -1.293811445E9 0.07310526315789474 -4914.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -19.0 -1198536835 15601 NULL NULL -1198536816 1198536835 19.0 -2397073651 1.0 -15601.0 NULL -1.198552436E9 0.07310526315789474 -5611.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -1040575969 15601 NULL NULL -1040575950 1040575969 19.0 -2081151919 1.0 -15601.0 NULL -1.04059157E9 0.07310526315789474 -4870.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -899534452 15601 NULL NULL -899534433 899534452 19.0 -1799068885 1.0 -15601.0 NULL -8.99550053E8 0.07310526315789474 -11994.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -643533009 15601 NULL NULL -643532990 643533009 19.0 -1287065999 1.0 -15601.0 NULL -6.4354861E8 0.07310526315789474 -7360.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -19.0 -584361640 15601 NULL NULL -584361621 584361640 19.0 -1168723261 1.0 -15601.0 NULL -5.84377241E8 0.07310526315789474 -10584.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -19.0 -285749156 15601 NULL NULL -285749137 285749156 19.0 -571498293 1.0 -15601.0 NULL -2.85764757E8 0.07310526315789474 -1240.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -18.0 -1414044792 15601 NULL NULL -1414044774 1414044792 18.0 -2828089566 1.0 -15601.0 NULL -1.414060393E9 0.07716666666666666 -1354.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -18.0 -1310922279 15601 NULL NULL -1310922261 1310922279 18.0 -2621844540 1.0 -15601.0 NULL -1.31093788E9 0.07716666666666666 -1451.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -18.0 -1185085807 15601 NULL NULL -1185085789 1185085807 18.0 -2370171596 1.0 -15601.0 NULL -1.185101408E9 0.07716666666666666 -2645.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -17.0 -1901567703 15601 NULL NULL -1901567686 1901567703 17.0 -3803135389 1.0 -15601.0 NULL -1.901583304E9 0.08170588235294118 -8616.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -17.0 -1275985495 15601 NULL NULL -1275985478 1275985495 17.0 -2551970973 1.0 -15601.0 NULL -1.276001096E9 0.08170588235294118 -10907.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -17.0 -590153501 15601 NULL NULL -590153484 590153501 17.0 -1180306985 1.0 -15601.0 NULL -5.90169102E8 0.08170588235294118 -14474.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -16.0 -1505978287 15601 NULL NULL -1505978271 1505978287 16.0 -3011956558 1.0 -15601.0 NULL -1.505993888E9 0.0868125 -13757.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -16.0 -598490358 15601 NULL NULL -598490342 598490358 16.0 -1196980700 1.0 -15601.0 NULL -5.98505959E8 0.0868125 -4796.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -15.0 -1925755234 15601 NULL NULL -1925755219 1925755234 15.0 -3851510453 1.0 -15601.0 NULL -1.925770835E9 0.0926 -14597.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -15.0 -937270420 15601 NULL NULL -937270405 937270420 15.0 -1874540825 1.0 -15601.0 NULL -9.37286021E8 0.0926 -9143.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -14.0 -1863202490 15601 NULL NULL -1863202476 1863202490 14.0 -3726404966 1.0 -15601.0 NULL -1.863218091E9 0.09921428571428571 -6262.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -14.0 -946632342 15601 NULL NULL -946632328 946632342 14.0 -1893264670 1.0 -15601.0 NULL -9.46647943E8 0.09921428571428571 -10465.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -14.0 -466156812 15601 NULL NULL -466156798 466156812 14.0 -932313610 1.0 -15601.0 NULL -4.66172413E8 0.09921428571428571 -14533.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -14.0 -205670222 15601 NULL NULL -205670208 205670222 14.0 -411340430 1.0 -15601.0 NULL -2.05685823E8 0.09921428571428571 -2239.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -13.0 -1040843741 15601 NULL NULL -1040843728 1040843741 13.0 -2081687469 1.0 -15601.0 NULL -1.040859342E9 0.10684615384615384 -7425.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -13.0 -928466576 15601 NULL NULL -928466563 928466576 13.0 -1856933139 1.0 -15601.0 NULL -9.28482177E8 0.10684615384615384 -4263.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -11.0 -1985550487 15601 NULL NULL -1985550476 1985550487 11.0 -3971100963 1.0 -15601.0 NULL -1.985566088E9 0.1262727272727273 -11217.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -11.0 -1964641289 15601 NULL NULL -1964641278 1964641289 11.0 -3929282567 1.0 -15601.0 NULL -1.96465689E9 0.1262727272727273 -7359.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -11.0 -1133138233 15601 NULL NULL -1133138222 1133138233 11.0 -2266276455 1.0 -15601.0 NULL -1.133153834E9 0.1262727272727273 -6401.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -11.0 -655443218 15601 NULL NULL -655443207 655443218 11.0 -1310886425 1.0 -15601.0 NULL -6.55458819E8 0.1262727272727273 -14006.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -11.0 -386315686 15601 NULL NULL -386315675 386315686 11.0 -772631361 1.0 -15601.0 NULL -3.86331287E8 0.1262727272727273 -3724.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -11.0 -26446061 15601 NULL NULL -26446050 26446061 11.0 -52892111 1.0 -15601.0 NULL -2.6461662E7 0.1262727272727273 -2366.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -10.0 -1850457201 15601 NULL NULL -1850457191 1850457201 10.0 -3700914392 1.0 -15601.0 NULL -1.850472802E9 0.1389 -6990.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -10.0 -1160428011 15601 NULL NULL -1160428001 1160428011 10.0 -2320856012 1.0 -15601.0 NULL -1.160443612E9 0.1389 -10030.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -10.0 -1086197521 15601 NULL NULL -1086197511 1086197521 10.0 -2172395032 1.0 -15601.0 NULL -1.086213122E9 0.1389 -9098.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -9.0 -911417577 15601 NULL NULL -911417568 911417577 9.0 -1822835145 1.0 -15601.0 NULL -9.11433178E8 0.15433333333333332 -7157.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -9.0 -775282830 15601 NULL NULL -775282821 775282830 9.0 -1550565651 1.0 -15601.0 NULL -7.75298431E8 0.15433333333333332 -6736.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -9.0 -216777441 15601 NULL NULL -216777432 216777441 9.0 -433554873 1.0 -15601.0 NULL -2.16793042E8 0.15433333333333332 -1546.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -2028170063 15601 NULL NULL -2028170055 2028170063 8.0 -4056340118 1.0 -15601.0 NULL -2.028185664E9 0.173625 -8861.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -1998625094 15601 NULL NULL -1998625086 1998625094 8.0 -3997250180 1.0 -15601.0 NULL -1.998640695E9 0.173625 -12186.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -1902104689 15601 NULL NULL -1902104681 1902104689 8.0 -3804209370 1.0 -15601.0 NULL -1.90212029E9 0.173625 -15168.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -1768316238 15601 NULL NULL -1768316230 1768316238 8.0 -3536632468 1.0 -15601.0 NULL -1.768331839E9 0.173625 -5292.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -8.0 -1621359391 15601 NULL NULL -1621359383 1621359391 8.0 -3242718774 1.0 -15601.0 NULL -1.621374992E9 0.173625 -9865.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -1493703726 15601 NULL NULL -1493703718 1493703726 8.0 -2987407444 1.0 -15601.0 NULL -1.493719327E9 0.173625 -1582.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -8.0 -335617169 15601 NULL NULL -335617161 335617169 8.0 -671234330 1.0 -15601.0 NULL -3.3563277E8 0.173625 -8457.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -8.0 -225001319 15601 NULL NULL -225001311 225001319 8.0 -450002630 1.0 -15601.0 NULL -2.2501692E8 0.173625 -3697.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -1761560547 15601 NULL NULL -1761560541 1761560547 6.0 -3523121088 1.0 -15601.0 NULL -1.761576148E9 0.2315 -4834.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -6.0 -1610058211 15601 NULL NULL -1610058205 1610058211 6.0 -3220116416 1.0 -15601.0 NULL -1.610073812E9 0.2315 -3809.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -1307656088 15601 NULL NULL -1307656082 1307656088 6.0 -2615312170 1.0 -15601.0 NULL -1.307671689E9 0.2315 -11470.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -6.0 -1207674957 15601 NULL NULL -1207674951 1207674957 6.0 -2415349908 1.0 -15601.0 NULL -1.207690558E9 0.2315 -1547.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -847064600 15601 NULL NULL -847064594 847064600 6.0 -1694129194 1.0 -15601.0 NULL -8.47080201E8 0.2315 -8305.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -786134704 15601 NULL NULL -786134698 786134704 6.0 -1572269402 1.0 -15601.0 NULL -7.86150305E8 0.2315 -314.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -659825179 15601 NULL NULL -659825173 659825179 6.0 -1319650352 1.0 -15601.0 NULL -6.5984078E8 0.2315 -12086.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -6.0 -573372032 15601 NULL NULL -573372026 573372032 6.0 -1146744058 1.0 -15601.0 NULL -5.73387633E8 0.2315 -4080.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -6.0 -337682588 15601 NULL NULL -337682582 337682588 6.0 -675365170 1.0 -15601.0 NULL -3.37698189E8 0.2315 -14544.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -5.0 -1888902550 15601 NULL NULL -1888902545 1888902550 5.0 -3777805095 1.0 -15601.0 NULL -1.888918151E9 0.2778 -11475.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -1844060558 15601 NULL NULL -1844060553 1844060558 5.0 -3688121111 1.0 -15601.0 NULL -1.844076159E9 0.2778 -6757.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -1367836702 15601 NULL NULL -1367836697 1367836702 5.0 -2735673399 1.0 -15601.0 NULL -1.367852303E9 0.2778 -3426.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -1029272743 15601 NULL NULL -1029272738 1029272743 5.0 -2058545481 1.0 -15601.0 NULL -1.029288344E9 0.2778 -12369.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -685821373 15601 NULL NULL -685821368 685821373 5.0 -1371642741 1.0 -15601.0 NULL -6.85836974E8 0.2778 -1413.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -550628565 15601 NULL NULL -550628560 550628565 5.0 -1101257125 1.0 -15601.0 NULL -5.50644166E8 0.2778 -6871.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -5.0 -13357585 15601 NULL NULL -13357580 13357585 5.0 -26715165 1.0 -15601.0 NULL -1.3373186E7 0.2778 -3129.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -4.0 -2142615863 15601 NULL NULL -2142615859 2142615863 4.0 -4285231722 1.0 -15601.0 NULL -2.142631464E9 0.34725 -5725.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -4.0 -1559306282 15601 NULL NULL -1559306278 1559306282 4.0 -3118612560 1.0 -15601.0 NULL -1.559321883E9 0.34725 -1933.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -4.0 -413080018 15601 NULL NULL -413080014 413080018 4.0 -826160032 1.0 -15601.0 NULL -4.13095619E8 0.34725 -12341.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -4.0 -85097850 15601 NULL NULL -85097846 85097850 4.0 -170195696 1.0 -15601.0 NULL -8.5113451E7 0.34725 -9996.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -3.0 -2076312756 15601 NULL NULL -2076312753 2076312756 3.0 -4152625509 1.0 -15601.0 NULL -2.076328357E9 0.463 -6868.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -3.0 -1714949058 15601 NULL NULL -1714949055 1714949058 3.0 -3429898113 1.0 -15601.0 NULL -1.714964659E9 0.463 -9133.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -3.0 -1263796487 15601 NULL NULL -1263796484 1263796487 3.0 -2527592971 1.0 -15601.0 NULL -1.263812088E9 0.463 -6280.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -2.0 -2115132140 15601 NULL NULL -2115132138 2115132140 2.0 -4230264278 1.0 -15601.0 NULL -2.115147741E9 0.6945 -10964.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -2.0 -430689331 15601 NULL NULL -430689329 430689331 2.0 -861378660 1.0 -15601.0 NULL -4.30704932E8 0.6945 -8125.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -2.0 -338257841 15601 NULL NULL -338257839 338257841 2.0 -676515680 1.0 -15601.0 NULL -3.38273442E8 0.6945 -12560.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -2.0 -319788030 15601 NULL NULL -319788028 319788030 2.0 -639576058 1.0 -15601.0 NULL -3.19803631E8 0.6945 -14333.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -2.0 -64512046 15601 NULL NULL -64512044 64512046 2.0 -129024090 1.0 -15601.0 NULL -6.4527647E7 0.6945 -1911.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -1.0 -789881959 15601 NULL NULL -789881958 789881959 1.0 -1579763917 1.0 -15601.0 NULL -7.8989756E8 1.389 -3329.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 -1.0 -630453835 15601 NULL NULL -630453834 630453835 1.0 -1260907669 1.0 -15601.0 NULL -6.30469436E8 1.389 -1824.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -1.0 -532065045 15601 NULL NULL -532065044 532065045 1.0 -1064130089 1.0 -15601.0 NULL -5.32080646E8 1.389 -8541.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 -1.0 -457778616 15601 NULL NULL -457778615 457778616 1.0 -915557231 1.0 -15601.0 NULL -4.57794217E8 1.389 -14074.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 0.0 -1355080830 15601 NULL NULL -1355080830 1355080830 -0.0 -2710161660 1.0 -15601.0 NULL -1.355096431E9 -Infinity -9172.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 0.0 -1300968933 15601 NULL NULL -1300968933 1300968933 -0.0 -2601937866 1.0 -15601.0 NULL -1.300984534E9 -Infinity -1543.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 0.0 -1111841132 15601 NULL NULL -1111841132 1111841132 -0.0 -2223682264 1.0 -15601.0 NULL -1.111856733E9 -Infinity -4665.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 0.0 -901264012 15601 NULL NULL -901264012 901264012 -0.0 -1802528024 1.0 -15601.0 NULL -9.01279613E8 -Infinity -9843.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 0.0 -438779645 15601 NULL NULL -438779645 438779645 -0.0 -877559290 1.0 -15601.0 NULL -4.38795246E8 -Infinity -1520.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 0.0 -203039588 15601 NULL NULL -203039588 203039588 -0.0 -406079176 1.0 -15601.0 NULL -2.03055189E8 -Infinity -8174.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 0.0 -39854776 15601 NULL NULL -39854776 39854776 -0.0 -79709552 1.0 -15601.0 NULL -3.9870377E7 -Infinity -9822.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 1.0 -2136727102 15601 NULL NULL -2136727103 2136727102 -1.0 -4273454205 1.0 -15601.0 NULL -2.136742703E9 -1.389 -14142.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 1.0 -1972121622 15601 NULL NULL -1972121623 1972121622 -1.0 -3944243245 1.0 -15601.0 NULL -1.972137223E9 -1.389 -14813.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 1.0 -1025788056 15601 NULL NULL -1025788057 1025788056 -1.0 -2051576113 1.0 -15601.0 NULL -1.025803657E9 -1.389 -6705.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 1.0 -832606494 15601 NULL NULL -832606495 832606494 -1.0 -1665212989 1.0 -15601.0 NULL -8.32622095E8 -1.389 -12326.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 1.0 -208178544 15601 NULL NULL -208178545 208178544 -1.0 -416357089 1.0 -15601.0 NULL -2.08194145E8 -1.389 -14401.0 -15601 NULL +NULL NULL NULL 1969-12-31 15:59:58.456 15601.0 1.0 -33712062 15601 NULL NULL -33712063 33712062 -1.0 -67424125 1.0 -15601.0 NULL -3.3727663E7 -1.389 -13902.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 2.0 -1084500358 15601 NULL NULL -1084500360 1084500358 -2.0 -2169000718 1.0 -15601.0 NULL -1.084515959E9 -0.6945 -12444.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 2.0 -664588420 15601 NULL NULL -664588422 664588420 -2.0 -1329176842 1.0 -15601.0 NULL -6.64604021E8 -0.6945 -1421.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 2.0 -400080827 15601 NULL NULL -400080829 400080827 -2.0 -800161656 1.0 -15601.0 NULL -4.00096428E8 -0.6945 -8783.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 3.0 -1580362265 15601 NULL NULL -1580362268 1580362265 -3.0 -3160724533 1.0 -15601.0 NULL -1.580377866E9 -0.463 -12167.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 3.0 -1269033095 15601 NULL NULL -1269033098 1269033095 -3.0 -2538066193 1.0 -15601.0 NULL -1.269048696E9 -0.463 -952.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 3.0 -1215180434 15601 NULL NULL -1215180437 1215180434 -3.0 -2430360871 1.0 -15601.0 NULL -1.215196035E9 -0.463 -2943.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 3.0 -662740282 15601 NULL NULL -662740285 662740282 -3.0 -1325480567 1.0 -15601.0 NULL -6.62755883E8 -0.463 -9802.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 4.0 -2118522134 15601 NULL NULL -2118522138 2118522134 -4.0 -4237044272 1.0 -15601.0 NULL -2.118537735E9 -0.34725 -15541.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 4.0 -1677882999 15601 NULL NULL -1677883003 1677882999 -4.0 -3355766002 1.0 -15601.0 NULL -1.6778986E9 -0.34725 -11050.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 4.0 -1096047343 15601 NULL NULL -1096047347 1096047343 -4.0 -2192094690 1.0 -15601.0 NULL -1.096062944E9 -0.34725 -14689.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 4.0 -941884962 15601 NULL NULL -941884966 941884962 -4.0 -1883769928 1.0 -15601.0 NULL -9.41900563E8 -0.34725 -5789.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 4.0 -293394791 15601 NULL NULL -293394795 293394791 -4.0 -586789586 1.0 -15601.0 NULL -2.93410392E8 -0.34725 -2385.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 4.0 -118815110 15601 NULL NULL -118815114 118815110 -4.0 -237630224 1.0 -15601.0 NULL -1.18830711E8 -0.34725 -13495.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 4.0 -25467184 15601 NULL NULL -25467188 25467184 -4.0 -50934372 1.0 -15601.0 NULL -2.5482785E7 -0.34725 -6352.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 5.0 -1668687246 15601 NULL NULL -1668687251 1668687246 -5.0 -3337374497 1.0 -15601.0 NULL -1.668702847E9 -0.2778 -4286.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 5.0 -1611690058 15601 NULL NULL -1611690063 1611690058 -5.0 -3223380121 1.0 -15601.0 NULL -1.611705659E9 -0.2778 -13152.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 5.0 -1456078486 15601 NULL NULL -1456078491 1456078486 -5.0 -2912156977 1.0 -15601.0 NULL -1.456094087E9 -0.2778 -5954.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 5.0 -1405201067 15601 NULL NULL -1405201072 1405201067 -5.0 -2810402139 1.0 -15601.0 NULL -1.405216668E9 -0.2778 -3396.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 5.0 -1332540455 15601 NULL NULL -1332540460 1332540455 -5.0 -2665080915 1.0 -15601.0 NULL -1.332556056E9 -0.2778 -12242.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 5.0 -507162101 15601 NULL NULL -507162106 507162101 -5.0 -1014324207 1.0 -15601.0 NULL -5.07177702E8 -0.2778 -4793.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 5.0 -245067785 15601 NULL NULL -245067790 245067785 -5.0 -490135575 1.0 -15601.0 NULL -2.45083386E8 -0.2778 -7277.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 5.0 -184458103 15601 NULL NULL -184458108 184458103 -5.0 -368916211 1.0 -15601.0 NULL -1.84473704E8 -0.2778 -7480.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 6.0 -1440134532 15601 NULL NULL -1440134538 1440134532 -6.0 -2880269070 1.0 -15601.0 NULL -1.440150133E9 -0.2315 -6222.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 6.0 -1135974844 15601 NULL NULL -1135974850 1135974844 -6.0 -2271949694 1.0 -15601.0 NULL -1.135990445E9 -0.2315 -3630.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 6.0 -940198586 15601 NULL NULL -940198592 940198586 -6.0 -1880397178 1.0 -15601.0 NULL -9.40214187E8 -0.2315 -4321.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 6.0 -921789404 15601 NULL NULL -921789410 921789404 -6.0 -1843578814 1.0 -15601.0 NULL -9.21805005E8 -0.2315 -4319.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 6.0 -47379735 15601 NULL NULL -47379741 47379735 -6.0 -94759476 1.0 -15601.0 NULL -4.7395336E7 -0.2315 -15099.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 7.0 -1487527155 15601 NULL NULL -1487527162 1487527155 -7.0 -2975054317 1.0 -15601.0 NULL -1.487542756E9 -0.19842857142857143 -3007.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 7.0 -484557615 15601 NULL NULL -484557622 484557615 -7.0 -969115237 1.0 -15601.0 NULL -4.84573216E8 -0.19842857142857143 -6156.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 7.0 -335637893 15601 NULL NULL -335637900 335637893 -7.0 -671275793 1.0 -15601.0 NULL -3.35653494E8 -0.19842857142857143 -13580.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 8.0 -1568412240 15601 NULL NULL -1568412248 1568412240 -8.0 -3136824488 1.0 -15601.0 NULL -1.568427841E9 -0.173625 -12508.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 8.0 -1393500402 15601 NULL NULL -1393500410 1393500402 -8.0 -2787000812 1.0 -15601.0 NULL -1.393516003E9 -0.173625 -3481.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 8.0 -671519607 15601 NULL NULL -671519615 671519607 -8.0 -1343039222 1.0 -15601.0 NULL -6.71535208E8 -0.173625 -5764.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 8.0 -590921449 15601 NULL NULL -590921457 590921449 -8.0 -1181842906 1.0 -15601.0 NULL -5.9093705E8 -0.173625 -2372.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 9.0 -2093472028 15601 NULL NULL -2093472037 2093472028 -9.0 -4186944065 1.0 -15601.0 NULL -2.093487629E9 -0.15433333333333332 -5040.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 9.0 -1792474070 15601 NULL NULL -1792474079 1792474070 -9.0 -3584948149 1.0 -15601.0 NULL -1.792489671E9 -0.15433333333333332 -12776.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 9.0 -1620061206 15601 NULL NULL -1620061215 1620061206 -9.0 -3240122421 1.0 -15601.0 NULL -1.620076807E9 -0.15433333333333332 -6563.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 9.0 -1145489043 15601 NULL NULL -1145489052 1145489043 -9.0 -2290978095 1.0 -15601.0 NULL -1.145504644E9 -0.15433333333333332 -1219.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 9.0 -910567691 15601 NULL NULL -910567700 910567691 -9.0 -1821135391 1.0 -15601.0 NULL -9.10583292E8 -0.15433333333333332 -15326.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 9.0 -605773050 15601 NULL NULL -605773059 605773050 -9.0 -1211546109 1.0 -15601.0 NULL -6.05788651E8 -0.15433333333333332 -1821.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 10.0 -1230115822 15601 NULL NULL -1230115832 1230115822 -10.0 -2460231654 1.0 -15601.0 NULL -1.230131423E9 -0.1389 -8174.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 10.0 -1043251982 15601 NULL NULL -1043251992 1043251982 -10.0 -2086503974 1.0 -15601.0 NULL -1.043267583E9 -0.1389 -13112.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 10.0 -720023732 15601 NULL NULL -720023742 720023732 -10.0 -1440047474 1.0 -15601.0 NULL -7.20039333E8 -0.1389 -6380.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 11.0 -1656847358 15601 NULL NULL -1656847369 1656847358 -11.0 -3313694727 1.0 -15601.0 NULL -1.656862959E9 -0.1262727272727273 -5557.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 11.0 -1558180030 15601 NULL NULL -1558180041 1558180030 -11.0 -3116360071 1.0 -15601.0 NULL -1.558195631E9 -0.1262727272727273 -14554.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 11.0 -1474284078 15601 NULL NULL -1474284089 1474284078 -11.0 -2948568167 1.0 -15601.0 NULL -1.474299679E9 -0.1262727272727273 -5179.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 11.0 -843069884 15601 NULL NULL -843069895 843069884 -11.0 -1686139779 1.0 -15601.0 NULL -8.43085485E8 -0.1262727272727273 -7445.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 12.0 -1879970002 15601 NULL NULL -1879970014 1879970002 -12.0 -3759940016 1.0 -15601.0 NULL -1.879985603E9 -0.11575 -2699.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 12.0 -1331125878 15601 NULL NULL -1331125890 1331125878 -12.0 -2662251768 1.0 -15601.0 NULL -1.331141479E9 -0.11575 -1755.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 12.0 -620887667 15601 NULL NULL -620887679 620887667 -12.0 -1241775346 1.0 -15601.0 NULL -6.20903268E8 -0.11575 -14670.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 13.0 -2108715482 15601 NULL NULL -2108715495 2108715482 -13.0 -4217430977 1.0 -15601.0 NULL -2.108731083E9 -0.10684615384615384 -6317.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 13.0 -2058347315 15601 NULL NULL -2058347328 2058347315 -13.0 -4116694643 1.0 -15601.0 NULL -2.058362916E9 -0.10684615384615384 -13779.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 14.0 -1970072997 15601 NULL NULL -1970073011 1970072997 -14.0 -3940146008 1.0 -15601.0 NULL -1.970088598E9 -0.09921428571428571 -9919.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 14.0 -1954298743 15601 NULL NULL -1954298757 1954298743 -14.0 -3908597500 1.0 -15601.0 NULL -1.954314344E9 -0.09921428571428571 -8276.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 14.0 -1555938533 15601 NULL NULL -1555938547 1555938533 -14.0 -3111877080 1.0 -15601.0 NULL -1.555954134E9 -0.09921428571428571 -4000.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 14.0 -1426659283 15601 NULL NULL -1426659297 1426659283 -14.0 -2853318580 1.0 -15601.0 NULL -1.426674884E9 -0.09921428571428571 -10237.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 14.0 -1358164329 15601 NULL NULL -1358164343 1358164329 -14.0 -2716328672 1.0 -15601.0 NULL -1.35817993E9 -0.09921428571428571 -3673.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 15.0 -1964487606 15601 NULL NULL -1964487621 1964487606 -15.0 -3928975227 1.0 -15601.0 NULL -1.964503207E9 -0.0926 -9686.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 15.0 -1675398355 15601 NULL NULL -1675398370 1675398355 -15.0 -3350796725 1.0 -15601.0 NULL -1.675413956E9 -0.0926 -6965.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 15.0 -1540302337 15601 NULL NULL -1540302352 1540302337 -15.0 -3080604689 1.0 -15601.0 NULL -1.540317938E9 -0.0926 -6.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 15.0 -1186641445 15601 NULL NULL -1186641460 1186641445 -15.0 -2373282905 1.0 -15601.0 NULL -1.186657046E9 -0.0926 -13784.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 15.0 -1106735397 15601 NULL NULL -1106735412 1106735397 -15.0 -2213470809 1.0 -15601.0 NULL -1.106750998E9 -0.0926 -457.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 16.0 -1011232927 15601 NULL NULL -1011232943 1011232927 -16.0 -2022465870 1.0 -15601.0 NULL -1.011248528E9 -0.0868125 -7309.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 17.0 -1932369186 15601 NULL NULL -1932369203 1932369186 -17.0 -3864738389 1.0 -15601.0 NULL -1.932384787E9 -0.08170588235294118 -13725.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 17.0 -1749442997 15601 NULL NULL -1749443014 1749442997 -17.0 -3498886011 1.0 -15601.0 NULL -1.749458598E9 -0.08170588235294118 -9261.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 17.0 -784264135 15601 NULL NULL -784264152 784264135 -17.0 -1568528287 1.0 -15601.0 NULL -7.84279736E8 -0.08170588235294118 -1865.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 17.0 -748287945 15601 NULL NULL -748287962 748287945 -17.0 -1496575907 1.0 -15601.0 NULL -7.48303546E8 -0.08170588235294118 -1581.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 17.0 -629005739 15601 NULL NULL -629005756 629005739 -17.0 -1258011495 1.0 -15601.0 NULL -6.2902134E8 -0.08170588235294118 -4621.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 17.0 -402367872 15601 NULL NULL -402367889 402367872 -17.0 -804735761 1.0 -15601.0 NULL -4.02383473E8 -0.08170588235294118 -2481.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 17.0 -191560572 15601 NULL NULL -191560589 191560572 -17.0 -383121161 1.0 -15601.0 NULL -1.91576173E8 -0.08170588235294118 -11494.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 18.0 -2044770406 15601 NULL NULL -2044770424 2044770406 -18.0 -4089540830 1.0 -15601.0 NULL -2.044786007E9 -0.07716666666666666 -9740.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 18.0 -1692252476 15601 NULL NULL -1692252494 1692252476 -18.0 -3384504970 1.0 -15601.0 NULL -1.692268077E9 -0.07716666666666666 -12006.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 18.0 -996134600 15601 NULL NULL -996134618 996134600 -18.0 -1992269218 1.0 -15601.0 NULL -9.96150201E8 -0.07716666666666666 -10750.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 18.0 -973905398 15601 NULL NULL -973905416 973905398 -18.0 -1947810814 1.0 -15601.0 NULL -9.73920999E8 -0.07716666666666666 -12973.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 18.0 -860591619 15601 NULL NULL -860591637 860591619 -18.0 -1721183256 1.0 -15601.0 NULL -8.6060722E8 -0.07716666666666666 -9257.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 18.0 -309614238 15601 NULL NULL -309614256 309614238 -18.0 -619228494 1.0 -15601.0 NULL -3.09629839E8 -0.07716666666666666 -12393.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 18.0 -62733813 15601 NULL NULL -62733831 62733813 -18.0 -125467644 1.0 -15601.0 NULL -6.2749414E7 -0.07716666666666666 -2192.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 19.0 -1644279296 15601 NULL NULL -1644279315 1644279296 -19.0 -3288558611 1.0 -15601.0 NULL -1.644294897E9 -0.07310526315789474 -11901.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 19.0 -1332687894 15601 NULL NULL -1332687913 1332687894 -19.0 -2665375807 1.0 -15601.0 NULL -1.332703495E9 -0.07310526315789474 -3671.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 19.0 -631397801 15601 NULL NULL -631397820 631397801 -19.0 -1262795621 1.0 -15601.0 NULL -6.31413402E8 -0.07310526315789474 -9730.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 19.0 -408304573 15601 NULL NULL -408304592 408304573 -19.0 -816609165 1.0 -15601.0 NULL -4.08320174E8 -0.07310526315789474 -10802.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 20.0 -2050820665 15601 NULL NULL -2050820685 2050820665 -20.0 -4101641350 1.0 -15601.0 NULL -2.050836266E9 -0.06945 -6811.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 20.0 -1972968987 15601 NULL NULL -1972969007 1972968987 -20.0 -3945937994 1.0 -15601.0 NULL -1.972984588E9 -0.06945 -4123.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 20.0 -1644694994 15601 NULL NULL -1644695014 1644694994 -20.0 -3289390008 1.0 -15601.0 NULL -1.644710595E9 -0.06945 -6372.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 20.0 -1195710741 15601 NULL NULL -1195710761 1195710741 -20.0 -2391421502 1.0 -15601.0 NULL -1.195726342E9 -0.06945 -3298.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 20.0 -368721894 15601 NULL NULL -368721914 368721894 -20.0 -737443808 1.0 -15601.0 NULL -3.68737495E8 -0.06945 -7860.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 20.0 -362433250 15601 NULL NULL -362433270 362433250 -20.0 -724866520 1.0 -15601.0 NULL -3.62448851E8 -0.06945 -6419.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 20.0 -89010 15601 NULL NULL -89030 89010 -20.0 -178040 1.0 -15601.0 NULL -104611.0 -0.06945 -11005.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 21.0 -893636289 15601 NULL NULL -893636310 893636289 -21.0 -1787272599 1.0 -15601.0 NULL -8.9365189E8 -0.06614285714285714 -11009.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 22.0 -1875861804 15601 NULL NULL -1875861826 1875861804 -22.0 -3751723630 1.0 -15601.0 NULL -1.875877405E9 -0.06313636363636364 -13165.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 22.0 -1433781206 15601 NULL NULL -1433781228 1433781206 -22.0 -2867562434 1.0 -15601.0 NULL -1.433796807E9 -0.06313636363636364 -2503.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 22.0 -490232669 15601 NULL NULL -490232691 490232669 -22.0 -980465360 1.0 -15601.0 NULL -4.9024827E8 -0.06313636363636364 -2446.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 23.0 -1167276678 15601 NULL NULL -1167276701 1167276678 -23.0 -2334553379 1.0 -15601.0 NULL -1.167292279E9 -0.06039130434782609 -9858.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 23.0 -996165688 15601 NULL NULL -996165711 996165688 -23.0 -1992331399 1.0 -15601.0 NULL -9.96181289E8 -0.06039130434782609 -10636.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 24.0 -1740312484 15601 NULL NULL -1740312508 1740312484 -24.0 -3480624992 1.0 -15601.0 NULL -1.740328085E9 -0.057875 -5333.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 24.0 -1278926860 15601 NULL NULL -1278926884 1278926860 -24.0 -2557853744 1.0 -15601.0 NULL -1.278942461E9 -0.057875 -3683.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 24.0 -404751232 15601 NULL NULL -404751256 404751232 -24.0 -809502488 1.0 -15601.0 NULL -4.04766833E8 -0.057875 -14489.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 25.0 -2030132877 15601 NULL NULL -2030132902 2030132877 -25.0 -4060265779 1.0 -15601.0 NULL -2.030148478E9 -0.05556 -5949.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 25.0 -1178735095 15601 NULL NULL -1178735120 1178735095 -25.0 -2357470215 1.0 -15601.0 NULL -1.178750696E9 -0.05556 -1540.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 25.0 -765146525 15601 NULL NULL -765146550 765146525 -25.0 -1530293075 1.0 -15601.0 NULL -7.65162126E8 -0.05556 -11081.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 26.0 -2141336536 15601 NULL NULL -2141336562 2141336536 -26.0 -4282673098 1.0 -15601.0 NULL -2.141352137E9 -0.05342307692307692 -5680.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 26.0 -692950740 15601 NULL NULL -692950766 692950740 -26.0 -1385901506 1.0 -15601.0 NULL -6.92966341E8 -0.05342307692307692 -1123.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 26.0 -51344670 15601 NULL NULL -51344696 51344670 -26.0 -102689366 1.0 -15601.0 NULL -5.1360271E7 -0.05342307692307692 -1779.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 27.0 -2043827141 15601 NULL NULL -2043827168 2043827141 -27.0 -4087654309 1.0 -15601.0 NULL -2.043842742E9 -0.051444444444444445 -2535.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 27.0 -1535090489 15601 NULL NULL -1535090516 1535090489 -27.0 -3070181005 1.0 -15601.0 NULL -1.53510609E9 -0.051444444444444445 -14493.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 27.0 -67671601 15601 NULL NULL -67671628 67671601 -27.0 -135343229 1.0 -15601.0 NULL -6.7687202E7 -0.051444444444444445 -10064.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 28.0 -1852182045 15601 NULL NULL -1852182073 1852182045 -28.0 -3704364118 1.0 -15601.0 NULL -1.852197646E9 -0.04960714285714286 -123.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 28.0 -1767756774 15601 NULL NULL -1767756802 1767756774 -28.0 -3535513576 1.0 -15601.0 NULL -1.767772375E9 -0.04960714285714286 -7464.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 28.0 -1556827241 15601 NULL NULL -1556827269 1556827241 -28.0 -3113654510 1.0 -15601.0 NULL -1.556842842E9 -0.04960714285714286 -3451.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 29.0 -2052415815 15601 NULL NULL -2052415844 2052415815 -29.0 -4104831659 1.0 -15601.0 NULL -2.052431416E9 -0.04789655172413793 -10659.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 29.0 -508126361 15601 NULL NULL -508126390 508126361 -29.0 -1016252751 1.0 -15601.0 NULL -5.08141962E8 -0.04789655172413793 -1791.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 29.0 -221039350 15601 NULL NULL -221039379 221039350 -29.0 -442078729 1.0 -15601.0 NULL -2.21054951E8 -0.04789655172413793 -4382.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 30.0 -1986754040 15601 NULL NULL -1986754070 1986754040 -30.0 -3973508110 1.0 -15601.0 NULL -1.986769641E9 -0.0463 -13493.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 30.0 -1465963146 15601 NULL NULL -1465963176 1465963146 -30.0 -2931926322 1.0 -15601.0 NULL -1.465978747E9 -0.0463 -15181.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 30.0 -1399138608 15601 NULL NULL -1399138638 1399138608 -30.0 -2798277246 1.0 -15601.0 NULL -1.399154209E9 -0.0463 -9726.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 30.0 -941937506 15601 NULL NULL -941937536 941937506 -30.0 -1883875042 1.0 -15601.0 NULL -9.41953107E8 -0.0463 -11530.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 30.0 -919690155 15601 NULL NULL -919690185 919690155 -30.0 -1839380340 1.0 -15601.0 NULL -9.19705756E8 -0.0463 -11205.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 30.0 -579164639 15601 NULL NULL -579164669 579164639 -30.0 -1158329308 1.0 -15601.0 NULL -5.7918024E8 -0.0463 -8716.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 31.0 -1954992185 15601 NULL NULL -1954992216 1954992185 -31.0 -3909984401 1.0 -15601.0 NULL -1.955007786E9 -0.044806451612903225 -15274.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 31.0 -1407693136 15601 NULL NULL -1407693167 1407693136 -31.0 -2815386303 1.0 -15601.0 NULL -1.407708737E9 -0.044806451612903225 -14906.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 31.0 -810446066 15601 NULL NULL -810446097 810446066 -31.0 -1620892163 1.0 -15601.0 NULL -8.10461667E8 -0.044806451612903225 -5318.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 31.0 -202495882 15601 NULL NULL -202495913 202495882 -31.0 -404991795 1.0 -15601.0 NULL -2.02511483E8 -0.044806451612903225 -10503.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 32.0 -1495050520 15601 NULL NULL -1495050552 1495050520 -32.0 -2990101072 1.0 -15601.0 NULL -1.495066121E9 -0.04340625 -6690.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 32.0 -991138235 15601 NULL NULL -991138267 991138235 -32.0 -1982276502 1.0 -15601.0 NULL -9.91153836E8 -0.04340625 -6705.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 32.0 -747159857 15601 NULL NULL -747159889 747159857 -32.0 -1494319746 1.0 -15601.0 NULL -7.47175458E8 -0.04340625 -12366.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 32.0 -537124320 15601 NULL NULL -537124352 537124320 -32.0 -1074248672 1.0 -15601.0 NULL -5.37139921E8 -0.04340625 -13092.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 33.0 -2081329290 15601 NULL NULL -2081329323 2081329290 -33.0 -4162658613 1.0 -15601.0 NULL -2.081344891E9 -0.04209090909090909 -15481.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 33.0 -667436971 15601 NULL NULL -667437004 667436971 -33.0 -1334873975 1.0 -15601.0 NULL -6.67452572E8 -0.04209090909090909 -10590.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 34.0 -1954258334 15601 NULL NULL -1954258368 1954258334 -34.0 -3908516702 1.0 -15601.0 NULL -1.954273935E9 -0.04085294117647059 -14670.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 34.0 -1175444744 15601 NULL NULL -1175444778 1175444744 -34.0 -2350889522 1.0 -15601.0 NULL -1.175460345E9 -0.04085294117647059 -3000.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 34.0 -1028809597 15601 NULL NULL -1028809631 1028809597 -34.0 -2057619228 1.0 -15601.0 NULL -1.028825198E9 -0.04085294117647059 -1652.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 34.0 -748476723 15601 NULL NULL -748476757 748476723 -34.0 -1496953480 1.0 -15601.0 NULL -7.48492324E8 -0.04085294117647059 -3147.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 34.0 -461126191 15601 NULL NULL -461126225 461126191 -34.0 -922252416 1.0 -15601.0 NULL -4.61141792E8 -0.04085294117647059 -7434.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 34.0 -303944829 15601 NULL NULL -303944863 303944829 -34.0 -607889692 1.0 -15601.0 NULL -3.0396043E8 -0.04085294117647059 -6147.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 35.0 -1198622822 15601 NULL NULL -1198622857 1198622822 -35.0 -2397245679 1.0 -15601.0 NULL -1.198638423E9 -0.03968571428571429 -13593.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 35.0 -987166521 15601 NULL NULL -987166556 987166521 -35.0 -1974333077 1.0 -15601.0 NULL -9.87182122E8 -0.03968571428571429 -13246.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 35.0 -777113949 15601 NULL NULL -777113984 777113949 -35.0 -1554227933 1.0 -15601.0 NULL -7.7712955E8 -0.03968571428571429 -12538.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 35.0 -605058422 15601 NULL NULL -605058457 605058422 -35.0 -1210116879 1.0 -15601.0 NULL -6.05074023E8 -0.03968571428571429 -4839.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 35.0 -419284856 15601 NULL NULL -419284891 419284856 -35.0 -838569747 1.0 -15601.0 NULL -4.19300457E8 -0.03968571428571429 -7981.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 35.0 -370099117 15601 NULL NULL -370099152 370099117 -35.0 -740198269 1.0 -15601.0 NULL -3.70114718E8 -0.03968571428571429 -12195.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 36.0 -1493188887 15601 NULL NULL -1493188923 1493188887 -36.0 -2986377810 1.0 -15601.0 NULL -1.493204488E9 -0.03858333333333333 -1576.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 36.0 -1300587151 15601 NULL NULL -1300587187 1300587151 -36.0 -2601174338 1.0 -15601.0 NULL -1.300602752E9 -0.03858333333333333 -9786.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 38.0 -440412114 15601 NULL NULL -440412152 440412114 -38.0 -880824266 1.0 -15601.0 NULL -4.40427715E8 -0.03655263157894737 -11485.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 39.0 -1351910626 15601 NULL NULL -1351910665 1351910626 -39.0 -2703821291 1.0 -15601.0 NULL -1.351926227E9 -0.03561538461538462 -5971.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 39.0 -1046301933 15601 NULL NULL -1046301972 1046301933 -39.0 -2092603905 1.0 -15601.0 NULL -1.046317534E9 -0.03561538461538462 -5267.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 39.0 -484639113 15601 NULL NULL -484639152 484639113 -39.0 -969278265 1.0 -15601.0 NULL -4.84654714E8 -0.03561538461538462 -9649.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 39.0 -189542740 15601 NULL NULL -189542779 189542740 -39.0 -379085519 1.0 -15601.0 NULL -1.89558341E8 -0.03561538461538462 -6191.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 39.0 -144116978 15601 NULL NULL -144117017 144116978 -39.0 -288233995 1.0 -15601.0 NULL -1.44132579E8 -0.03561538461538462 -10541.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 40.0 -1530632114 15601 NULL NULL -1530632154 1530632114 -40.0 -3061264268 1.0 -15601.0 NULL -1.530647715E9 -0.034725 -2403.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 40.0 -912039001 15601 NULL NULL -912039041 912039001 -40.0 -1824078042 1.0 -15601.0 NULL -9.12054602E8 -0.034725 -4541.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 40.0 -515857483 15601 NULL NULL -515857523 515857483 -40.0 -1031715006 1.0 -15601.0 NULL -5.15873084E8 -0.034725 -10418.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 40.0 -487954385 15601 NULL NULL -487954425 487954385 -40.0 -975908810 1.0 -15601.0 NULL -4.87969986E8 -0.034725 -1908.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 41.0 -1730738390 15601 NULL NULL -1730738431 1730738390 -41.0 -3461476821 1.0 -15601.0 NULL -1.730753991E9 -0.03387804878048781 -10253.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 41.0 -338704173 15601 NULL NULL -338704214 338704173 -41.0 -677408387 1.0 -15601.0 NULL -3.38719774E8 -0.03387804878048781 -6463.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 41.0 -185407727 15601 NULL NULL -185407768 185407727 -41.0 -370815495 1.0 -15601.0 NULL -1.85423328E8 -0.03387804878048781 -5443.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 42.0 -1253747722 15601 NULL NULL -1253747764 1253747722 -42.0 -2507495486 1.0 -15601.0 NULL -1.253763323E9 -0.03307142857142857 -4559.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 42.0 -1127028116 15601 NULL NULL -1127028158 1127028116 -42.0 -2254056274 1.0 -15601.0 NULL -1.127043717E9 -0.03307142857142857 -11876.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 42.0 -658899077 15601 NULL NULL -658899119 658899077 -42.0 -1317798196 1.0 -15601.0 NULL -6.58914678E8 -0.03307142857142857 -6443.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 42.0 -122247742 15601 NULL NULL -122247784 122247742 -42.0 -244495526 1.0 -15601.0 NULL -1.22263343E8 -0.03307142857142857 -13907.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 42.0 -30310351 15601 NULL NULL -30310393 30310351 -42.0 -60620744 1.0 -15601.0 NULL -3.0325952E7 -0.03307142857142857 -13209.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 42.0 -27952228 15601 NULL NULL -27952270 27952228 -42.0 -55904498 1.0 -15601.0 NULL -2.7967829E7 -0.03307142857142857 -10837.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 44.0 -2098300466 15601 NULL NULL -2098300510 2098300466 -44.0 -4196600976 1.0 -15601.0 NULL -2.098316067E9 -0.03156818181818182 -12769.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 44.0 -1144200805 15601 NULL NULL -1144200849 1144200805 -44.0 -2288401654 1.0 -15601.0 NULL -1.144216406E9 -0.03156818181818182 -7864.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 44.0 -1109093265 15601 NULL NULL -1109093309 1109093265 -44.0 -2218186574 1.0 -15601.0 NULL -1.109108866E9 -0.03156818181818182 -2574.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 44.0 -780348314 15601 NULL NULL -780348358 780348314 -44.0 -1560696672 1.0 -15601.0 NULL -7.80363915E8 -0.03156818181818182 -1895.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 45.0 -689749024 15601 NULL NULL -689749069 689749024 -45.0 -1379498093 1.0 -15601.0 NULL -6.89764625E8 -0.030866666666666667 -13213.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 45.0 -223953421 15601 NULL NULL -223953466 223953421 -45.0 -447906887 1.0 -15601.0 NULL -2.23969022E8 -0.030866666666666667 -1066.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 45.0 -195941743 15601 NULL NULL -195941788 195941743 -45.0 -391883531 1.0 -15601.0 NULL -1.95957344E8 -0.030866666666666667 -8784.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 46.0 -1996378319 15601 NULL NULL -1996378365 1996378319 -46.0 -3992756684 1.0 -15601.0 NULL -1.99639392E9 -0.030195652173913044 -11955.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 46.0 -1721221449 15601 NULL NULL -1721221495 1721221449 -46.0 -3442442944 1.0 -15601.0 NULL -1.72123705E9 -0.030195652173913044 -9922.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 46.0 -1116090298 15601 NULL NULL -1116090344 1116090298 -46.0 -2232180642 1.0 -15601.0 NULL -1.116105899E9 -0.030195652173913044 -10359.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 46.0 -1063470233 15601 NULL NULL -1063470279 1063470233 -46.0 -2126940512 1.0 -15601.0 NULL -1.063485834E9 -0.030195652173913044 -12467.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 46.0 -645509327 15601 NULL NULL -645509373 645509327 -46.0 -1291018700 1.0 -15601.0 NULL -6.45524928E8 -0.030195652173913044 -2351.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 46.0 -591161051 15601 NULL NULL -591161097 591161051 -46.0 -1182322148 1.0 -15601.0 NULL -5.91176652E8 -0.030195652173913044 -7959.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 47.0 -1230441185 15601 NULL NULL -1230441232 1230441185 -47.0 -2460882417 1.0 -15601.0 NULL -1.230456786E9 -0.029553191489361703 -5916.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 47.0 -1220505630 15601 NULL NULL -1220505677 1220505630 -47.0 -2441011307 1.0 -15601.0 NULL -1.220521231E9 -0.029553191489361703 -8198.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 47.0 -1045079067 15601 NULL NULL -1045079114 1045079067 -47.0 -2090158181 1.0 -15601.0 NULL -1.045094668E9 -0.029553191489361703 -14880.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 47.0 -1019007115 15601 NULL NULL -1019007162 1019007115 -47.0 -2038014277 1.0 -15601.0 NULL -1.019022716E9 -0.029553191489361703 -12199.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 48.0 -795361000 15601 NULL NULL -795361048 795361000 -48.0 -1590722048 1.0 -15601.0 NULL -7.95376601E8 -0.0289375 -6419.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 48.0 -505179873 15601 NULL NULL -505179921 505179873 -48.0 -1010359794 1.0 -15601.0 NULL -5.05195474E8 -0.0289375 -3892.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -1506320791 15601 NULL NULL -1506320840 1506320791 -49.0 -3012641631 1.0 -15601.0 NULL -1.506336392E9 -0.028346938775510203 -13039.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -1259043484 15601 NULL NULL -1259043533 1259043484 -49.0 -2518087017 1.0 -15601.0 NULL -1.259059085E9 -0.028346938775510203 -11582.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -1107321329 15601 NULL NULL -1107321378 1107321329 -49.0 -2214642707 1.0 -15601.0 NULL -1.10733693E9 -0.028346938775510203 -9152.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 49.0 -839522912 15601 NULL NULL -839522961 839522912 -49.0 -1679045873 1.0 -15601.0 NULL -8.39538513E8 -0.028346938775510203 -1900.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -343392629 15601 NULL NULL -343392678 343392629 -49.0 -686785307 1.0 -15601.0 NULL -3.4340823E8 -0.028346938775510203 -14619.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -170140038 15601 NULL NULL -170140087 170140038 -49.0 -340280125 1.0 -15601.0 NULL -1.70155639E8 -0.028346938775510203 -11133.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 49.0 -128270777 15601 NULL NULL -128270826 128270777 -49.0 -256541603 1.0 -15601.0 NULL -1.28286378E8 -0.028346938775510203 -14956.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 51.0 -2103985381 15601 NULL NULL -2103985432 2103985381 -51.0 -4207970813 1.0 -15601.0 NULL -2.104000982E9 -0.02723529411764706 -3319.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 51.0 -2040027963 15601 NULL NULL -2040028014 2040027963 -51.0 -4080055977 1.0 -15601.0 NULL -2.040043564E9 -0.02723529411764706 -10001.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 51.0 -232545302 15601 NULL NULL -232545353 232545302 -51.0 -465090655 1.0 -15601.0 NULL -2.32560903E8 -0.02723529411764706 -12397.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 52.0 -2125793790 15601 NULL NULL -2125793842 2125793790 -52.0 -4251587632 1.0 -15601.0 NULL -2.125809391E9 -0.02671153846153846 -1530.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 52.0 -1927777662 15601 NULL NULL -1927777714 1927777662 -52.0 -3855555376 1.0 -15601.0 NULL -1.927793263E9 -0.02671153846153846 -8895.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 52.0 -1846410950 15601 NULL NULL -1846411002 1846410950 -52.0 -3692821952 1.0 -15601.0 NULL -1.846426551E9 -0.02671153846153846 -1398.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 52.0 -1214834730 15601 NULL NULL -1214834782 1214834730 -52.0 -2429669512 1.0 -15601.0 NULL -1.214850331E9 -0.02671153846153846 -461.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 52.0 -746546766 15601 NULL NULL -746546818 746546766 -52.0 -1493093584 1.0 -15601.0 NULL -7.46562367E8 -0.02671153846153846 -7714.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 53.0 -1283930255 15601 NULL NULL -1283930308 1283930255 -53.0 -2567860563 1.0 -15601.0 NULL -1.283945856E9 -0.026207547169811322 -14758.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 53.0 -1231026402 15601 NULL NULL -1231026455 1231026402 -53.0 -2462052857 1.0 -15601.0 NULL -1.231042003E9 -0.026207547169811322 -13896.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 53.0 -782857402 15601 NULL NULL -782857455 782857402 -53.0 -1565714857 1.0 -15601.0 NULL -7.82873003E8 -0.026207547169811322 -14823.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 54.0 -1735553309 15601 NULL NULL -1735553363 1735553309 -54.0 -3471106672 1.0 -15601.0 NULL -1.73556891E9 -0.025722222222222223 -4463.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 54.0 -1711666077 15601 NULL NULL -1711666131 1711666077 -54.0 -3423332208 1.0 -15601.0 NULL -1.711681678E9 -0.025722222222222223 -2362.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 54.0 -1676223874 15601 NULL NULL -1676223928 1676223874 -54.0 -3352447802 1.0 -15601.0 NULL -1.676239475E9 -0.025722222222222223 -5631.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 54.0 -1479988050 15601 NULL NULL -1479988104 1479988050 -54.0 -2959976154 1.0 -15601.0 NULL -1.480003651E9 -0.025722222222222223 -14786.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 54.0 -83357142 15601 NULL NULL -83357196 83357142 -54.0 -166714338 1.0 -15601.0 NULL -8.3372743E7 -0.025722222222222223 -999.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 55.0 -1559932440 15601 NULL NULL -1559932495 1559932440 -55.0 -3119864935 1.0 -15601.0 NULL -1.559948041E9 -0.025254545454545453 -4051.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 55.0 -1224290649 15601 NULL NULL -1224290704 1224290649 -55.0 -2448581353 1.0 -15601.0 NULL -1.22430625E9 -0.025254545454545453 -2174.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 55.0 -1044215393 15601 NULL NULL -1044215448 1044215393 -55.0 -2088430841 1.0 -15601.0 NULL -1.044230994E9 -0.025254545454545453 -9261.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 55.0 -819636483 15601 NULL NULL -819636538 819636483 -55.0 -1639273021 1.0 -15601.0 NULL -8.19652084E8 -0.025254545454545453 -6746.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 55.0 -486340511 15601 NULL NULL -486340566 486340511 -55.0 -972681077 1.0 -15601.0 NULL -4.86356112E8 -0.025254545454545453 -10538.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 56.0 -1971224972 15601 NULL NULL -1971225028 1971224972 -56.0 -3942450000 1.0 -15601.0 NULL -1.971240573E9 -0.02480357142857143 -7420.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 56.0 -1378117091 15601 NULL NULL -1378117147 1378117091 -56.0 -2756234238 1.0 -15601.0 NULL -1.378132692E9 -0.02480357142857143 -2756.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 56.0 -1061994141 15601 NULL NULL -1061994197 1061994141 -56.0 -2123988338 1.0 -15601.0 NULL -1.062009742E9 -0.02480357142857143 -2869.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 56.0 -85144619 15601 NULL NULL -85144675 85144619 -56.0 -170289294 1.0 -15601.0 NULL -8.516022E7 -0.02480357142857143 -9962.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 57.0 -1465657206 15601 NULL NULL -1465657263 1465657206 -57.0 -2931314469 1.0 -15601.0 NULL -1.465672807E9 -0.02436842105263158 -5660.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 57.0 -1393938237 15601 NULL NULL -1393938294 1393938237 -57.0 -2787876531 1.0 -15601.0 NULL -1.393953838E9 -0.02436842105263158 -4488.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 57.0 -865531893 15601 NULL NULL -865531950 865531893 -57.0 -1731063843 1.0 -15601.0 NULL -8.65547494E8 -0.02436842105263158 -4014.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 58.0 -2101713482 15601 NULL NULL -2101713540 2101713482 -58.0 -4203427022 1.0 -15601.0 NULL -2.101729083E9 -0.023948275862068966 -9166.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 58.0 -1624506701 15601 NULL NULL -1624506759 1624506701 -58.0 -3249013460 1.0 -15601.0 NULL -1.624522302E9 -0.023948275862068966 -5773.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 58.0 -1384901601 15601 NULL NULL -1384901659 1384901601 -58.0 -2769803260 1.0 -15601.0 NULL -1.384917202E9 -0.023948275862068966 -831.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 58.0 1575089695 15601 NULL NULL 1575089637 -1575089695 -58.0 3150179332 1.0 -15601.0 NULL 1.575074094E9 -0.023948275862068966 12735.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 59.0 -1374485693 15601 NULL NULL -1374485752 1374485693 -59.0 -2748971445 1.0 -15601.0 NULL -1.374501294E9 -0.02354237288135593 -6391.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 60.0 -1141582332 15601 NULL NULL -1141582392 1141582332 -60.0 -2283164724 1.0 -15601.0 NULL -1.141597933E9 -0.02315 -10359.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 60.0 -977722732 15601 NULL NULL -977722792 977722732 -60.0 -1955445524 1.0 -15601.0 NULL -9.77738333E8 -0.02315 -8062.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 60.0 -657503893 15601 NULL NULL -657503953 657503893 -60.0 -1315007846 1.0 -15601.0 NULL -6.57519494E8 -0.02315 -15349.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 60.0 -640286718 15601 NULL NULL -640286778 640286718 -60.0 -1280573496 1.0 -15601.0 NULL -6.40302319E8 -0.02315 -6077.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 61.0 -1377611623 15601 NULL NULL -1377611684 1377611623 -61.0 -2755223307 1.0 -15601.0 NULL -1.377627224E9 -0.02277049180327869 -12121.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 61.0 -155636656 15601 NULL NULL -155636717 155636656 -61.0 -311273373 1.0 -15601.0 NULL -1.55652257E8 -0.02277049180327869 -1080.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 62.0 -1838132825 15601 NULL NULL -1838132887 1838132825 -62.0 -3676265712 1.0 -15601.0 NULL -1.838148426E9 -0.022403225806451613 -7404.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 62.0 -1488190636 15601 NULL NULL -1488190698 1488190636 -62.0 -2976381334 1.0 -15601.0 NULL -1.488206237E9 -0.022403225806451613 -11246.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 62.0 -1423925704 15601 NULL NULL -1423925766 1423925704 -62.0 -2847851470 1.0 -15601.0 NULL -1.423941305E9 -0.022403225806451613 -6833.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 62.0 -310826420 15601 NULL NULL -310826482 310826420 -62.0 -621652902 1.0 -15601.0 NULL -3.10842021E8 -0.022403225806451613 -7697.0 -15601 NULL +NULL NULL true 1969-12-31 15:59:58.456 15601.0 62.0 -120943153 15601 NULL NULL -120943215 120943153 -62.0 -241886368 1.0 -15601.0 NULL -1.20958754E8 -0.022403225806451613 -4201.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 79.553 -1823591768 15601 NULL NULL -1823591801 1823591768 -79.553 -3647183569 1.0 -15601.0 NULL -1.823607369E9 -0.04209090909090909 -6479.0 -15601 NULL +NULL NULL false 1969-12-31 15:59:58.456 15601.0 79.553 -1452617198 15601 NULL NULL -1452617231 1452617198 -79.553 -2905234429 1.0 -15601.0 NULL -1.452632799E9 -0.04209090909090909 -8088.0 -15601 NULL +526337887 t0346137k7Lk0O true 1969-12-31 15:59:51.609 15044.0 NULL 1864027286 15044 false 526352931 NULL -1864027286 NULL NULL 1.0 -15044.0 -981136225450075266 1.864012242E9 NULL 466.0 -15044 526367975 +-367195514 t5805L0xlU0YM true 1969-12-31 15:59:43.799 -13339.0 NULL 1864027286 -13339 false -367208853 NULL -1864027286 NULL NULL 1.0 13339.0 684487321652762958 1.864040625E9 NULL 8748.0 13339 -367222192 +-380733719 t7s5did true NULL -2120.0 NULL 1864027286 -2120 false -380735839 NULL -1864027286 NULL NULL 1.0 2120.0 709701992654102954 1.864029406E9 NULL 326.0 2120 -380737959 +-104148943 tEO4vj3G true 1969-12-31 15:59:44.53 2248.0 NULL 1864027286 2248 false -104146695 NULL -1864027286 NULL NULL 1.0 -2248.0 194132281226719770 1.864025038E9 NULL 1422.0 -2248 -104144447 +-487903609 tINcSR1MT3f2P4 true 1969-12-31 16:00:12.099 -9147.0 NULL 1864027286 -9147 false -487912756 NULL -1864027286 NULL NULL 1.0 9147.0 909482690371460216 1.864036433E9 NULL 5891.0 9147 -487921903 +336056067 tJ7bf true 1969-12-31 15:59:50.481 16124.0 NULL 1864027286 16124 false 336072191 NULL -1864027286 NULL NULL 1.0 -16124.0 -626447734089803626 1.864011162E9 NULL 12266.0 -16124 336088315 +-459571311 taArL704d542R82qw8 true 1969-12-31 16:00:00.738 -13901.0 NULL 1864027286 -13901 false -459585212 NULL -1864027286 NULL NULL 1.0 13901.0 856679375410094632 1.864041187E9 NULL 493.0 13901 -459599113 +223484391 tca24E6L true 1969-12-31 16:00:02.505 -12721.0 NULL 1864027286 -12721 false 223471670 NULL -1864027286 NULL NULL 1.0 12721.0 -416557290527987620 1.864040007E9 NULL 6435.0 12721 223458949 +252479879 tdUWi true 1969-12-31 16:00:01.806 -877.0 NULL 1864027286 -877 false 252479002 NULL -1864027286 NULL NULL 1.0 877.0 -470627748870048572 1.864028163E9 NULL 620.0 877 252478125 +1030560824 tmS75um6Mvyb6N1oiKP7 true 1969-12-31 15:59:53.233 -11073.0 NULL 1864027286 -11073 false 1030549751 NULL -1864027286 NULL NULL 1.0 11073.0 -1920972855444505786 1.864038359E9 NULL 9539.0 11073 1030538678 +95424126 txKwQS70d20 true 1969-12-31 16:00:16.343 9766.0 NULL 1864027286 9766 false 95433892 NULL -1864027286 NULL NULL 1.0 -9766.0 -177891378697177112 1.86401752E9 NULL 632.0 -9766 95443658 +396908469 uGD31tQ70Py2E0T true 1969-12-31 15:59:50.224 16084.0 NULL 1864027286 16084 false 396924553 NULL -1864027286 NULL NULL 1.0 -16084.0 -739878197275353158 1.864011202E9 NULL 4274.0 -16084 396940637 +-770958258 uXu1mj3tWs36cGpu4p3aHq true 1969-12-31 15:59:56.944 8059.0 NULL 1864027286 8059 false -770950199 NULL -1864027286 NULL NULL 1.0 -8059.0 1437072207083129914 1.864019227E9 NULL 4763.0 -8059 -770942140 +-933664265 ue8IUf0GlY18RT325P2tu true 1969-12-31 16:00:02.456 13750.0 NULL 1864027286 13750 false -933650515 NULL -1864027286 NULL NULL 1.0 -13750.0 1740350035547952290 1.864013536E9 NULL 8536.0 -13750 -933636765 +-518918140 ugq0uAy0qXj2D0fX true 1969-12-31 16:00:12.479 5245.0 NULL 1864027286 5245 false -518912895 NULL -1864027286 NULL NULL 1.0 -5245.0 967267795337252970 1.864022041E9 NULL 1491.0 -5245 -518907650 +-360475292 uq2hp true 1969-12-31 16:00:10.933 -1007.0 NULL 1864027286 -1007 false -360476299 NULL -1864027286 NULL NULL 1.0 1007.0 671937657292294514 1.864028293E9 NULL 803.0 1007 -360477306 +-372506148 utfrK57P2tp0 true 1969-12-31 16:00:05.326 -12525.0 NULL 1864027286 -12525 false -372518673 NULL -1864027286 NULL NULL 1.0 12525.0 694384971016511478 1.864039811E9 NULL 6686.0 12525 -372531198 +434741484 uxI8i true 1969-12-31 16:00:12.505 8120.0 NULL 1864027286 8120 false 434749604 NULL -1864027286 NULL NULL 1.0 -8120.0 -810385124433694744 1.864019166E9 NULL 86.0 -8120 434757724 +-198739996 uxnt0fsrBtPD807 true 1969-12-31 16:00:11.528 -14709.0 NULL 1864027286 -14709 false -198754705 NULL -1864027286 NULL NULL 1.0 14709.0 370484193340880630 1.864041995E9 NULL 14552.0 14709 -198769414 +-452599200 v4L3dR650oy4O8MPhjc true 1969-12-31 15:59:46.988 8757.0 NULL 1864027286 8757 false -452590443 NULL -1864027286 NULL NULL 1.0 -8757.0 843640935134827698 1.864018529E9 NULL 3509.0 -8757 -452581686 +-601825532 v4gQqo0bxX256o7EEN42lSoU true 1969-12-31 15:59:58.417 11021.0 NULL 1864027286 11021 false -601814511 NULL -1864027286 NULL NULL 1.0 -11021.0 1121798669614747146 1.864016265E9 NULL 1472.0 -11021 -601803490 +-758062600 vA0bEQqO50LlKcj7AAR56P63 true 1969-12-31 16:00:16.169 7111.0 NULL 1864027286 7111 false -758055489 NULL -1864027286 NULL NULL 1.0 -7111.0 1413036115798072854 1.864020175E9 NULL 6634.0 -7111 -758048378 +573439687 vALXyM54AgSH4e0O4IN true 1969-12-31 16:00:10.069 -150.0 NULL 1864027286 -150 false 573439537 NULL -1864027286 NULL NULL 1.0 150.0 -1068906943839206582 1.864027436E9 NULL 86.0 150 573439387 +86487282 vH8AHgcWaDm true 1969-12-31 16:00:10.869 13309.0 NULL 1864027286 13309 false 86500591 NULL -1864027286 NULL NULL 1.0 -13309.0 -161239461879126026 1.864013977E9 NULL 8673.0 -13309 86513900 +-520765672 vQalqQ true 1969-12-31 15:59:44.48 -3969.0 NULL 1864027286 -3969 false -520769641 NULL -1864027286 NULL NULL 1.0 3969.0 970728820544424326 1.864031255E9 NULL 2312.0 3969 -520773610 +245429195 vXc7m82uAg2g24 true 1969-12-31 15:59:57.185 -16001.0 NULL 1864027286 -16001 false 245413194 NULL -1864027286 NULL NULL 1.0 16001.0 -457456889960411484 1.864043287E9 NULL 6792.0 16001 245397193 +-87388872 veoqj217BlDBBVkN0ei3c true 1969-12-31 16:00:03.492 10039.0 NULL 1864027286 10039 false -87378833 NULL -1864027286 NULL NULL 1.0 -10039.0 162876528930837238 1.864017247E9 NULL 5844.0 -10039 -87368794 +-64947310 vvictFVSOgi true 1969-12-31 15:59:48.172 6612.0 NULL 1864027286 6612 false -64940698 NULL -1864027286 NULL NULL 1.0 -6612.0 121051233043885628 1.864020674E9 NULL 5306.0 -6612 -64934086 +773348268 vwb48kytjp0Q2YEb true 1969-12-31 15:59:44.909 12581.0 NULL 1864027286 12581 false 773360849 NULL -1864027286 NULL NULL 1.0 -12581.0 -1441565724460125814 1.864014705E9 NULL 1164.0 -12581 773373430 +-532611088 wLWrtVNx188P7uXPV true 1969-12-31 16:00:04.012 -1428.0 NULL 1864027286 -1428 false -532612516 NULL -1864027286 NULL NULL 1.0 1428.0 992804262689111576 1.864028714E9 NULL 338.0 1428 -532613944 +936765787 wP0re2S74Y308jgOTc6 true 1969-12-31 15:59:50.924 -10311.0 NULL 1864027286 -10311 false 936755476 NULL -1864027286 NULL NULL 1.0 10311.0 -1746137767573918136 1.864037597E9 NULL 4706.0 10311 936745165 +236934374 wiBqE2A1x8T8gcT4 true 1969-12-31 16:00:11.324 -15101.0 NULL 1864027286 -15101 false 236919273 NULL -1864027286 NULL NULL 1.0 15101.0 -441623989451283078 1.864042387E9 NULL 5149.0 15101 236904172 +573476034 x1832l1R2m3V true 1969-12-31 15:59:49.722 -5070.0 NULL 1864027286 -5070 false 573470964 NULL -1864027286 NULL NULL 1.0 5070.0 -1068965524624723704 1.864032356E9 NULL 1226.0 5070 573465894 +605953955 x5vy367f6d81FfL8AI8XJ true 1969-12-31 16:00:01.206 11683.0 NULL 1864027286 11683 false 605965638 NULL -1864027286 NULL NULL 1.0 -11683.0 -1129536483610398468 1.864015603E9 NULL 4636.0 -11683 605977321 +2101183 x7By66525 true 1969-12-31 16:00:05.831 -8915.0 NULL 1864027286 -8915 false 2092268 NULL -1864027286 NULL NULL 1.0 8915.0 -3900044641624648 1.864036201E9 NULL 7766.0 8915 2083353 +741306115 y1uSBY0 true 1969-12-31 15:59:56.456 -16032.0 NULL 1864027286 -16032 false 741290083 NULL -1864027286 NULL NULL 1.0 16032.0 -1381784941553204738 1.864043318E9 NULL 2678.0 16032 741274051 +136715714 y2Q3YW true 1969-12-31 15:59:50.737 11813.0 NULL 1864027286 11813 false 136727527 NULL -1864027286 NULL NULL 1.0 -11813.0 -254863841075301722 1.864015473E9 NULL 6764.0 -11813 136739340 +-315135285 y4jD1v2Go true 1969-12-31 15:59:43.97 -4683.0 NULL 1864027286 -4683 false -315139968 NULL -1864027286 NULL NULL 1.0 4683.0 587429499261166848 1.864031969E9 NULL 1283.0 4683 -315144651 +855072260 y7S47c5V true 1969-12-31 16:00:08.381 -11734.0 NULL 1864027286 -11734 false 855060526 NULL -1864027286 NULL NULL 1.0 11734.0 -1593856151645512436 1.86403902E9 NULL 10982.0 11734 855048792 +-128417177 ygkC2e2sUm2036Sd1U8kCG62 true 1969-12-31 16:00:01.936 -8871.0 NULL 1864027286 -8871 false -128426048 NULL -1864027286 NULL NULL 1.0 8871.0 239389657705145728 1.864036157E9 NULL 8411.0 8871 -128434919 +732924624 yxN0212hM17E8J8bJj8D7b true 1969-12-31 15:59:46.461 -6751.0 NULL 1864027286 -6751 false 732917873 NULL -1864027286 NULL NULL 1.0 6751.0 -1366178913669082678 1.864034037E9 NULL 1925.0 6751 732911122 +-778541551 t66fkUkSNP78t2856Lcn true 1969-12-31 16:00:03.35 15678.0 NULL 1864027286 15678 true -778525873 NULL -1864027286 NULL NULL 1.0 -15678.0 1451193470128970678 1.864011608E9 NULL 7154.0 -15678 -778510195 +319983133 t78m7 true 1969-12-31 16:00:09.36 14512.0 NULL 1864027286 14512 true 319997645 NULL -1864027286 NULL NULL 1.0 -14512.0 -596484341735741470 1.864012774E9 NULL 4422.0 -14512 320012157 +58198060 t7Sx50XeM true 1969-12-31 16:00:07.889 7557.0 NULL 1864027286 7557 true 58205617 NULL -1864027286 NULL NULL 1.0 -7557.0 -108496858286465462 1.864019729E9 NULL 2552.0 -7557 58213174 +308450217 t7i26BC11U1YTY8I0p true 1969-12-31 15:59:46.402 1017.0 NULL 1864027286 1017 true 308451234 NULL -1864027286 NULL NULL 1.0 -1017.0 -574961516576370924 1.864026269E9 NULL 530.0 -1017 308452251 +-894394703 tFtQ26aDMi1tJ026luPcu true 1969-12-31 15:59:56.928 -3178.0 NULL 1864027286 -3178 true -894397881 NULL -1864027286 NULL NULL 1.0 3178.0 1667182054724580966 1.864030464E9 NULL 3166.0 3178 -894401059 +-362733967 tUi8QYP4S53YPcw true 1969-12-31 16:00:00.003 -7959.0 NULL 1864027286 -7959 true -362741926 NULL -1864027286 NULL NULL 1.0 7959.0 676160847840192836 1.864035245E9 NULL 5609.0 7959 -362749885 +426284338 u6ELlhG3 true 1969-12-31 16:00:00.64 -15070.0 NULL 1864027286 -15070 true 426269268 NULL -1864027286 NULL NULL 1.0 15070.0 -794577546735246648 1.864042356E9 NULL 3916.0 15070 426254198 +-804390280 uNJPm true 1969-12-31 16:00:12.321 -10737.0 NULL 1864027286 -10737 true -804401017 NULL -1864027286 NULL NULL 1.0 10737.0 1499425444574149862 1.864038023E9 NULL 8927.0 10737 -804411754 +-412772386 uO4aN4J0dKv3717r8fPG true 1969-12-31 16:00:07.824 -11809.0 NULL 1864027286 -11809 true -412784195 NULL -1864027286 NULL NULL 1.0 11809.0 769441002709544770 1.864039095E9 NULL 254.0 11809 -412796004 +-719899789 umNykRkKiih6Cx6K42 true 1969-12-31 15:59:55.878 -10134.0 NULL 1864027286 -10134 true -719909923 NULL -1864027286 NULL NULL 1.0 10134.0 1341931739934158978 1.86403742E9 NULL 9728.0 10134 -719920057 +-110450673 uv5m1sFX10 true 1969-12-31 16:00:16.376 -8148.0 NULL 1864027286 -8148 true -110458821 NULL -1864027286 NULL NULL 1.0 8148.0 205898256323389806 1.864035434E9 NULL 1178.0 8148 -110466969 +-804959350 v2wRf43gpDUt1lfieq true 1969-12-31 16:00:08.659 -8072.0 NULL 1864027286 -8072 true -804967422 NULL -1864027286 NULL NULL 1.0 8072.0 1500481238949076692 1.864035358E9 NULL 686.0 8072 -804975494 +460817498 v3A1iI77YBRwl3I16 true 1969-12-31 16:00:08.026 7391.0 NULL 1864027286 7391 true 460824889 NULL -1864027286 NULL NULL 1.0 -7391.0 -858990167163921254 1.864019895E9 NULL 2304.0 -7391 460832280 +108023602 veIw1kh7 true 1969-12-31 16:00:14.188 9239.0 NULL 1864027286 9239 true 108032841 NULL -1864027286 NULL NULL 1.0 -9239.0 -201376163408099526 1.864018047E9 NULL 3602.0 -9239 108042080 +-947255611 vgKx505VdPsHO true 1969-12-31 15:59:46.062 13661.0 NULL 1864027286 13661 true -947241950 NULL -1864027286 NULL NULL 1.0 -13661.0 1765684841243847700 1.864013625E9 NULL 11158.0 -13661 -947228289 +194353234 vtad71tYi1fs1e0tcJg0 true 1969-12-31 15:59:55.372 2960.0 NULL 1864027286 2960 true 194356194 NULL -1864027286 NULL NULL 1.0 -2960.0 -362285248819109484 1.864024326E9 NULL 2806.0 -2960 194359154 +97246854 vvK378scVFuBh8Q3HXUJsP true 1969-12-31 16:00:01.629 -9554.0 NULL 1864027286 -9554 true 97237300 NULL -1864027286 NULL NULL 1.0 9554.0 -181252980416967800 1.86403684E9 NULL 3670.0 9554 97227746 +304132102 vxAjxUq0k true 1969-12-31 16:00:03.466 -12962.0 NULL 1864027286 -12962 true 304119140 NULL -1864027286 NULL NULL 1.0 12962.0 -566886375154854040 1.864040248E9 NULL 952.0 12962 304106178 +-129248849 w3OO7InLN4ic3M0h8xpvuBMn true 1969-12-31 15:59:48.413 3255.0 NULL 1864027286 3255 true -129245594 NULL -1864027286 NULL NULL 1.0 -3255.0 240917313811277884 1.864024031E9 NULL 2711.0 -3255 -129242339 +466063930 w6OUE6V3UjfE2 true 1969-12-31 15:59:56.958 14276.0 NULL 1864027286 14276 true 466078206 NULL -1864027286 NULL NULL 1.0 -14276.0 -868782493393928916 1.86401301E9 NULL 9966.0 -14276 466092482 +746145173 wEe2THv60F6 true 1969-12-31 16:00:03.372 -5589.0 NULL 1864027286 -5589 true 746139584 NULL -1864027286 NULL NULL 1.0 5589.0 -1390824543740689024 1.864032875E9 NULL 773.0 5589 746133995 +-203191502 wK0N1nX22KSjcTVhDYq true 1969-12-31 15:59:49.907 -6663.0 NULL 1864027286 -6663 true -203198165 NULL -1864027286 NULL NULL 1.0 6663.0 378766924025130190 1.864033949E9 NULL 6395.0 6663 -203204828 +54908166 wLIR3B37 true 1969-12-31 16:00:05.971 8499.0 NULL 1864027286 8499 true 54916665 NULL -1864027286 NULL NULL 1.0 -8499.0 -102366162016121190 1.864018787E9 NULL 1109.0 -8499 54925164 +872474570 wT50ouOe760m3AyJ7x4p83U6 true 1969-12-31 15:59:46.57 -2856.0 NULL 1864027286 -2856 true 872471714 NULL -1864027286 NULL NULL 1.0 2856.0 -1626311081159188204 1.864030142E9 NULL 1766.0 2856 872468858 +247204221 wblxBWSlwWlX7E true 1969-12-31 15:59:54.186 4502.0 NULL 1864027286 4502 true 247208723 NULL -1864027286 NULL NULL 1.0 -4502.0 -460803805009215778 1.864022784E9 NULL 1198.0 -4502 247213225 +-520054643 wc4Ae163B5VxG2L true 1969-12-31 16:00:06.693 301.0 NULL 1864027286 301 true -520054342 NULL -1864027286 NULL NULL 1.0 -301.0 969395483690775812 1.864026985E9 NULL 205.0 -301 -520054041 +-553779656 weQ0d24K116Y0 true 1969-12-31 16:00:12.009 11147.0 NULL 1864027286 11147 true -553768509 NULL -1864027286 NULL NULL 1.0 -11147.0 1032239610903536574 1.864016139E9 NULL 3652.0 -11147 -553757362 +200690208 wfT8d53abPxBj0L true 1969-12-31 16:00:15.522 -12052.0 NULL 1864027286 -12052 true 200678156 NULL -1864027286 NULL NULL 1.0 12052.0 -374069558488164616 1.864039338E9 NULL 4706.0 12052 200666104 +421764768 whw6kHIbH true 1969-12-31 16:00:06.463 5142.0 NULL 1864027286 5142 true 421769910 NULL -1864027286 NULL NULL 1.0 -5142.0 -786190620653764260 1.864022144E9 NULL 866.0 -5142 421775052 +-370283300 x0w77gi6iqtTQ1 true 1969-12-31 15:59:44.652 1850.0 NULL 1864027286 1850 true -370281450 NULL -1864027286 NULL NULL 1.0 -1850.0 690214726299644700 1.864025436E9 NULL 586.0 -1850 -370279600 +-25028803 x8n40D35c65l true 1969-12-31 15:59:43.775 -4002.0 NULL 1864027286 -4002 true -25032805 NULL -1864027286 NULL NULL 1.0 4002.0 46661831565117230 1.864031288E9 NULL 3740.0 4002 -25036807 +-140351494 xh0Qhj80MAcHEMVKx true 1969-12-31 16:00:14.98 -11115.0 NULL 1864027286 -11115 true -140362609 NULL -1864027286 NULL NULL 1.0 11115.0 261639733110149174 1.864038401E9 NULL 8441.0 11115 -140373724 +773036466 xnk564ke0a7kay3aE6IC true 1969-12-31 16:00:12.369 -12066.0 NULL 1864027286 -12066 true 773024400 NULL -1864027286 NULL NULL 1.0 12066.0 -1440938574343778400 1.864039352E9 NULL 11276.0 12066 773012334 +336043289 xow6f03825H0h8mFjVr true 1969-12-31 15:59:51.587 -97.0 NULL 1864027286 -97 true 336043192 NULL -1864027286 NULL NULL 1.0 97.0 -626393679162536912 1.864027383E9 NULL 14.0 97 336043095 +-581868488 xqa4i5EAo4CbOQjD true 1969-12-31 16:00:14.891 15218.0 NULL 1864027286 15218 true -581853270 NULL -1864027286 NULL NULL 1.0 -15218.0 1084590371728325220 1.864012068E9 NULL 4902.0 -15218 -581838052 +-694015335 y3XV0j2p80 true 1969-12-31 15:59:52.848 9540.0 NULL 1864027286 9540 true -694005795 NULL -1864027286 NULL NULL 1.0 -9540.0 1293645738522122370 1.864017746E9 NULL 6686.0 -9540 -693996255 +35949208 yF6U2FcHNa8 true 1969-12-31 15:59:54.285 6775.0 NULL 1864027286 6775 true 35955983 NULL -1864027286 NULL NULL 1.0 -6775.0 -67022933406952138 1.864020511E9 NULL 1211.0 -6775 35962758 +-871616990 yfR36R70W0G1KV4dmi1 true 1969-12-31 15:59:52.407 -15590.0 NULL 1864027286 -15590 true -871632580 NULL -1864027286 NULL NULL 1.0 15590.0 1624746912486577880 1.864042876E9 NULL 8936.0 15590 -871648170 +1036977737 yvNv1q true 1969-12-31 15:59:46.839 7408.0 NULL 1864027286 7408 true 1036985145 NULL -1864027286 NULL NULL 1.0 -7408.0 -1932968605456666470 1.864019878E9 NULL 4102.0 -7408 1036992553 +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- TargetTypeClasses: Long, String, Double, Timestamp +-- Functions: Avg, Min, StDevP, Sum, Var +-- ArithmeticOps: Divide, Subtract, Multiply, Remainder +-- FilterOps: GreaterThan, LessThan, LessThanOrEqual, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Long, String, Double, Timestamp +-- Functions: Avg, Min, StDevP, Sum, Var +-- ArithmeticOps: Divide, Subtract, Multiply, Remainder +-- FilterOps: GreaterThan, LessThan, LessThanOrEqual, GreaterThanOrEqual, Like +-- GroupBy: NoGroupByProjectColumns +EXPLAIN SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring2)) (TOK_SELEXPR (TOK_TABLE_OR_COL cdouble)) (TOK_SELEXPR (TOK_TABLE_OR_COL cfloat)) (TOK_SELEXPR (TOK_TABLE_OR_COL cbigint)) (TOK_SELEXPR (TOK_TABLE_OR_COL csmallint)) (TOK_SELEXPR (/ (TOK_TABLE_OR_COL cbigint) 3569)) (TOK_SELEXPR (- (- 257) (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (* (- 6432) (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (* (TOK_TABLE_OR_COL cdouble) 10.175)) (TOK_SELEXPR (/ (* (- 6432) (TOK_TABLE_OR_COL cfloat)) (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (% (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (* (TOK_TABLE_OR_COL cdouble) (- (TOK_TABLE_OR_COL cdouble))))) (TOK_WHERE (OR (OR (AND (>= (- 1.389) (TOK_TABLE_OR_COL cint)) (AND (< (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL ctinyint)) (> (- 6432) (TOK_TABLE_OR_COL csmallint)))) (AND (>= (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cfloat)) (<= (TOK_TABLE_OR_COL cstring2) 'a'))) (AND (LIKE (TOK_TABLE_OR_COL cstring1) 'ss%') (> 10.175 (TOK_TABLE_OR_COL cbigint))))) (TOK_ORDERBY (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL csmallint)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cstring2)) (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cdouble))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (((((- 1.389) >= cint) and ((csmallint < ctinyint) and ((- 6432) > csmallint))) or ((cdouble >= cfloat) and (cstring2 <= 'a'))) or ((cstring1 like 'ss%') and (10.175 > cbigint))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: ctimestamp1 + type: timestamp + expr: cstring2 + type: string + expr: cdouble + type: double + expr: cfloat + type: float + expr: cbigint + type: bigint + expr: csmallint + type: smallint + expr: (cbigint / 3569) + type: double + expr: ((- 257) - csmallint) + type: int + expr: ((- 6432) * cfloat) + type: float + expr: (- cdouble) + type: double + expr: (cdouble * 10.175) + type: double + expr: (((- 6432) * cfloat) / cfloat) + type: double + expr: (- cfloat) + type: float + expr: (cint % csmallint) + type: int + expr: (- cdouble) + type: double + expr: (cdouble * (- cdouble)) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col5 + type: smallint + expr: _col1 + type: string + expr: _col2 + type: double + sort order: +++ + tag: -1 + value expressions: + expr: _col0 + type: timestamp + expr: _col1 + type: string + expr: _col2 + type: double + expr: _col3 + type: float + expr: _col4 + type: bigint + expr: _col5 + type: smallint + expr: _col6 + type: double + expr: _col7 + type: int + expr: _col8 + type: float + expr: _col9 + type: double + expr: _col10 + type: double + expr: _col11 + type: double + expr: _col12 + type: float + expr: _col13 + type: int + expr: _col14 + type: double + expr: _col15 + type: double + Vectorized execution: true + Reduce Operator Tree: + Extract + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT ctimestamp1, + cstring2, + cdouble, + cfloat, + cbigint, + csmallint, + (cbigint / 3569), + (-257 - csmallint), + (-6432 * cfloat), + (-(cdouble)), + (cdouble * 10.175), + ((-6432 * cfloat) / cfloat), + (-(cfloat)), + (cint % csmallint), + (-(cdouble)), + (cdouble * (-(cdouble))) +FROM alltypesorc +WHERE (((-1.389 >= cint) + AND ((csmallint < ctinyint) + AND (-6432 > csmallint))) + OR ((cdouble >= cfloat) + AND (cstring2 <= 'a')) + OR ((cstring1 LIKE 'ss%') + AND (10.175 > cbigint))) +ORDER BY csmallint, cstring2, cdouble +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +1969-12-31 16:00:08.451 rVWAj4N1MCg8Scyp7wj2C NULL -51.0 -89010 NULL -24.93975903614458 NULL 328032.0 NULL NULL -6432.0 51.0 NULL NULL NULL +NULL 4hA4KQj2vD3fI6gX82220d 477.0 NULL -1887561756 477 -528876.9279910339 -734 NULL -477.0 4853.475 NULL NULL -326 -477.0 -227529.0 +NULL xH7445Rals48VOulSyR5F 10221.0 NULL -1645852809 10221 -461152.37013168953 -10478 NULL -10221.0 103998.675 NULL NULL 5022 -10221.0 -1.04468841E8 +NULL 4hA4KQj2vD3fI6gX82220d 12329.0 NULL -1887561756 12329 -528876.9279910339 -12586 NULL -12329.0 125447.57500000001 NULL NULL -3104 -12329.0 -1.52004241E8 +1969-12-31 15:59:46.443 0034fkcXMQI3 15601.0 -43.0 -223687300 15601 -62675.06304286915 -15858 276576.0 -15601.0 158740.17500000002 -6432.0 43.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.778 00d5kr1wEB7evExG 15601.0 4.0 -941884962 15601 -263907.24628747546 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.729 020gtq4CLjybO3F40kpyXi 15601.0 30.0 -1986754040 15601 -556669.6665732699 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.704 041Ph15F 15601.0 -55.0 -1338667765 15601 -375082.02998038667 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.253 047TAc3t6f6rU8M7Dk7Gh8 15601.0 -44.0 272368436 15601 76315.05631829644 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.063 04XP4DrTCblC7885 15601.0 79.553 -1452617198 15601 -407009.58195572987 -15858 -511684.9 -15601.0 158740.17500000002 -6432.0 -79.553 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.123 064GHv0UW8 15601.0 -14.0 1007181336 15601 282202.67189688986 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.83 06Tj8f5xNhpaiE71AWqJ7b5 15601.0 -49.0 226841234 15601 63558.76548052676 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.436 08wTUR832pDS4Hd8O40 15601.0 -51.0 69448698 15601 19458.86746987952 -15858 328032.0 -15601.0 158740.17500000002 -6432.0 51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.258 0E6V6dPe00Ort5Ia6Ha8 15601.0 -26.0 1351243372 15601 378605.5959652564 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.552 0Ef374 15601.0 62.0 -1488190636 15601 -416976.9223872233 -15858 -398784.0 -15601.0 158740.17500000002 -6432.0 -62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.481 0IJJNV0BH 15601.0 10.0 -1230115822 15601 -344666.80358643876 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.535 0JA4aw00Rkv1mSy 15601.0 55.0 -1044215393 15601 -292579.26393947884 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.888 0KoLN8L6Iih8ej2sW7JF 15601.0 -23.0 -2104361963 15601 -589622.2927991034 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.645 0ORX152g18fL0nI10TVqI 15601.0 10.0 -1043251982 15601 -292309.3253012048 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.175 0Q7LP3644p 15601.0 -50.0 716349726 15601 200714.40907817316 -15858 321600.0 -15601.0 158740.17500000002 -6432.0 50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.655 0QVeMpE1JOCOS1427vP47tk0 15601.0 -23.0 649202618 15601 181900.4253292239 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.928 0UugmY0R5hI 15601.0 -32.0 1701987317 15601 476880.7276548053 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.153 0Yo1dcEr7D57no22Tiv2TXR 15601.0 -44.0 -399793337 15601 -112018.30680862987 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.715 0aQBRP67JY0gpi 15601.0 -44.0 -75975416 15601 -21287.59204258896 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.82 0bsH6qR 15601.0 -46.0 -208932264 15601 -58540.8416923508 -15858 295872.0 -15601.0 158740.17500000002 -6432.0 46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.33 0e8O8CeLi 15601.0 24.0 -1740312484 15601 -487619.0764920146 -15858 -154368.0 -15601.0 158740.17500000002 -6432.0 -24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.71 0h046K61PUKMqHs6v4 15601.0 -30.0 1221840945 15601 342348.26141776406 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.524 0ltFl7 15601.0 52.0 1551262646 15601 434649.1022695433 -15858 -334464.0 -15601.0 158740.17500000002 -6432.0 -52.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.007 0nur4r8MV673GcJp3h765I 15601.0 35.0 2123136080 15601 594882.6225833567 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.115 0p6665Ys81o1ITrC5DSoHV 15601.0 -20.0 -258993110 15601 -72567.41664331745 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.575 0q1A0HR4Q8Cd6r 15601.0 29.0 -221039350 15601 -61933.132530120485 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.401 0q4ykcW1A0SyL68L2FH45a 15601.0 30.0 2033485401 15601 569763.3513589241 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.786 0to563s4g3qycP5T8 15601.0 -1.0 672512361 15601 188431.59456430373 -15858 6432.0 -15601.0 158740.17500000002 -6432.0 1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.334 0u7Jba8i21vWm 15601.0 22.0 -1875861804 15601 -525598.7122443261 -15858 -141504.0 -15601.0 158740.17500000002 -6432.0 -22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.384 0uO20 15601.0 -59.0 1850076369 15601 518373.87755673856 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.279 0vC4nYJsnNgXvL5 15601.0 -11.0 1778089631 15601 498203.87531521433 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.932 10 15601.0 16.0 NULL 15601 NULL -15858 -102912.0 -15601.0 158740.17500000002 -6432.0 -16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.661 10mF5gYR5Fey1vTEHx 15601.0 25.0 -2030132877 15601 -568824.0058840011 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.997 12AEw 15601.0 -64.0 1421812187 15601 398378.30961053516 -15858 411648.0 -15601.0 158740.17500000002 -6432.0 64.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.853 12gbSP4px465TdXmV5F2apmC 15601.0 28.0 -1556827241 15601 -436208.2490893808 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.671 1434C61RVhlDmptMem1X 15601.0 -4.0 913861995 15601 256055.47632390025 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.499 14MDiWrX 15601.0 -33.0 42147119 15601 11809.223592042588 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.351 155506i0h358vma3m1tGku 15601.0 -57.0 1328883886 15601 372340.6797422247 -15858 366624.0 -15601.0 158740.17500000002 -6432.0 57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.522 1618frAK6kL 15601.0 -44.0 1296727292 15601 363330.70664051553 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.617 16NIx33qB1Thp5q 15601.0 -9.0 1660201497 15601 465172.7366209022 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.488 16jmamsEtKc51n 15601.0 1.0 -832606494 15601 -233288.45446903896 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.419 17i12pGg4fpDVOekj5 15601.0 59.0 -1374485693 15601 -385117.87419445225 -15858 -379488.0 -15601.0 158740.17500000002 -6432.0 -59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.284 17r8lCoU7J3mt47of258 15601.0 59.0 1841882240 15601 516077.9602129448 -15858 -379488.0 -15601.0 158740.17500000002 -6432.0 -59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.883 18032Ok80Rh3ICJd2QqF 15601.0 1.0 -2136727102 15601 -598690.6982347997 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.545 1812MP27X 15601.0 -25.0 882926601 15601 247387.6718968899 -15858 160800.0 -15601.0 158740.17500000002 -6432.0 25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.183 18QAI3 15601.0 0.0 1638241933 15601 459019.8747548333 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.863 1Ewed8Vw3iVfeeaXWE2g7 15601.0 -6.0 -786134704 15601 -220267.49901933313 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.578 1G71L 15601.0 -64.0 -1809291815 15601 -506946.43177360605 -15858 411648.0 -15601.0 158740.17500000002 -6432.0 64.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.691 1GMeP 15601.0 60.0 1480022657 15601 414688.33202577755 -15858 -385920.0 -15601.0 158740.17500000002 -6432.0 -60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.898 1GsrLIbvD7J7l7eyJ7 15601.0 -44.0 -772919195 15601 -216564.63855421686 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.839 1Ic5OYcpB 15601.0 -2.0 -430689331 15601 -120675.07172877557 -15858 12864.0 -15601.0 158740.17500000002 -6432.0 2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.539 1J2G60o 15601.0 -23.0 -1864716928 15601 -522476.0235360045 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.528 1L2401UOQ236aqX6dCr404H 15601.0 -41.0 NULL 15601 NULL -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.571 1NuHbq7wu 15601.0 -42.0 -1434650528 15601 -401975.49117399834 -15858 270144.0 -15601.0 158740.17500000002 -6432.0 42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.377 1Rnl53uFEkUaP567 15601.0 -44.0 -429050254 15601 -120215.81787615578 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.326 1TWVYbo8A06jVpsj 15601.0 -28.0 -1297431786 15601 -363528.09918744746 -15858 180096.0 -15601.0 158740.17500000002 -6432.0 28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.27 1a8dVp 15601.0 15.0 2106881426 15601 590328.2224712805 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.237 1af7dEq0egH 15601.0 -4.0 996077543 15601 279091.49425609416 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.206 1bQgOIC5M1mYO 15601.0 44.0 970663654 15601 271970.7632390025 -15858 -283008.0 -15601.0 158740.17500000002 -6432.0 -44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.31 1cySK1D066 15601.0 25.0 492608996 15601 138024.3754553096 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.207 1geCYToEJ2C 15601.0 -48.0 -652336471 15601 -182778.5012608574 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.214 1mwmV 15601.0 60.0 -640286718 15601 -179402.27458671897 -15858 -385920.0 -15601.0 158740.17500000002 -6432.0 -60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.869 1r31LS0 15601.0 16.0 908699526 15601 254609.00140095263 -15858 -102912.0 -15601.0 158740.17500000002 -6432.0 -16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.503 1sHwG4L77O4cr560Mb438A 15601.0 49.0 -343392629 15601 -96215.36256654526 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.224 1t0CR 15601.0 -21.0 1890350821 15601 529658.3975903614 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.894 1tIN2rwDJ0 15601.0 -6.0 -1207674957 15601 -338379.08573830203 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.264 1ydwoKOeCAx7c15W08 15601.0 40.0 2088429109 15601 585158.0579994397 -15858 -257280.0 -15601.0 158740.17500000002 -6432.0 -40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.821 203NY247Byl0uo 15601.0 34.0 1736691817 15601 486604.5998879238 -15858 -218688.0 -15601.0 158740.17500000002 -6432.0 -34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.935 23EpSjnhU1fkij33yNA763AK 15601.0 -19.0 897944388 15601 251595.5135892407 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.154 23HjoS18rjHCx771 15601.0 18.0 -996134600 15601 -279107.4810871393 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.281 23Uv26RhfxYCNyIQS1HJn 15601.0 -23.0 1273456471 15601 356810.44298122724 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.641 23fHhEiKL5D3voA 15601.0 -33.0 -1465766070 15601 -410693.7713645279 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.64 24Brw6 15601.0 7.0 1621296717 15601 454271.985710283 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.723 25EMXg12 15601.0 47.0 1447975413 15601 405708.9977584758 -15858 -302304.0 -15601.0 158740.17500000002 -6432.0 -47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.747 260x8Lpv5ILXWEPxlog248di 15601.0 22.0 1846338753 15601 517326.6329504063 -15858 -141504.0 -15601.0 158740.17500000002 -6432.0 -22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.911 268awl0F5A 15601.0 -39.0 -176425309 15601 -49432.70075651443 -15858 250848.0 -15601.0 158740.17500000002 -6432.0 39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.692 26VAMx7 15601.0 -30.0 1563934122 15601 438199.5298402914 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.459 27iT5rw 15601.0 18.0 -62733813 15601 -17577.420285794342 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.066 28412JHar2yEWJ4rsg 15601.0 -63.0 2059199534 15601 576968.2079013729 -15858 405216.0 -15601.0 158740.17500000002 -6432.0 63.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.241 28ao0HxkN7J72QNhcY 15601.0 2.0 419546737 15601 117553.02241524236 -15858 -12864.0 -15601.0 158740.17500000002 -6432.0 -2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.561 28j21KA5BLfXk8IrHe 15601.0 -33.0 -226993201 15601 -63601.34519473242 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.435 2C1n0DNS8X 15601.0 -26.0 -354697170 15601 -99382.78789576913 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.638 2EgCJP76SeDBsFg6w 15601.0 -33.0 570984089 15601 159984.33426730178 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.553 2FlOO88n5i2I 15601.0 29.0 1674587606 15601 469203.58811992157 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.476 2IDKgpJH461h554ubuHe2 15601.0 -55.0 996454184 15601 279197.0254973382 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.11 2M5wNS40c8E03s6aUlur 15601.0 -13.0 -928466576 15601 -260147.54160829363 -15858 83616.0 -15601.0 158740.17500000002 -6432.0 13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.286 2N0G8 15601.0 -47.0 -1828371599 15601 -512292.4065564584 -15858 302304.0 -15601.0 158740.17500000002 -6432.0 47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.95 2O55G 15601.0 -33.0 1958832178 15601 548846.2252731858 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.279 2On21PaPPbpDap7Q55a5Iw 15601.0 -58.0 2144274348 15601 600805.36508826 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.027 2R8parX8OGHj3vE6Hk761a6b 15601.0 62.0 -310826420 15601 -87090.61922107033 -15858 -398784.0 -15601.0 158740.17500000002 -6432.0 -62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.265 2S72XuXwWWB2bpmYpu6Y0q 15601.0 59.0 1762456014 15601 493823.48388904455 -15858 -379488.0 -15601.0 158740.17500000002 -6432.0 -59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.157 2TCJA4qtFeE58 15601.0 -45.0 -1291025659 15601 -361733.1630708882 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.446 2V30r60 15601.0 36.0 -1493188887 15601 -418377.3849817876 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.592 2V48sMwTCo8fdDnY78qDXns 15601.0 -45.0 1675482723 15601 469454.3914261698 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.696 2Y1016lg2I5NaYJ 15601.0 22.0 NULL 15601 NULL -15858 -141504.0 -15601.0 158740.17500000002 -6432.0 -22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.583 2YAbAlSe6FR66WFo 15601.0 -59.0 1364240151 15601 382247.170355842 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.864 2fqi280kgLqm40T8Pg2e47 15601.0 8.0 1990837220 15601 557813.734939759 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.108 2g0kR10R20S8bO7x233PflX 15601.0 -11.0 1810075387 15601 507165.98122723453 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.934 2hyiY02c4fV168hNxjdGqo 15601.0 28.0 -1852182045 15601 -518963.86803026055 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.102 2uXU06tULF7itEhNYy5j7k 15601.0 35.0 -987166521 15601 -276594.71028299246 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.975 2uvcn0tEsP42wySb0LWC875U 15601.0 -17.0 -590153501 15601 -165355.42196693752 -15858 109344.0 -15601.0 158740.17500000002 -6432.0 17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.698 2w0w8B85pE4jELXx 15601.0 13.0 -2108715482 15601 -590842.1075931634 -15858 -83616.0 -15601.0 158740.17500000002 -6432.0 -13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.08 2wgGraY3CIxDy8AxH3um15GE 15601.0 59.0 701594431 15601 196580.11515830766 -15858 -379488.0 -15601.0 158740.17500000002 -6432.0 -59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.39 30abVOkSw 15601.0 -57.0 -304247740 15601 -85247.33538806389 -15858 366624.0 -15601.0 158740.17500000002 -6432.0 57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.129 316f2Yg786dK8Bdk 15601.0 20.0 -362433250 15601 -101550.36424768843 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.709 31Sc0dgiT2Ag83txo7 15601.0 -8.0 -335617169 15601 -94036.75231157186 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.504 32XYGA7BOMTt27DGulBeUroc 15601.0 -50.0 -596103241 15601 -167022.48276828244 -15858 321600.0 -15601.0 158740.17500000002 -6432.0 50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.708 32gboqrESN35shM21v4Y 15601.0 -39.0 2129132384 15601 596562.7301765201 -15858 250848.0 -15601.0 158740.17500000002 -6432.0 39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.097 32u2yKHQehN 15601.0 -5.0 -1844060558 15601 -516688.3042869151 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.729 348A6IBn 15601.0 31.0 954086950 15601 267326.1277668815 -15858 -199392.0 -15601.0 158740.17500000002 -6432.0 -31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.342 34ByCIyiD2b3RM 15601.0 26.0 1802490164 15601 505040.67357803305 -15858 -167232.0 -15601.0 158740.17500000002 -6432.0 -26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.97 3503D1bt0J1Ud74yX4716121 15601.0 -2.0 -319788030 15601 -89601.57747268143 -15858 12864.0 -15601.0 158740.17500000002 -6432.0 2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.894 35MAHX70Py67 15601.0 42.0 1267863526 15601 355243.3527598767 -15858 -270144.0 -15601.0 158740.17500000002 -6432.0 -42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.279 35V0Eq127c7Jbvs862 15601.0 28.0 440950508 15601 123550.15634631549 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.644 35kveUkKO3V1ad2 15601.0 -23.0 NULL 15601 NULL -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.524 371wKbMGY2 15601.0 -61.0 1977536065 15601 554086.8772765481 -15858 392352.0 -15601.0 158740.17500000002 -6432.0 61.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.381 375tWcaL 15601.0 27.0 208571945 15601 58439.88372093023 -15858 -173664.0 -15601.0 158740.17500000002 -6432.0 -27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.809 38VIu8r35oI8LI 15601.0 9.0 1445910023 15601 405130.29504062765 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.62 3AXY47D 15601.0 -36.0 1449097159 15601 406023.3003642477 -15858 231552.0 -15601.0 158740.17500000002 -6432.0 36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.367 3DCKPI43L3d 15601.0 19.0 -408304573 15601 -114403.07453068087 -15858 -122208.0 -15601.0 158740.17500000002 -6432.0 -19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.637 3E6lh2b7Mc5EAYo3 15601.0 -8.0 -1768316238 15601 -495465.46315494535 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.14 3HY275 15601.0 -54.0 -989710558 15601 -277307.5253572429 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.309 3I62k00H8W4YkR8UVffhm 15601.0 37.0 1251122304 15601 350552.6209022135 -15858 -237984.0 -15601.0 158740.17500000002 -6432.0 -37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.801 3I6hScTcbL 15601.0 -37.0 333141293 15601 93343.03530400673 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.059 3J5RuDO2K 15601.0 -12.0 1511836517 15601 423602.27430652844 -15858 77184.0 -15601.0 158740.17500000002 -6432.0 12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.251 3J71K25Fc721kce4lIT 15601.0 18.0 827296932 15601 231800.76548052675 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.932 3NKHJC 15601.0 -59.0 -133287350 15601 -37345.853180162514 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.658 3RUv5ya25aqr5127TxoQT251 15601.0 -58.0 1395869576 15601 391109.43569627346 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.684 3RW7h8mx1UYX 15601.0 9.0 -605773050 15601 -169731.87167273747 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.385 3Rql1n377th0WNasiwTIqfAk 15601.0 -16.0 1164066405 15601 326160.38246007287 -15858 102912.0 -15601.0 158740.17500000002 -6432.0 16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.635 3STg8jD7jqGBM52TjVsB46Ab 15601.0 47.0 -1220505630 15601 -341974.1188007845 -15858 -302304.0 -15601.0 158740.17500000002 -6432.0 -47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.554 3T10x1IyRuV5H77 15601.0 -37.0 -218695361 15601 -61276.36901092743 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.978 3U24COBBS7q3TeS3m 15601.0 17.0 -402367872 15601 -112739.66713365089 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.038 3Uyh75B8Qwn 15601.0 -11.0 676428086 15601 189528.74362566546 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.759 3V8UHxN5TBU 15601.0 -51.0 NULL 15601 NULL -15858 328032.0 -15601.0 158740.17500000002 -6432.0 51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.35 3Xs32r0n4BU2f2tiC 15601.0 -11.0 986909074 15601 276522.5760717288 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.992 3a6E43HeD 15601.0 -60.0 1915758648 15601 536777.4300924629 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.948 3aDifhjuk6b4nntFIF 15601.0 8.0 1327060856 15601 371829.88400112075 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.106 3g41G77ehhX5fI7 15601.0 30.0 -1465963146 15601 -410748.99019333144 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.547 3g5v51lNv 15601.0 0.0 473839931 15601 132765.46119361164 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.409 3h42BQqfR5c74WLa 15601.0 -20.0 -57923441 15601 -16229.599607733258 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.346 3iHVpKa1Iy 15601.0 -18.0 -1414044792 15601 -396201.9590921827 -15858 115776.0 -15601.0 158740.17500000002 -6432.0 18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.239 3l33jTxWC 15601.0 -15.0 562442679 15601 157591.11207621184 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.834 3oIYv7OvH2vrLTHsa 15601.0 -23.0 -557847275 15601 -156303.52339590923 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.848 3qT4ePv7ISMeETgFD0b0S1Ly 15601.0 -4.0 -2142615863 15601 -600340.6732978425 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.687 3t5w8EbK07SIW3PEI4 15601.0 10.0 24464415 15601 6854.697394228075 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.984 3th76XH6M3nttE4 15601.0 29.0 1956045570 15601 548065.4441019894 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.949 3uojQvrD6m41To 15601.0 1.0 829192702 15601 232331.9422807509 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.725 3v66hVGTQa 15601.0 -50.0 -458110015 15601 -128358.08769963575 -15858 321600.0 -15601.0 158740.17500000002 -6432.0 50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.679 40at262XNm5auTvXDhreVM 15601.0 -5.0 612416000 15601 171593.16335107872 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.992 41k5oTFUiu5nv 15601.0 -28.0 989393728 15601 277218.7525917624 -15858 180096.0 -15601.0 158740.17500000002 -6432.0 28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.413 428fBlpfi 15601.0 51.0 -2040027963 15601 -571596.5152703839 -15858 -328032.0 -15601.0 158740.17500000002 -6432.0 -51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.884 42egcL8i65 15601.0 8.0 -1568412240 15601 -439454.256094144 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.059 44n5KP8SW 15601.0 -31.0 1250832914 15601 350471.5365648641 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.711 45ehHO1 15601.0 19.0 1981706992 15601 555255.5315214345 -15858 -122208.0 -15601.0 158740.17500000002 -6432.0 -19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.794 465xOUe8A4186sH 15601.0 56.0 -1061994141 15601 -297560.70075651444 -15858 -360192.0 -15601.0 158740.17500000002 -6432.0 -56.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.878 46cPsh 15601.0 -48.0 1544127003 15601 432649.76267862145 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.469 47Sm8wxGLl4syvsh1W8d2eq 15601.0 25.0 -1178735095 15601 -330270.4104791258 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.308 47tNFFE0l8022wydms 15601.0 6.0 -921789404 15601 -258276.66124964977 -15858 -38592.0 -15601.0 158740.17500000002 -6432.0 -6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.877 48gL7oUDAKW75kgT 15601.0 5.0 -245067785 15601 -68665.67245727095 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.876 4AqO5U 15601.0 -32.0 -938739544 15601 -263025.9299523676 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.124 4DwyxKwiHK3nV8p6 15601.0 32.0 -747159857 15601 -209347.11599887925 -15858 -205824.0 -15601.0 158740.17500000002 -6432.0 -32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.035 4E0UheoualijJ1rno 15601.0 46.0 -1116090298 15601 -312717.9316335108 -15858 -295872.0 -15601.0 158740.17500000002 -6432.0 -46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.782 4E1jb 15601.0 7.0 -484557615 15601 -135768.45474922948 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.334 4EbBPLvTO2Pe6s33iKn8 15601.0 46.0 -1721221449 15601 -482269.9492855141 -15858 -295872.0 -15601.0 158740.17500000002 -6432.0 -46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.384 4F7q027w 15601.0 -37.0 -1373443946 15601 -384825.9865508546 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.781 4HXsi4dv 15601.0 40.0 -487954385 15601 -136720.19753432335 -15858 -257280.0 -15601.0 158740.17500000002 -6432.0 -40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.777 4J1YKqEsJ2K0e85FB1Q 15601.0 0.0 -203039588 15601 -56889.7696833847 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.379 4L28g68B1xnrTBsnCa 15601.0 -22.0 1593645377 15601 446524.3421126366 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.504 4M0VqYd8r8D5 15601.0 -26.0 2102392175 15601 589070.3768562622 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.031 4P1l3UF37p8CvAKi5qA 15601.0 40.0 -912039001 15601 -255544.69066965536 -15858 -257280.0 -15601.0 158740.17500000002 -6432.0 -40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.249 4Rq1pXQeEsPt 15601.0 42.0 -122247742 15601 -34252.659568506584 -15858 -270144.0 -15601.0 158740.17500000002 -6432.0 -42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.386 4U34tbdGyu6f52ry 15601.0 1.0 254788466 15601 71389.31521434576 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.315 4UWNuEfgp 15601.0 8.0 -1393500402 15601 -390445.61557859345 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.452 4Y8Yutn4b4HF0 15601.0 -6.0 -337682588 15601 -94615.46315494536 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.821 4c7SDx6WePBLWjdjH1o7ix 15601.0 -37.0 79643966 15601 22315.485009806667 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.819 4i342tHD 15601.0 10.0 1177275310 15601 329861.3925469319 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.049 4lAdgqS7J8PYkK 15601.0 0.0 1561097160 15601 437404.6399551695 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.397 52cUSOgt7i1PMGWG3 15601.0 0.0 53950949 15601 15116.544970579995 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.798 53J14DdxOk0BwV5x3TunGjou 15601.0 18.0 -860591619 15601 -241129.62146259457 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.432 53X1h8m4Q5y8SGKk0EL74v 15601.0 16.0 326323074 15601 91432.63491173998 -15858 -102912.0 -15601.0 158740.17500000002 -6432.0 -16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.496 53XJFq221K 15601.0 15.0 147916674 15601 41444.8512188288 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.162 545WCULCG83sT3fR1RD38e 15601.0 17.0 -1749442997 15601 -490177.3597646399 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.558 54Q740CGYW4r2 15601.0 -4.0 1385428226 15601 388183.8683104511 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.054 54X76o 15601.0 -18.0 1179135101 15601 330382.488372093 -15858 115776.0 -15601.0 158740.17500000002 -6432.0 18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.094 54gc6c4vFnE7BduQcdm 15601.0 -9.0 -216777441 15601 -60738.98599047352 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.87 56015OKS42DG3ju4KW0a558 15601.0 -31.0 -1784005728 15601 -499861.50966657326 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.166 563BdSoLJFx 15601.0 6.0 -47379735 15601 -13275.353040067246 -15858 -38592.0 -15601.0 158740.17500000002 -6432.0 -6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.697 5684o66hD1A 15601.0 33.0 -667436971 15601 -187009.51835247967 -15858 -212256.0 -15601.0 158740.17500000002 -6432.0 -33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.984 568U4kod3IM212hiu8KM 15601.0 7.0 160900383 15601 45082.76351919305 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.334 56J7AFRtVC30pT458Lc3461 15601.0 28.0 -1767756774 15601 -495308.70664051553 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.066 56ac8 15601.0 -20.0 -41530125 15601 -11636.347716447184 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.307 578rPxyhOk6IXAKYJn 15601.0 14.0 NULL 15601 NULL -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.805 57eimVBuq4i3FdRlJi5iNFh5 15601.0 -35.0 1326401578 15601 371645.1605491734 -15858 225120.0 -15601.0 158740.17500000002 -6432.0 35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.548 584i3Q7R5P65nCfCt30B 15601.0 48.0 1276990360 15601 357800.60521154385 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.279 5DJnb 15601.0 38.0 299342203 15601 83872.85037825721 -15858 -244416.0 -15601.0 158740.17500000002 -6432.0 -38.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.68 5EBH67Oqi47O 15601.0 -2.0 1450853557 15601 406515.426449986 -15858 12864.0 -15601.0 158740.17500000002 -6432.0 2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.894 5EIQq8oF 15601.0 4.0 -25467184 15601 -7135.663771364528 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.252 5FApe58n1bNcyN52tE 15601.0 -8.0 -1902104689 15601 -532951.720089661 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.763 5Fy3QhweW 15601.0 -29.0 1023307150 15601 286720.97226113756 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.021 5HN44RVUXF0ELkvPAkQntoiB 15601.0 13.0 -2058347315 15601 -576729.4242084618 -15858 -83616.0 -15601.0 158740.17500000002 -6432.0 -13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.124 5JN6of4vi 15601.0 55.0 448409948 15601 125640.22079013729 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.493 5MO0A16x7Ec5nM23WnBU 15601.0 -33.0 -6432 15601 -1.8021854861305688 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.86 5Pn1BhiCeCd 15601.0 30.0 160587665 15601 44995.14289717007 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.957 5SVe8AEjY848Rf 15601.0 -56.0 -1683701844 15601 -471757.31129167834 -15858 360192.0 -15601.0 158740.17500000002 -6432.0 56.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.344 5Sm77ix2oQa7spX 15601.0 47.0 1640015816 15601 459516.89997198095 -15858 -302304.0 -15601.0 158740.17500000002 -6432.0 -47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.733 5UcDl 15601.0 -63.0 483904240 15601 135585.38526197814 -15858 405216.0 -15601.0 158740.17500000002 -6432.0 63.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.096 5fTGTHvaK 15601.0 -41.0 -480294523 15601 -134573.97674418605 -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.418 5fecwPu2O6YdwAt 15601.0 -20.0 -125514283 15601 -35167.913421126366 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.506 5kH1rO 15601.0 26.0 1341651482 15601 375918.0392266741 -15858 -167232.0 -15601.0 158740.17500000002 -6432.0 -26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.779 5lXRdTnA22VoT16Npr 15601.0 -60.0 1122241452 15601 314441.4267301765 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.066 5rg4D5D3KoH7Em1 15601.0 -58.0 2079381885 15601 582623.1115158307 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.076 5t0xD81bv100c5Tsy0T 15601.0 15.0 1329082102 15601 372396.217988232 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.026 5tCt5 15601.0 8.0 -671519607 15601 -188153.43429532083 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.188 5w4L1fDocLE51HE7N3c 15601.0 -63.0 -1574729892 15601 -441224.4023536004 -15858 405216.0 -15601.0 158740.17500000002 -6432.0 63.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.782 5ydLyNvMP2B2 15601.0 34.0 -1175444744 15601 -329348.4852899972 -15858 -218688.0 -15601.0 158740.17500000002 -6432.0 -34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.832 6002q 15601.0 37.0 676613895 15601 189580.8055477725 -15858 -237984.0 -15601.0 158740.17500000002 -6432.0 -37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.364 60B4H0EgaA4NC5Iyy4O 15601.0 -3.0 211786821 15601 59340.66152984029 -15858 19296.0 -15601.0 158740.17500000002 -6432.0 3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.916 60fy6yAOepPm6l3 15601.0 58.0 -1624506701 15601 -455171.3928271225 -15858 -373056.0 -15601.0 158740.17500000002 -6432.0 -58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.136 60g81s 15601.0 -51.0 1551526522 15601 434723.0378257215 -15858 328032.0 -15601.0 158740.17500000002 -6432.0 51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.675 60o1F4eW1 15601.0 -41.0 1718435591 15601 481489.3782572149 -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.873 62YSTHdPej50X5u3O1D 15601.0 -62.0 281485844 15601 78869.66769403194 -15858 398784.0 -15601.0 158740.17500000002 -6432.0 62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.124 63N5mknei4aeWJ8V0qwVI 15601.0 5.0 188016060 15601 52680.3194172037 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.198 63eX32F8ps86O 15601.0 -2.0 -2115132140 15601 -592639.9943961895 -15858 12864.0 -15601.0 158740.17500000002 -6432.0 2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.465 63ml1hL17Hky 15601.0 -39.0 -775351902 15601 -217246.26001681143 -15858 250848.0 -15601.0 158740.17500000002 -6432.0 39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.616 64NUjX13Fyeb7AWh5DX2D 15601.0 39.0 333745628 15601 93512.36424768843 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.182 66NbK5Ke 15601.0 -19.0 -1293795844 15601 -362509.34267301764 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.305 66O6v0Vf6jvnQs2Ps62hYr4 15601.0 -30.0 701736845 15601 196620.01821238443 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.179 66S3R 15601.0 52.0 113813447 15601 31889.44998599047 -15858 -334464.0 -15601.0 158740.17500000002 -6432.0 -52.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:43.721 67e72C1HvFm3G61s3E 15601.0 57.0 -1465657206 15601 -410663.26870271785 -15858 -366624.0 -15601.0 158740.17500000002 -6432.0 -57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.752 67jdQgbohcurvMDHh5W 15601.0 36.0 4757615 15601 1333.0386662930794 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.218 67p706r1Gv1cjIO 15601.0 -54.0 -641670659 15601 -179790.0417483889 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.462 68ldxXNy74071w 15601.0 35.0 -777113949 15601 -217739.96889885122 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.388 6A657TNuJgSp1Y6chfUOqyo 15601.0 20.0 1605330367 15601 449798.3656486411 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.299 6C5K3WGc2laGctSI2m0o8 15601.0 47.0 -1019007115 15601 -285516.1431773606 -15858 -302304.0 -15601.0 158740.17500000002 -6432.0 -47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.965 6D4DQRSeJLF51 15601.0 50.0 1278766496 15601 358298.2616979546 -15858 -321600.0 -15601.0 158740.17500000002 -6432.0 -50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.03 6ERA57C3XFjRG3oJ0 15601.0 25.0 -765146525 15601 -214386.81003082095 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.631 6G507mfwId541DtIuy 15601.0 -53.0 1415455683 15601 396597.27738862426 -15858 340896.0 -15601.0 158740.17500000002 -6432.0 53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.034 6HHDm16v6VrJA 15601.0 20.0 811631368 15601 227411.4228075091 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.32 6KJ1McyXPvnI1aVA2m1 15601.0 39.0 -144116978 15601 -40380.21238442141 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.444 6N24JhdOx8Uu368 15601.0 -5.0 -685821373 15601 -192160.65368450547 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.896 6Qtj3B0piVu 15601.0 46.0 -1063470233 15601 -297974.28775567387 -15858 -295872.0 -15601.0 158740.17500000002 -6432.0 -46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.171 6RF0nrPv31V5d7y203yEhP04 15601.0 -11.0 -26446061 15601 -7409.935836368731 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.101 6Ro6sc8i5gt3Yau7O 15601.0 -6.0 -847064600 15601 -237339.47884561503 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.975 6TeJh6uj8yr 15601.0 23.0 446614861 15601 125137.25441300085 -15858 -147936.0 -15601.0 158740.17500000002 -6432.0 -23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.052 6U81A8U3S 15601.0 -22.0 -1138394041 15601 -318967.2291958532 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.88 6UFb57s47rh1M046gK2RyP 15601.0 48.0 1294882412 15601 362813.7887363407 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.811 6WUSYOYu 15601.0 11.0 317708856 15601 89019.01260857383 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.52 6ej7IPl1axJbEoLTlQd2V 15601.0 -35.0 682869093 15601 191333.45278789577 -15858 225120.0 -15601.0 158740.17500000002 -6432.0 35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.045 6ekoSl0HCwx6IuWGt5JC5U0 15601.0 34.0 709756299 15601 198866.9932754273 -15858 -218688.0 -15601.0 158740.17500000002 -6432.0 -34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.338 6hI8NKEDoQHh 15601.0 11.0 1647833756 15601 461707.41272065 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.677 6iO7Vgh08 15601.0 -55.0 -1062767051 15601 -297777.2628187167 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.859 6l8L47 15601.0 -54.0 1882977755 15601 527592.5343233398 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.056 6mWsAi 15601.0 58.0 235428680 15601 65964.88652283553 -15858 -373056.0 -15601.0 158740.17500000002 -6432.0 -58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.467 6oAqXj7Kno4oPwyyvkFHx26E 15601.0 27.0 -67671601 15601 -18960.94172036985 -15858 -173664.0 -15601.0 158740.17500000002 -6432.0 -27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.739 6p3YH01g4Q 15601.0 25.0 1972121187 15601 552569.6797422247 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.394 6rMa1i 15601.0 48.0 400830823 15601 112309.00056038106 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.803 6tDKNa 15601.0 35.0 456583571 15601 127930.39254693191 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.703 6ukSO2rt3sY 15601.0 17.0 912955819 15601 255801.5743905856 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.961 6xam34x8s05c60D8BXMDCP 15601.0 32.0 1194813198 15601 334775.34267301764 -15858 -205824.0 -15601.0 158740.17500000002 -6432.0 -32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.733 6ySy81Xi5 15601.0 54.0 -1676223874 15601 -469662.0549173438 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.606 70CwR7G80qU0a 15601.0 29.0 -2052415815 15601 -575067.474082376 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.265 70Kvn2dL1ONDAGv22fni5S 15601.0 -44.0 299090584 15601 83802.34911739983 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.779 71w84QYjROpI1LRs 15601.0 12.0 627141836 15601 175719.20313813392 -15858 -77184.0 -15601.0 158740.17500000002 -6432.0 -12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.576 73117URk7G4v 15601.0 -46.0 529529092 15601 148369.03670495938 -15858 295872.0 -15601.0 158740.17500000002 -6432.0 46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.229 73l03Fiy5cx14fg 15601.0 -21.0 1679050126 15601 470453.9439618941 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.495 74B2Y5Q 15601.0 -13.0 -1040843741 15601 -291634.5589801065 -15858 83616.0 -15601.0 158740.17500000002 -6432.0 13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.055 74YmI3NrkE60Skh0247Cef 15601.0 22.0 1592489073 15601 446200.3566825441 -15858 -141504.0 -15601.0 158740.17500000002 -6432.0 -22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.16 770AYojc7s 15601.0 -4.0 1380425571 15601 386782.1717567946 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.81 77KSI1X3EL2 15601.0 -54.0 1750152891 15601 490376.2653404315 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.23 77tF4t 15601.0 30.0 -919690155 15601 -257688.47156066124 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.68 78Qfd68RemAlT6Kn8j 15601.0 19.0 605778880 15601 169733.5051835248 -15858 -122208.0 -15601.0 158740.17500000002 -6432.0 -19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.982 7AL73c 15601.0 -21.0 1650023180 15601 462320.86859064165 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.457 7C80P162Dh088i1 15601.0 -32.0 -2105144474 15601 -589841.54497058 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.215 7E0b24sDWE4IdwLO 15601.0 16.0 2125913889 15601 595660.9383580835 -15858 -102912.0 -15601.0 158740.17500000002 -6432.0 -16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.799 7JQfxa2Or8T4qp 15601.0 45.0 761255971 15601 213296.7136452788 -15858 -289440.0 -15601.0 158740.17500000002 -6432.0 -45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.823 7KGMko8S5y3g5jq 15601.0 -59.0 543831209 15601 152376.35444101988 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.184 7MH3oxJA2Tk 15601.0 -11.0 -1964641289 15601 -550473.8831605492 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.054 7Q2u1kLd7Mfy1 15601.0 -14.0 -1863202490 15601 -522051.6923507985 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.506 7QuAXV6VYT7q 15601.0 38.0 1524423680 15601 427129.07817315776 -15858 -244416.0 -15601.0 158740.17500000002 -6432.0 -38.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.393 7RSMUpu2l 15601.0 31.0 1827212970 15601 511967.7696833847 -15858 -199392.0 -15601.0 158740.17500000002 -6432.0 -31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.738 7RTbw57HqNyGPcn 15601.0 17.0 -1932369186 15601 -541431.545530961 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.829 7Ur2a5SGe4m64pM2BC 15601.0 57.0 560414150 15601 157022.7374614738 -15858 -366624.0 -15601.0 158740.17500000002 -6432.0 -57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.093 7V5hA1gBCS673CU337DA24Ce 15601.0 -32.0 1991822914 15601 558089.9170636033 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.457 7W2RwS80JX 15601.0 -26.0 432515401 15601 121186.71924908938 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.555 7Wy08w00BpunUYJVsr05u46 15601.0 20.0 -89010 15601 -24.93975903614458 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.755 7X08u20Av7FQvjLy5L52 15601.0 -31.0 1705300763 15601 477809.1238442141 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.851 7XSN7PgyBJ42NuN87t 15601.0 -49.0 -668597606 15601 -187334.7172877557 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.783 7adFqAqlKXtTQ 15601.0 -8.0 -1493703726 15601 -418521.6379938358 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.383 7arS506d1YXayI 15601.0 -60.0 -1016256928 15601 -284745.5668254413 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.747 7hs2n1g25 15601.0 -13.0 377434477 15601 105753.56598486971 -15858 83616.0 -15601.0 158740.17500000002 -6432.0 13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.022 7jEJE3CR3l027M76o2N81 15601.0 0.0 1018195815 15601 285288.8246007285 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.251 7o8D0lTRw30h 15601.0 36.0 -1300587151 15601 -364412.2025777529 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.609 7od8M476cRRTyd1i 15601.0 -41.0 2067730138 15601 579358.4023536005 -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.039 7rem6u7WK00EsD1mq6gp80 15601.0 0.0 98841361 15601 27694.413281031102 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.377 7s3sR2QjWXv0 15601.0 -44.0 -1032806869 15601 -289382.7035584197 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.615 7vT82OOJ7VpT5J 15601.0 10.0 1661516996 15601 465541.326982348 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.209 80rr6EU 15601.0 -41.0 -560714683 15601 -157106.94396189408 -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.79 82g6ygwAG80 15601.0 39.0 -484639113 15601 -135791.28971700757 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.61 8367JQap6U744J2 15601.0 54.0 -1711666077 15601 -479592.62454469036 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.957 85F0x1b1jAwFtt0 15601.0 -7.0 1631784601 15601 457210.5914822079 -15858 45024.0 -15601.0 158740.17500000002 -6432.0 7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.552 85i7Iq6mS56rOtT28bhNjy 15601.0 -42.0 -933775134 15601 -261634.94928551416 -15858 270144.0 -15601.0 158740.17500000002 -6432.0 42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.132 85nENa25nmPijGxYvb5F7 15601.0 -43.0 1489229962 15601 417268.1316895489 -15858 276576.0 -15601.0 158740.17500000002 -6432.0 43.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.845 86Rm22yWrLRgkI6V 15601.0 -1.0 1809122123 15601 506898.88568226394 -15858 6432.0 -15601.0 158740.17500000002 -6432.0 1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.945 87Iw7D4t61rud4M 15601.0 9.0 -910567691 15601 -255132.44354160829 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.755 8C2si8HMM25gTx 15601.0 29.0 252879408 15601 70854.4152423648 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.284 8CiP3 15601.0 10.175 99984127 15601 28014.60549173438 -15858 -65445.6 -15601.0 158740.17500000002 -6432.0 -10.175 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.231 8DLDCR7L 15601.0 -4.0 1522352025 15601 426548.6200616419 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.483 8FK46Fy4W5mow61w1EO 15601.0 19.0 -1644279296 15601 -460711.4866909498 -15858 -122208.0 -15601.0 158740.17500000002 -6432.0 -19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.512 8I7242Peq34tib 15601.0 41.0 -338704173 15601 -94901.70159708602 -15858 -263712.0 -15601.0 158740.17500000002 -6432.0 -41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.106 8NB5Hm30xPsXKoQUCdxi 15601.0 -62.0 -1592016120 15601 -446067.83973101707 -15858 398784.0 -15601.0 158740.17500000002 -6432.0 62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.205 8NgNgkpB06N7bMGgBs5QJ 15601.0 14.0 -1954298743 15601 -547575.9997198095 -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.936 8R8xyd522O4QL6chM 15601.0 9.0 -1620061206 15601 -453925.8072289157 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.848 8T0iicu1hkiuJIF6nIYW0G5 15601.0 7.0 821719163 15601 230237.92743065284 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.813 8U6rv3y3cwrlg6L 15601.0 -23.0 380840615 15601 106707.9335948445 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.674 8V43o1S8d0t6u4i 15601.0 37.0 1217409914 15601 341106.7284953769 -15858 -237984.0 -15601.0 158740.17500000002 -6432.0 -37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.267 8Vs552xiccF5j3n60 15601.0 -14.0 862568803 15601 241683.60969459233 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.887 8W4LA8kaxVohu172E 15601.0 -14.0 946654233 15601 265243.5508545811 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.153 8bcU4P2 15601.0 -6.0 -659825179 15601 -184876.76632109834 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.582 8dvkU0qkX4qr 15601.0 29.0 1195930056 15601 335088.2757074811 -15858 -186528.0 -15601.0 158740.17500000002 -6432.0 -29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.383 8e3Ri1wGpcM 15601.0 -33.0 -2080305624 15601 -582881.9344354161 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.695 8e7L21Y4g8xid8j 15601.0 25.0 451518699 15601 126511.26337909779 -15858 -160800.0 -15601.0 158740.17500000002 -6432.0 -25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.218 8fhS6JqUfN 15601.0 39.0 923495645 15601 258754.73381899693 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.915 8fxjs0MMOIa0N27 15601.0 -14.0 -205670222 15601 -57626.84841692351 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.221 8gqle254GhDd1pCxr2k45 15601.0 -40.0 159274870 15601 44627.31017091622 -15858 257280.0 -15601.0 158740.17500000002 -6432.0 40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.612 8qRIl5Mu125F3y0RDS2tJ 15601.0 -30.0 1787283476 15601 500779.9036144578 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.682 8r0tSk 15601.0 -10.0 944581452 15601 264662.777248529 -15858 64320.0 -15601.0 158740.17500000002 -6432.0 10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.237 8rt58A3QR04YRX4t 15601.0 -44.0 -1551649760 15601 -434757.5679462034 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.017 8wAyA76 15601.0 41.0 137074296 15601 38406.91958531801 -15858 -263712.0 -15601.0 158740.17500000002 -6432.0 -41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.962 A1qy8CWr78 15601.0 -11.0 -386315686 15601 -108241.99663771364 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.234 A4g0u43t1BLI4h 15601.0 36.0 873370057 15601 244710.01877276547 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.158 ABOL5huJ5V40JR7Xy5Jh0 15601.0 45.0 -195941743 15601 -54901.02073409919 -15858 -289440.0 -15601.0 158740.17500000002 -6432.0 -45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.343 ABv6FN1qbww204XIw3Pk32nF 15601.0 -34.0 -1177680836 15601 -329975.0170916223 -15858 218688.0 -15601.0 158740.17500000002 -6432.0 34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.983 AIb8nmLQ0Jg4t3gUu75vJeyH 15601.0 -59.0 -2021724111 15601 -566467.9492855142 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.79 AXc2FKJEWhLfD253aoO1 15601.0 -24.0 -278405900 15601 -78006.69655365648 -15858 154368.0 -15601.0 158740.17500000002 -6432.0 24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.055 AaqE4i62EBu0EEc0j 15601.0 7.0 68454489 15601 19180.299523676098 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.914 Af3LT15L8Onw 15601.0 14.0 -1555938533 15601 -435959.2415242365 -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.999 Alqjt 15601.0 20.0 -1972968987 15601 -552807.2252731858 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.834 AoaeP78qMN6Owq7 15601.0 38.0 951445775 15601 266586.0955449706 -15858 -244416.0 -15601.0 158740.17500000002 -6432.0 -38.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.541 AofL0r45t 15601.0 -12.0 308271363 15601 86374.71644718408 -15858 77184.0 -15601.0 158740.17500000002 -6432.0 12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.038 ApHibcqSn8Oo335QmfLfWnYF 15601.0 8.0 -590921449 15601 -165570.59372373213 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.062 B0L388T3mhPaRCS 15601.0 -58.0 808219026 15601 226455.31689548894 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.07 B204fmP5Do5b 15601.0 -9.0 1788323480 15601 501071.3028859625 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.816 B3sM2VnR 15601.0 15.0 1860728286 15601 521358.44382179884 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.134 B4bPyjY 15601.0 -48.0 -803222928 15601 -225055.45755113478 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.688 B561GDW 15601.0 6.0 273663235 15601 76677.84673578033 -15858 -38592.0 -15601.0 158740.17500000002 -6432.0 -6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.845 B5E1TD86mgjtAtB4 15601.0 -57.0 -1698345590 15601 -475860.350238162 -15858 366624.0 -15601.0 158740.17500000002 -6432.0 57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.51 B5RW2g5yog 15601.0 62.0 1815385311 15601 508653.7716447184 -15858 -398784.0 -15601.0 158740.17500000002 -6432.0 -62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.54 BBP8rjueJ6qT2UgiU51yh 15601.0 20.0 -2050820665 15601 -574620.5281591482 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.858 BClgHeB 15601.0 -55.0 357043363 15601 100040.16895488932 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.408 BEjDfR852Hc1MF836c 15601.0 28.0 1527899325 15601 428102.92098627065 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.331 BLO5XwB7 15601.0 12.0 1941610780 15601 544020.9526478006 -15858 -77184.0 -15601.0 158740.17500000002 -6432.0 -12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.84 BR5F00 15601.0 45.0 1903410305 15601 533317.5413281032 -15858 -289440.0 -15601.0 158740.17500000002 -6432.0 -45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.949 BRG7Sv5qr1v0twTX22 15601.0 51.0 -2103985381 15601 -589516.7780891006 -15858 -328032.0 -15601.0 158740.17500000002 -6432.0 -51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.988 BTHM1wQ6nmd7i4D62 15601.0 17.0 -784264135 15601 -219743.38330064443 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.964 BeKTyMrM8FWn6ewb 15601.0 -36.0 -1804756106 15601 -505675.56906696555 -15858 231552.0 -15601.0 158740.17500000002 -6432.0 36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.92 ByMim67Bdl5Kq5NSjW17G3 15601.0 -22.0 623049731 15601 174572.6340711684 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.483 C0M1vBmsgknoehCiG7 15601.0 -48.0 -1228417392 15601 -344190.919585318 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.293 C53Tn5 15601.0 -31.0 -2030835158 15601 -569020.7783692911 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.672 CJgR7y5fJt25q1 15601.0 18.0 -2044770406 15601 -572925.3028859624 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.627 CQCJ6h0swWhp4 15601.0 -49.0 -230127703 15601 -64479.602970019616 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.714 Cb4HG6630oxk51h5F3W 15601.0 -19.0 -899534452 15601 -252041.03446343515 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.275 Ci5SHf 15601.0 -12.0 642606685 15601 180052.30736901093 -15858 77184.0 -15601.0 158740.17500000002 -6432.0 12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.088 Cl82a 15601.0 -12.0 1553995372 15601 435414.7862146259 -15858 77184.0 -15601.0 158740.17500000002 -6432.0 12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.596 Crds83KvG3egbK 15601.0 -30.0 722336779 15601 202391.92462874754 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.672 CvUplJQ5P60W8 15601.0 2.0 1921019802 15601 538251.5556178201 -15858 -12864.0 -15601.0 158740.17500000002 -6432.0 -2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.197 D0EmwVYsS1R 15601.0 11.0 -1474284078 15601 -413080.43653684505 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.344 D26B67MOpPcteG70IOsMqH 15601.0 -5.0 -13357585 15601 -3742.66881479406 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.924 D8K4E6MSC6E1d7UlX7yS6o2 15601.0 58.0 300682807 15601 84248.4749229476 -15858 -373056.0 -15601.0 158740.17500000002 -6432.0 -58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.142 DANHO0P7GlF6WFPQkFF8 15601.0 79.553 -1823591768 15601 -510953.1431773606 -15858 -511684.9 -15601.0 158740.17500000002 -6432.0 -79.553 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.259 DBTgG3H 15601.0 46.0 1056441941 15601 296005.02689829085 -15858 -295872.0 -15601.0 158740.17500000002 -6432.0 -46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.074 DJq0Lol1I 15601.0 19.0 1089687789 15601 305320.19865508546 -15858 -122208.0 -15601.0 158740.17500000002 -6432.0 -19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.419 DUE3Y1g4jLp345K 15601.0 60.0 -1141582332 15601 -319860.5581395349 -15858 -385920.0 -15601.0 158740.17500000002 -6432.0 -60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.809 DWHPiSxW7ON5vyCNmn 15601.0 -8.0 -2028170063 15601 -568274.0439899132 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.311 Db7CaO 15601.0 43.0 2113671499 15601 592230.7366209022 -15858 -276576.0 -15601.0 158740.17500000002 -6432.0 -43.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.254 Dk66H 15601.0 4.0 1533958255 15601 429800.5757915382 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.994 Dncfdm0107vK5Bmwppr1H 15601.0 -15.0 -937270420 15601 -262614.29532081814 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.365 DpXKnXx54Ped8cJeCJL 15601.0 39.0 1210224988 15601 339093.58027458674 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.402 DsLt4LdED7Q7 15601.0 -26.0 -257298466 15601 -72092.59344354161 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.117 E100F0lsE520GtpXYIu 15601.0 -26.0 -404509269 15601 -113339.6662930793 -15858 167232.0 -15601.0 158740.17500000002 -6432.0 26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.413 E2Kbx50LJ7amwF 15601.0 -61.0 -1022679553 15601 -286545.12552535726 -15858 392352.0 -15601.0 158740.17500000002 -6432.0 61.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.254 E865b 15601.0 57.0 761877407 15601 213470.8341272065 -15858 -366624.0 -15601.0 158740.17500000002 -6432.0 -57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.233 EPi08Ihi40O 15601.0 -34.0 113880409 15601 31908.212104230875 -15858 218688.0 -15601.0 158740.17500000002 -6432.0 34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.035 ERwT6401a164 15601.0 12.0 1295172704 15601 362895.12580554775 -15858 -77184.0 -15601.0 158740.17500000002 -6432.0 -12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.989 ETN236368gQub756Dmfp5181 15601.0 -6.0 -1610058211 15601 -451123.0627626786 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.925 EUfLkLQ 15601.0 -10.0 -1086197521 15601 -304342.2586158588 -15858 64320.0 -15601.0 158740.17500000002 -6432.0 10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.279 EcpSw7QRSrw40ueJm 15601.0 -44.0 30909765 15601 8660.623423928271 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:43.705 Ek2sC17CCXFw1Fdq1c3N7o1 15601.0 -12.0 595414579 15601 166829.52619781453 -15858 77184.0 -15601.0 158740.17500000002 -6432.0 12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.256 EmIssCRj 15601.0 21.0 68208550 15601 19111.38974502662 -15858 -135072.0 -15601.0 158740.17500000002 -6432.0 -21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.565 En0gIyb3UWw7Bg5Cs 15601.0 40.0 946637795 15601 265238.9450826562 -15858 -257280.0 -15601.0 158740.17500000002 -6432.0 -40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.305 EpY8iI4vm3q3d3x0862L3 15601.0 32.0 839217757 15601 235140.86775007006 -15858 -205824.0 -15601.0 158740.17500000002 -6432.0 -32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.391 Etkti70 15601.0 -37.0 -1474993355 15601 -413279.16923507984 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.689 ExDDp5f2lgt8O7VUcf12q81T 15601.0 18.0 1105763794 15601 309824.5430092463 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.159 F06d7U0vinY 15601.0 -50.0 1445828009 15601 405107.3154945363 -15858 321600.0 -15601.0 158740.17500000002 -6432.0 50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.485 F0FeMN5eraBSeNo 15601.0 15.0 -1186641445 15601 -332485.6948725133 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.816 F1D04R4cY5JQbX3M4l6 15601.0 7.0 -1487527155 15601 -416791.02129448025 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.233 F1p7M8ag2lHT1No88g564W0 15601.0 24.0 184592771 15601 51721.14625945643 -15858 -154368.0 -15601.0 158740.17500000002 -6432.0 -24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.547 F214U41bv 15601.0 26.0 -692950740 15601 -194158.23479966377 -15858 -167232.0 -15601.0 158740.17500000002 -6432.0 -26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.111 F68eh 15601.0 6.0 1274836009 15601 357196.9764639955 -15858 -38592.0 -15601.0 158740.17500000002 -6432.0 -6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.038 F7A5XKmXGD 15601.0 -14.0 -946632342 15601 -265237.41720369854 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.875 FAYy2rCtAk6p6LyMS7S3M 15601.0 45.0 29687887 15601 8318.264780050435 -15858 -289440.0 -15601.0 158740.17500000002 -6432.0 -45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.711 FEfERlrjMF6a37teo6RpLM 15601.0 21.0 1849599424 15601 518240.24208461755 -15858 -135072.0 -15601.0 158740.17500000002 -6432.0 -21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.12 FGD08uu4La5qPEl 15601.0 49.0 1419034476 15601 397600.02129448025 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.145 FH3xC0m38Hp 15601.0 -29.0 -1355363882 15601 -379760.1238442141 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.75 FIB30nWy1482081ypBNk75 15601.0 -22.0 -116661992 15601 -32687.585318016252 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.176 FbU0U126PPV4V80C 15601.0 -53.0 1164180530 15601 326192.3592042589 -15858 340896.0 -15601.0 158740.17500000002 -6432.0 53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.875 FmeinD4GMhc3dR 15601.0 30.0 -941937506 15601 -263921.9686186607 -15858 -192960.0 -15601.0 158740.17500000002 -6432.0 -30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.173 Fo0lvObXB13uFiJ538N1I7EI 15601.0 49.0 172978219 15601 48466.858783973104 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.405 Ftd0f531WF17cjTI2O 15601.0 -61.0 1139675920 15601 319326.39955169515 -15858 392352.0 -15601.0 158740.17500000002 -6432.0 61.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.119 Fwf6Sac6mM2Q5tj38H 15601.0 4.0 -293394791 15601 -82206.44186046511 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.925 G2eTbpXOf 15601.0 -46.0 -468932050 15601 -131390.3194172037 -15858 295872.0 -15601.0 158740.17500000002 -6432.0 46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.034 G70732cedJMM0TMdTnO2 15601.0 5.0 -1405201067 15601 -393724.0311011488 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.391 G8YI4g61V5l0 15601.0 -45.0 -831227593 15601 -232902.099467638 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.719 GA848dL72B2dOUfpVmG77J3F 15601.0 39.0 581431028 15601 162911.46763799383 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.066 GG48LXS1XF8 15601.0 -36.0 796380856 15601 223138.37377416642 -15858 231552.0 -15601.0 158740.17500000002 -6432.0 36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.228 GGc5G7 15601.0 3.0 -662740282 15601 -185693.5505743906 -15858 -19296.0 -15601.0 158740.17500000002 -6432.0 -3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.083 GLUkX0100q 15601.0 -31.0 -198456342 15601 -55605.58755954049 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.555 GT18w 15601.0 6.0 -940198586 15601 -263434.739702998 -15858 -38592.0 -15601.0 158740.17500000002 -6432.0 -6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.258 GWyjg3VFq1 15601.0 -25.0 988888 15601 277.07705239562904 -15858 160800.0 -15601.0 158740.17500000002 -6432.0 25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.223 Gi2GkC27Si2F2HcPpxl30H 15601.0 53.0 613322929 15601 171847.27626786215 -15858 -340896.0 -15601.0 158740.17500000002 -6432.0 -53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.76 Gk6NYea0882752C 15601.0 17.0 -191560572 15601 -53673.45811151583 -15858 -109344.0 -15601.0 158740.17500000002 -6432.0 -17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.259 GkRP5Gp6K6SFm5O21tX1U3 15601.0 -46.0 271210320 15601 75990.56318296441 -15858 295872.0 -15601.0 158740.17500000002 -6432.0 46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.96 GlQD5lVNjayU21uPxj7x6 15601.0 -49.0 -197652849 15601 -55380.45643037265 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.044 Gs7PDk 15601.0 11.0 1518898051 15601 425580.8492574951 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.893 Gv7dDwR 15601.0 -45.0 56009543 15601 15693.343513589241 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.785 H2W5UNJvOk4884lt0u2K 15601.0 -14.0 984832395 15601 275940.71028299246 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.92 H660yyHFbeUy864u1nS1 15601.0 -27.0 711356569 15601 199315.37377416642 -15858 173664.0 -15601.0 158740.17500000002 -6432.0 27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.931 H6EQ3Y5tY82S5U1 15601.0 14.0 -1358164329 15601 -380544.78257214907 -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.553 H85Or4yRdt4A1 15601.0 -42.0 1285310382 15601 360131.79658167553 -15858 270144.0 -15601.0 158740.17500000002 -6432.0 42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.528 HC8S2Tyv8RF 15601.0 -17.0 1158473216 15601 324593.2238722331 -15858 109344.0 -15601.0 158740.17500000002 -6432.0 17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.575 HCje0r5N3C0o3 15601.0 39.0 186460538 15601 52244.476884281314 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.722 HCr4b46Dx6aSa0Q7CRp3 15601.0 -53.0 879759030 15601 246500.14850098066 -15858 340896.0 -15601.0 158740.17500000002 -6432.0 53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.561 HJTchT5CPC84 15601.0 -29.0 -427240643 15601 -119708.78201176801 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.593 HN57u11H8 15601.0 -13.0 2061177369 15601 577522.3785374054 -15858 83616.0 -15601.0 158740.17500000002 -6432.0 13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.096 HUKr4vWS 15601.0 28.0 1781483364 15601 499154.7671616699 -15858 -180096.0 -15601.0 158740.17500000002 -6432.0 -28.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.712 HX4NNXplV2R7G35xp 15601.0 37.0 980331206 15601 274679.5197534323 -15858 -237984.0 -15601.0 158740.17500000002 -6432.0 -37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.9 HcoJtE70sS7KuFuuW 15601.0 20.0 -368721894 15601 -103312.38274026338 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.08 HghnGE5gflqVwR76sX18 15601.0 48.0 1766992295 15601 495094.506864668 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.375 HmC2gaY 15601.0 -49.0 -57200424 15601 -16027.017091622303 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.161 Hs4v5FHpNs4 15601.0 -20.0 -1569241661 15601 -439686.6520033623 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.213 Hu8U10iq3 15601.0 1.0 -1972121622 15601 -552569.8016251051 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.328 Hv27a0qU14MJB7 15601.0 -37.0 -1274229243 15601 -357026.9663771365 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.189 HyD5X4wA0G4Ir6Wq6gM5H 15601.0 -16.0 290481712 15601 81390.2247128047 -15858 102912.0 -15601.0 158740.17500000002 -6432.0 16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.83 I086Kg80pX 15601.0 -19.0 -1575589254 15601 -441465.18744746427 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.396 I0S8mgt10Gm 15601.0 -61.0 1114673625 15601 312320.9932754273 -15858 392352.0 -15601.0 158740.17500000002 -6432.0 61.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.434 I7MI02kTvL36N 15601.0 -3.0 -1714949058 15601 -480512.48472961615 -15858 19296.0 -15601.0 158740.17500000002 -6432.0 3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:31.808 IAFkV5cK0Jh10Im806u 15601.0 20.0 1638071199 15601 458972.03670495935 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.476 IAnfq 15601.0 44.0 -2098300466 15601 -587923.9187447465 -15858 -283008.0 -15601.0 158740.17500000002 -6432.0 -44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.025 ICK66G8e8 15601.0 0.0 -901264012 15601 -252525.6407957411 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.965 IDPh0xt5aj4nhjfgvB6O6X3 15601.0 2.0 -664588420 15601 -186211.38133931073 -15858 -12864.0 -15601.0 158740.17500000002 -6432.0 -2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.733 IJRqL2Ec6JGceMcn6bUyuRU8 15601.0 -17.0 -1275985495 15601 -357519.05155505746 -15858 109344.0 -15601.0 158740.17500000002 -6432.0 17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.215 IMC05lv4PYLJb2n3r7T 15601.0 55.0 1582500035 15601 443401.5228355282 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.331 ISSP0gjn3qxAC7gH3l11N6 15601.0 8.0 183549371 15601 51428.79546091342 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.778 IYlXj3xg 15601.0 20.0 505524678 15601 141643.22723451947 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.699 Ib62k3A2XLg2TL 15601.0 -29.0 -2143024405 15601 -600455.14289717 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.19 IpDn22 15601.0 -19.0 -1322538563 15601 -370562.78033062484 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.195 Is5DY4nt6n85p8 15601.0 -11.0 -655443218 15601 -183648.98234799664 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.022 IvE07gK77 15601.0 -20.0 -1293754251 15601 -362497.68870832166 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.754 J0I71XNHjvS8 15601.0 -3.0 -2076312756 15601 -581763.1706360325 -15858 19296.0 -15601.0 158740.17500000002 -6432.0 3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.762 J4Fr2Ysig4v1h1y4Yg0QF8w8 15601.0 23.0 1499121057 15601 420039.5228355282 -15858 -147936.0 -15601.0 158740.17500000002 -6432.0 -23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.469 J73U1aQTRUd 15601.0 -6.0 -573372032 15601 -160653.4132810311 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.09 JE6y6UBN33n8Kcs 15601.0 -60.0 -2041965187 15601 -572139.3070888204 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.631 JEVyBv2IqG1xPJASdCL8 15601.0 33.0 739625813 15601 207236.14822079014 -15858 -212256.0 -15601.0 158740.17500000002 -6432.0 -33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.324 JFRQYgF2d57MV 15601.0 49.0 -128270777 15601 -35940.25693471561 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.014 JGPmC0e7g1h87 15601.0 -52.0 -886068046 15601 -248267.8750350238 -15858 334464.0 -15601.0 158740.17500000002 -6432.0 52.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.952 JN1cd 15601.0 14.0 -1426659283 15601 -399736.4200056038 -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.902 JO2608Lv74HyA 15601.0 -21.0 441754322 15601 123775.37741664331 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.741 JeNoQM2514UXI306K8SbN 15601.0 -2.0 624304190 15601 174924.12160268982 -15858 12864.0 -15601.0 158740.17500000002 -6432.0 2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.295 Jf3TV3LhLih 15601.0 45.0 -223953421 15601 -62749.62762678621 -15858 -289440.0 -15601.0 158740.17500000002 -6432.0 -45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.057 JfvDur75VQCb53GicM7hHU 15601.0 3.0 -1580362265 15601 -442802.5399271505 -15858 -19296.0 -15601.0 158740.17500000002 -6432.0 -3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.326 JqulbtcrXcNBymoHD0uDu 15601.0 2.0 496222742 15601 139036.9128607453 -15858 -12864.0 -15601.0 158740.17500000002 -6432.0 -2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.556 Jto1Ej2BS 15601.0 53.0 1556590849 15601 436142.014289717 -15858 -340896.0 -15601.0 158740.17500000002 -6432.0 -53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.383 K3DGd0 15601.0 41.0 -1730738390 15601 -484936.5060240964 -15858 -263712.0 -15601.0 158740.17500000002 -6432.0 -41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.979 K3d77AuD2 15601.0 -37.0 943423950 15601 264338.4561501821 -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.114 KO3lYMSBj 15601.0 15.0 -1106735397 15601 -310096.77696833847 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.564 KV5evP72y5O6w7j 15601.0 -19.0 -1040575969 15601 -291559.5318016251 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.914 KX43450qk3ifahho2 15601.0 -19.0 853662696 15601 239188.2028579434 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.84 KXy5w41XCCA8oA 15601.0 12.0 -1331125878 15601 -372968.86466797424 -15858 -77184.0 -15601.0 158740.17500000002 -6432.0 -12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.189 Keq6tT2y4kB7 15601.0 14.0 -1970072997 15601 -551995.796301485 -15858 -90048.0 -15601.0 158740.17500000002 -6432.0 -14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.433 Kp7FRaBtqU8i2U1 15601.0 53.0 -1231026402 15601 -344921.9394788456 -15858 -340896.0 -15601.0 158740.17500000002 -6432.0 -53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.579 Kt5AoC5 15601.0 1.0 -208178544 15601 -58329.65648641076 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.284 L1pn2rBecf3v4mOe 15601.0 -50.0 547762198 15601 153477.78033062484 -15858 321600.0 -15601.0 158740.17500000002 -6432.0 50.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.418 L2WL0K8Q3077Q7lHWxq3 15601.0 21.0 -893636289 15601 -250388.42504903334 -15858 -135072.0 -15601.0 158740.17500000002 -6432.0 -21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.918 LGM2rR 15601.0 -5.0 286911598 15601 80389.91258055478 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.07 LLeNMJ3ml 15601.0 44.0 -780348314 15601 -218646.20734099188 -15858 -283008.0 -15601.0 158740.17500000002 -6432.0 -44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.965 LW12Cn18Fa3jK0 15601.0 1.0 1365515285 15601 382604.45082656207 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.771 Lc62N872p2Qx048D8x 15601.0 36.0 503569096 15601 141095.29167834128 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.805 Ljca2gTfVlP3iiRV4Ue 15601.0 55.0 1386764124 15601 388558.1742785094 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.104 Lm4jGS6uC6m0buRvp63 15601.0 34.0 -1028809597 15601 -288262.70579994394 -15858 -218688.0 -15601.0 158740.17500000002 -6432.0 -34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.044 Lptx5Gx2Mw5PLl4hSL6T67F 15601.0 35.0 NULL 15601 NULL -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.812 LrcpM 15601.0 35.0 -1198622822 15601 -335842.7632390025 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.903 LxdPDb 15601.0 -25.0 907202969 15601 254189.68030260576 -15858 160800.0 -15601.0 158740.17500000002 -6432.0 25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:43.771 M40e006lkM2L 15601.0 49.0 -1107321329 15601 -310260.9495657047 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.515 MD1CaRLo1Q1yu8633IB 15601.0 -11.0 1417503370 15601 397171.0198935276 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.437 MHUrF1wtS4FCMIT6aP5 15601.0 18.0 1102736886 15601 308976.4320537966 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.302 MKVQYGxtltIv4QN 15601.0 -24.0 146845669 15601 41144.76576071729 -15858 154368.0 -15601.0 158740.17500000002 -6432.0 24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.069 MO74jra6B1534xeWwCNp0k5 15601.0 -62.0 68899019 15601 19304.85261978145 -15858 398784.0 -15601.0 158740.17500000002 -6432.0 62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.881 MOrNN2vu2e 15601.0 -40.0 561535341 15601 157336.88456150182 -15858 257280.0 -15601.0 158740.17500000002 -6432.0 40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.199 Ma0cUc3gxu236hG 15601.0 -25.0 -414129290 15601 -116035.10507144859 -15858 160800.0 -15601.0 158740.17500000002 -6432.0 25.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.766 Mfyi8GP6X7lQ28o3l 15601.0 15.0 -1540302337 15601 -431578.12748669094 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.748 Mg8NV0cpt7B80 15601.0 -14.0 -466156812 15601 -130612.72401232838 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.71 MhnIfCXt3OD 15601.0 -23.0 -1046520269 15601 -293225.0683664892 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.306 MnGh7cJ8Tqfj5SM3i643 15601.0 -49.0 2025282930 15601 567465.0966657327 -15858 315168.0 -15601.0 158740.17500000002 -6432.0 49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.687 Mpl1s7so8 15601.0 20.0 -1195710741 15601 -335026.8257214906 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.372 Ms3HD0o 15601.0 -9.0 108834881 15601 30494.50294200056 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.331 N6s6Ya7n38uF3 15601.0 4.0 -1096047343 15601 -307102.08545811154 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.617 N887uW7KRb6LMp 15601.0 -31.0 1521898163 15601 426421.4522275147 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.15 NKt630 15601.0 -11.0 -1133138233 15601 -317494.601569067 -15858 70752.0 -15601.0 158740.17500000002 -6432.0 11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.838 NP22kVaQGeaH604 15601.0 15.0 -1675398355 15601 -469430.75231157185 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.847 NaTC1s58bEK 15601.0 -9.0 NULL 15601 NULL -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.101 Ner2VnJw3kK6StMYD 15601.0 -39.0 -1651489748 15601 -462731.7870551975 -15858 250848.0 -15601.0 158740.17500000002 -6432.0 39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.558 NmR21ryn0FG67 15601.0 -24.0 -1496666324 15601 -419351.7298963295 -15858 154368.0 -15601.0 158740.17500000002 -6432.0 24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.064 NrCRG0ol8t3w116fK2 15601.0 18.0 NULL 15601 NULL -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.697 O2387e47vBg 15601.0 -1.0 -789881959 15601 -221317.44438217988 -15858 6432.0 -15601.0 158740.17500000002 -6432.0 1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:52.595 O30yrAd1e8dgm5 15601.0 62.0 -1838132825 15601 -515027.4096385542 -15858 -398784.0 -15601.0 158740.17500000002 -6432.0 -62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.882 O77TCNDlf8w 15601.0 -31.0 -46453649 15601 -13015.87251330905 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.255 OI5Fo 15601.0 -58.0 -1560616588 15601 -437269.98823199776 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.061 OX3YD1C1JMmS52Y 15601.0 5.0 -1668687246 15601 -467550.3631269263 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.345 ObGm1w 15601.0 -37.0 NULL 15601 NULL -15858 237984.0 -15601.0 158740.17500000002 -6432.0 37.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.612 Oc6P2F1UD0D0T0haR 15601.0 21.0 1312374660 15601 367714.9509666573 -15858 -135072.0 -15601.0 158740.17500000002 -6432.0 -21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.186 OgJ3DltBHB87rMQt2d 15601.0 -9.0 -911417577 15601 -255370.573550014 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.05 OgJuBiLW71S 15601.0 59.0 1129363554 15601 316436.97226113756 -15858 -379488.0 -15601.0 158740.17500000002 -6432.0 -59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.805 OqeL462twjC0O34y086scWbW 15601.0 -46.0 157777107 15601 44207.651162790695 -15858 295872.0 -15601.0 158740.17500000002 -6432.0 46.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.281 OtS4TXC3o8opoEsRtv5Sj 15601.0 8.0 2060956712 15601 577460.5525357242 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.14 OtgfTpqxm51v6Y 15601.0 -29.0 -393066261 15601 -110133.44382179882 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.996 P66k5ETLyP41K5o5gAT 15601.0 -22.0 NULL 15601 NULL -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:43.931 PEBBi 15601.0 42.0 509177858 15601 142666.81367329785 -15858 -270144.0 -15601.0 158740.17500000002 -6432.0 -42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.18 PFiGGCalsC 15601.0 -5.0 -1029272743 15601 -288392.4749229476 -15858 32160.0 -15601.0 158740.17500000002 -6432.0 5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.912 PIKnd8tj154 15601.0 -45.0 1619226365 15601 453691.89268702717 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:16.338 PJoW4 15601.0 -3.0 504525087 15601 141363.15130288596 -15858 19296.0 -15601.0 158740.17500000002 -6432.0 3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.21 PK01P7dDg2f8IAPjo662y072 15601.0 58.0 -1384901601 15601 -388036.3129728215 -15858 -373056.0 -15601.0 158740.17500000002 -6432.0 -58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.953 PN27a314v6PyUpVfeiU 15601.0 18.0 -973905398 15601 -272879.0692070608 -15858 -115776.0 -15601.0 158740.17500000002 -6432.0 -18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.438 PN71Bl6jM 15601.0 -41.0 -1064437283 15601 -298245.24600728496 -15858 263712.0 -15601.0 158740.17500000002 -6432.0 41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.49 PQyN2mruXRR47dPEkesk 15601.0 5.0 -507162101 15601 -142102.01765200336 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.767 PS4fs5g7Itj843qvX 15601.0 56.0 -1378117091 15601 -386135.3575231157 -15858 -360192.0 -15601.0 158740.17500000002 -6432.0 -56.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.953 PY216BgK57qkoktjrjHb 15601.0 -48.0 1198344254 15601 335764.71112356405 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.695 PxcCoxYeQ5M 15601.0 -34.0 1218760785 15601 341485.2297562342 -15858 218688.0 -15601.0 158740.17500000002 -6432.0 34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.741 PyGaf 15601.0 -16.0 -1505978287 15601 -421960.8537405436 -15858 102912.0 -15601.0 158740.17500000002 -6432.0 16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.789 Q08uv20m 15601.0 39.0 -1046301933 15601 -293163.89268702717 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.986 Q1T7u0syw2NPveOu 15601.0 -18.0 -1185085807 15601 -332049.8198374895 -15858 115776.0 -15601.0 158740.17500000002 -6432.0 18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.38 Q30600R1 15601.0 53.0 -1283930255 15601 -359745.0980666854 -15858 -340896.0 -15601.0 158740.17500000002 -6432.0 -53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.559 Q37LCWVlT8TkMm2f3h7j0d 15601.0 -34.0 1476533372 15601 413710.6674138414 -15858 218688.0 -15601.0 158740.17500000002 -6432.0 34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.961 Q3mmj6mG4EG8H 15601.0 10.0 -720023732 15601 -201743.83076492016 -15858 -64320.0 -15601.0 158740.17500000002 -6432.0 -10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.617 Q4yNJBnb 15601.0 -10.0 1710641158 15601 479305.45194732415 -15858 64320.0 -15601.0 158740.17500000002 -6432.0 10.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.42 Q6v087IOF2 15601.0 -9.0 192161117 15601 53841.7251330905 -15858 57888.0 -15601.0 158740.17500000002 -6432.0 9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.315 Q76PX622TlrNxcGCf5p507o8 15601.0 -22.0 1270307708 15601 355928.189408798 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.453 QCY0pTKdHRqrf5P1N58 15601.0 4.0 -1677882999 15601 -470126.9260297002 -15858 -25728.0 -15601.0 158740.17500000002 -6432.0 -4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.681 QFHk87n5xsCYI226 15601.0 53.0 -782857402 15601 -219349.23003642476 -15858 -340896.0 -15601.0 158740.17500000002 -6432.0 -53.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.415 QLA5Le5ePE53UgM7km6 15601.0 51.0 -232545302 15601 -65156.99131409358 -15858 -328032.0 -15601.0 158740.17500000002 -6432.0 -51.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.808 QV08okL83Ug1jwOV8h74 15601.0 54.0 493058527 15601 138150.3297842533 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.754 QWSToWHfYl4rAJcLMwO 15601.0 54.0 1825424393 15601 511466.6273465957 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.067 Qq1cBHJkF7A3y3v5crIN0fJ 15601.0 -33.0 -1583014792 15601 -443545.75287195295 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.435 Qq2Jy5Iy15LsnaWwI 15601.0 -55.0 1958873163 15601 548857.7088820398 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.832 QrFWcQo7 15601.0 -27.0 -1152127938 15601 -322815.33706920705 -15858 173664.0 -15601.0 158740.17500000002 -6432.0 27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.603 R4WtD3 15601.0 -54.0 -1754189160 15601 -491507.1896889885 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.587 R68avA7MskCgYOOEP 15601.0 -44.0 1448245990 15601 405784.81087139255 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.331 R8IJh6386ba3D3VS70FSlw6 15601.0 -52.0 440096608 15601 123310.90165312412 -15858 334464.0 -15601.0 158740.17500000002 -6432.0 52.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.054 RFm8XplgEW3ep0R 15601.0 48.0 -505179873 15601 -141546.6161389745 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.579 RO83j2qQsq7 15601.0 1.0 345752927 15601 96876.6957130849 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.727 ROWD7iWDvXjq3RU60LfIm 15601.0 27.0 391612768 15601 109726.18884841692 -15858 -173664.0 -15601.0 158740.17500000002 -6432.0 -27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.368 RV01bFdAim2mhn0is3SuP 15601.0 20.0 -1644694994 15601 -460827.9613337069 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.246 RWDJpR813I70rA48j3St8 15601.0 -8.0 667749103 15601 187096.97478285234 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.232 Rf45Knu04s4160Ic0TDdw 15601.0 -59.0 1781893821 15601 499269.7733258616 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.863 RjYdeaB 15601.0 11.0 -1656847358 15601 -464232.93863827403 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.134 Rkjxcgk8n8m2B3jrKY1PbS3 15601.0 -24.0 -402193022 15601 -112690.6758195573 -15858 154368.0 -15601.0 158740.17500000002 -6432.0 24.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.584 RrQO5beX488KbcA6g4Jnu5 15601.0 -29.0 -1912094416 15601 -535750.7469879518 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.061 S1gQ06M353rQ5vm2a24EMN 15601.0 -19.0 -643533009 15601 -180311.85458111516 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.238 S25uia48N4 15601.0 39.0 -1351910626 15601 -378792.5542168675 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.336 S731TWfDrNnVe8p2yuE1k 15601.0 -4.0 956522842 15601 268008.6416363127 -15858 25728.0 -15601.0 158740.17500000002 -6432.0 4.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.747 SD7DWsK 15601.0 54.0 -1479988050 15601 -414678.63547212107 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.26 SJ8F14f7LlNlWpBJ 15601.0 15.0 NULL 15601 NULL -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.754 SJf447 15601.0 20.0 1129495890 15601 316474.05155505746 -15858 -128640.0 -15601.0 158740.17500000002 -6432.0 -20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.043 STrL4f3N1wj 15601.0 -60.0 -5953872 15601 -1668.2185486130568 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.058 Sfe4pA7B3f5x 15601.0 -15.0 419609353 15601 117570.5668254413 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.132 ShjbW3q38Px24Hx 15601.0 -22.0 -1803981239 15601 -505458.4586718969 -15858 141504.0 -15601.0 158740.17500000002 -6432.0 22.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.822 SjG26TSvqw3myt 15601.0 0.0 -39854776 15601 -11166.930792939198 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.18 SpJMvUVUfHrf1A723s10EdC 15601.0 47.0 -1230441185 15601 -344757.96721770806 -15858 -302304.0 -15601.0 158740.17500000002 -6432.0 -47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.051 Sr02RjVo6gEbKjr4Ftm0d 15601.0 35.0 -605058422 15601 -169531.639674979 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.284 SvKL2lM7lc 15601.0 -26.28 808737125 15601 226600.48332866348 -15858 169032.97 -15601.0 158740.17500000002 -6432.0 26.28 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.345 SwEtmG886dSmCVYqhnvUm 15601.0 -48.0 2080590537 15601 582961.7643597646 -15858 308736.0 -15601.0 158740.17500000002 -6432.0 48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.195 Syoe8Gm2 15601.0 -55.0 2020504394 15601 566126.1961333707 -15858 353760.0 -15601.0 158740.17500000002 -6432.0 55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.401 T3KP6V 15601.0 -59.0 -1315413812 15601 -368566.492574951 -15858 379488.0 -15601.0 158740.17500000002 -6432.0 59.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.071 T45sp 15601.0 -18.0 1800301969 15601 504427.5620622023 -15858 115776.0 -15601.0 158740.17500000002 -6432.0 18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.108 T5W42P5q3uxBgYya8Et085C 15601.0 9.0 -2093472028 15601 -586571.0361445784 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.884 T7R4Jnl7s3d053wmyOrt 15601.0 -40.0 375928903 15601 105331.71840851779 -15858 257280.0 -15601.0 158740.17500000002 -6432.0 40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.06 T7YaUc10ta 15601.0 55.0 -1224290649 15601 -343034.64527878957 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.451 TEM55fi2Ly 15601.0 -57.0 -585350546 15601 -164009.6794620342 -15858 366624.0 -15601.0 158740.17500000002 -6432.0 57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.705 TGfOwisk27yqU43c4NdpO 15601.0 -14.0 1892527183 15601 530268.193611656 -15858 90048.0 -15601.0 158740.17500000002 -6432.0 14.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.004 TN1V103235ex7r5y1UnD 15601.0 12.0 1028143712 15601 288076.13112916786 -15858 -77184.0 -15601.0 158740.17500000002 -6432.0 -12.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.88 TNE8eY3 15601.0 -42.0 1987471865 15601 556870.7943401512 -15858 270144.0 -15601.0 158740.17500000002 -6432.0 42.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.868 TTC6F8qbjDrUwqlWQ674T 15601.0 -56.0 -971846497 15601 -272302.184645559 -15858 360192.0 -15601.0 158740.17500000002 -6432.0 56.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.945 TXaLgi3L562jI1 15601.0 54.0 -1735553309 15601 -486285.6007284954 -15858 -347328.0 -15601.0 158740.17500000002 -6432.0 -54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.716 Tcvj5uSM1NCQUr 15601.0 1.0 -1025788056 15601 -287416.0986270664 -15858 -6432.0 -15601.0 158740.17500000002 -6432.0 -1.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:08.445 TwtBSyUgu7uOpsQ 15601.0 48.0 846324964 15601 237132.2398430933 -15858 -308736.0 -15601.0 158740.17500000002 -6432.0 -48.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.396 U2MJbm 15601.0 -20.0 823972698 15601 230869.34659568506 -15858 128640.0 -15601.0 158740.17500000002 -6432.0 20.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.732 U62U7O2LVYg 15601.0 21.0 1837742836 15601 514918.1384141216 -15858 -135072.0 -15601.0 158740.17500000002 -6432.0 -21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:47.57 U75G6OsrKmd7KxMe 15601.0 -29.0 -1703837738 15601 -477399.1980947044 -15858 186528.0 -15601.0 158740.17500000002 -6432.0 29.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.054 UG6g10Lb571g 15601.0 -8.0 -1998625094 15601 -559995.8234799664 -15858 51456.0 -15601.0 158740.17500000002 -6432.0 8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.923 UHSnND7vTVfm80W3E3AX5aR 15601.0 -19.0 268499605 15601 75231.04651162791 -15858 122208.0 -15601.0 158740.17500000002 -6432.0 19.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.137 UQR88o20Gf453RP 15601.0 -44.0 -1447719201 15601 -405637.2095825161 -15858 283008.0 -15601.0 158740.17500000002 -6432.0 44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.68 UU01Fkn1Fp2d 15601.0 33.0 2094164536 15601 586765.0703278229 -15858 -212256.0 -15601.0 158740.17500000002 -6432.0 -33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.782 UVo71u40can1RQJ0MTNPS 15601.0 -27.0 37567484 15601 10526.053236200616 -15858 173664.0 -15601.0 158740.17500000002 -6432.0 27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.583 UYC1dkb7n5YcmFAAbT2 15601.0 -31.0 -1357998994 15601 -380498.45727094426 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.357 Ubb7l 15601.0 -13.0 1179505870 15601 330486.3743345475 -15858 83616.0 -15601.0 158740.17500000002 -6432.0 13.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.137 Uw8VcBX726537W7Nc32f5og1 15601.0 -30.0 -1617443296 15601 -453192.29363967496 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.259 V10T8Fo0d5HOeEM8ysObmPU4 15601.0 5.0 -184458103 15601 -51683.413561221634 -15858 -32160.0 -15601.0 158740.17500000002 -6432.0 -5.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.324 V37l2corMwuEU0F2I4R 15601.0 -38.0 -1138820207 15601 -319086.6368730737 -15858 244416.0 -15601.0 158740.17500000002 -6432.0 38.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:06.982 V3L2j5d3q 15601.0 2.0 -400080827 15601 -112098.8587839731 -15858 -12864.0 -15601.0 158740.17500000002 -6432.0 -2.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.627 V3e7tuWVX0gajjH6X8 15601.0 -32.0 -1473796341 15601 -412943.777248529 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.872 V3ySf 15601.0 7.0 1329225687 15601 372436.4491454189 -15858 -45024.0 -15601.0 158740.17500000002 -6432.0 -7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.32 V74j2j3Pc8OY7tl 15601.0 -21.0 -813809028 15601 -228021.58251611097 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.545 VHe5j0T1o21J806LMb8ay1 15601.0 -16.0 2066094917 15601 578900.2289156626 -15858 102912.0 -15601.0 158740.17500000002 -6432.0 16.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:45.008 VNQIHXp5B80I 15601.0 -31.0 2006229754 15601 562126.5771924909 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.18 VT72k7T7C3N73lA10202 15601.0 57.0 -1393938237 15601 -390568.29279910336 -15858 -366624.0 -15601.0 158740.17500000002 -6432.0 -57.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.121 VTDTuUp 15601.0 -6.0 281019305 15601 78738.94788456151 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.948 VXtbOP4eT6x2R05 15601.0 -58.0 2006398616 15601 562173.8907256934 -15858 373056.0 -15601.0 158740.17500000002 -6432.0 58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.422 Vc0uIW6g2n7P8f75JDUG6yN 15601.0 15.0 274226131 15601 76835.5648641076 -15858 -96480.0 -15601.0 158740.17500000002 -6432.0 -15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.998 VftK7455nP4C2fb42Guv7I0 15601.0 -40.0 1194316702 15601 334636.2291958532 -15858 257280.0 -15601.0 158740.17500000002 -6432.0 40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.504 VkLA5W0AsJ2v7X7 15601.0 -60.0 -1743144280 15601 -488412.5189128607 -15858 385920.0 -15601.0 158740.17500000002 -6432.0 60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:12.413 Vt166H6HUcc 15601.0 -32.0 -1864500604 15601 -522415.41159988794 -15858 205824.0 -15601.0 158740.17500000002 -6432.0 32.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.14 W087uQpM6uJ2G5aB 15601.0 3.0 270888813 15601 75900.47996637714 -15858 -19296.0 -15601.0 158740.17500000002 -6432.0 -3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.429 W2i72S68FOFb0F0nq0s64Y 15601.0 -23.0 -287502046 15601 -80555.35051835248 -15858 147936.0 -15601.0 158740.17500000002 -6432.0 23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.906 W2o1wfC1yw61GkMU 15601.0 35.0 -419284856 15601 -117479.64583917064 -15858 -225120.0 -15601.0 158740.17500000002 -6432.0 -35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.697 W3QY4I4LLu6yX 15601.0 -6.0 19993315 15601 5601.9375175119085 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.189 W56kQ5UX8GHpErCJ0X0PiMg 15601.0 -54.0 1304453187 15601 365495.42925189127 -15858 347328.0 -15601.0 158740.17500000002 -6432.0 54.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.747 W58KCRgshk2VVbX 15601.0 11.0 2062427061 15601 577872.5304006725 -15858 -70752.0 -15601.0 158740.17500000002 -6432.0 -11.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.83 W5d6CKH 15601.0 -40.0 283135872 15601 79331.98991314093 -15858 257280.0 -15601.0 158740.17500000002 -6432.0 40.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.028 W6d48516 15601.0 -18.0 -1310922279 15601 -367308.0075651443 -15858 115776.0 -15601.0 158740.17500000002 -6432.0 18.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:11.91 W6w0xHjP 15601.0 -30.0 -532238997 15601 -149128.32642196695 -15858 192960.0 -15601.0 158740.17500000002 -6432.0 30.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:03.127 WBuN1V4lP1858Dd3 15601.0 -27.0 934071980 15601 261718.12272345196 -15858 173664.0 -15601.0 158740.17500000002 -6432.0 27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:04.699 WLct4cIh2E3 15601.0 26.0 -2141336536 15601 -599982.217988232 -15858 -167232.0 -15601.0 158740.17500000002 -6432.0 -26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:02.752 We3u7Ih60iJx1U2kH 15601.0 -33.0 707803275 15601 198319.7744466237 -15858 212256.0 -15601.0 158740.17500000002 -6432.0 33.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:05.327 Wkr033CN8bH7LI 15601.0 26.0 1747188649 15601 489545.7128047072 -15858 -167232.0 -15601.0 158740.17500000002 -6432.0 -26.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.894 Wn8om1ooSVQSHxcg5F 15601.0 -34.0 -1225938733 15601 -343496.4228075091 -15858 218688.0 -15601.0 158740.17500000002 -6432.0 34.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:48.244 Wpi2820uS61uJ7Gn7xu822MA 15601.0 58.0 805666814 15601 225740.2112636593 -15858 -373056.0 -15601.0 158740.17500000002 -6432.0 -58.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.819 Wqx20H0G3di6k6KN54T 15601.0 -15.0 -1925755234 15601 -539578.378817596 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:09.027 X03I20xG6O6Agj1sSW0Si3F 15601.0 -15.0 1057122452 15601 296195.6996357523 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:58.202 X27PKe6lm1EmNx6tkEGfQ 15601.0 -31.0 926099123 15601 259484.203698515 -15858 199392.0 -15601.0 158740.17500000002 -6432.0 31.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.459 X3E664G5sA 15601.0 -3.0 1649136404 15601 462072.4023536004 -15858 19296.0 -15601.0 158740.17500000002 -6432.0 3.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:56.567 XKSgnqfq2Nn18h7GB6 15601.0 9.0 -1145489043 15601 -320955.1815634632 -15858 -57888.0 -15601.0 158740.17500000002 -6432.0 -9.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.479 XO40KP8emk1B6Cf4O64 15601.0 -17.0 -1901567703 15601 -532801.2616979546 -15858 109344.0 -15601.0 158740.17500000002 -6432.0 17.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.437 XP4nn8i47ipR3tsL4Bua 15601.0 0.0 1049949527 15601 294185.9139815074 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.24 XQkXKeHtwH7 15601.0 0.0 10989626 15601 3079.189128607453 -15858 -0.0 -15601.0 158740.17500000002 NaN -0.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:57.801 XfVO17QmuH0yT1uQKCKvFtU 15601.0 23.0 -996165688 15601 -279116.19165032223 -15858 -147936.0 -15601.0 158740.17500000002 -6432.0 -23.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:53.039 XgGvxqJL7ioDnQ4Bue6spR 15601.0 8.0 53656310 15601 15033.989913140937 -15858 -51456.0 -15601.0 158740.17500000002 -6432.0 -8.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.116 XhyV0PF0kbo2yqP47G1M 15601.0 62.0 158194463 15601 44324.590361445786 -15858 -398784.0 -15601.0 158740.17500000002 -6432.0 -62.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.754 Xp6aP 15601.0 49.0 46706681 15601 13086.769683384702 -15858 -315168.0 -15601.0 158740.17500000002 -6432.0 -49.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:49.097 Xt8767d0562DL58h2yksj37 15601.0 52.0 -2125793790 15601 -595627.2877556739 -15858 -334464.0 -15601.0 158740.17500000002 -6432.0 -52.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:01.652 Xy07hchP3S32iW6YG3cn3 15601.0 41.0 NULL 15601 NULL -15858 -263712.0 -15601.0 158740.17500000002 -6432.0 -41.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:46.085 Y20HmnH71A88V4 15601.0 60.0 1428011023 15601 400115.1647520314 -15858 -385920.0 -15601.0 158740.17500000002 -6432.0 -60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:44.603 Y6mE20661Ek61Mf7mYtCQV5 15601.0 -7.0 724330421 15601 202950.5242364808 -15858 45024.0 -15601.0 158740.17500000002 -6432.0 7.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:07.707 Y71O40OUSsvw 15601.0 60.0 -657503893 15601 -184226.3639674979 -15858 -385920.0 -15601.0 158740.17500000002 -6432.0 -60.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.52 Y7y6VtlL3yi6mWjRecJ60 15601.0 39.0 1748908827 15601 490027.69038946484 -15858 -250848.0 -15601.0 158740.17500000002 -6432.0 -39.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.285 YA630l4W6 15601.0 55.0 -1559932440 15601 -437078.2964415803 -15858 -353760.0 -15601.0 158740.17500000002 -6432.0 -55.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:15.507 YN4su 15601.0 -35.0 1779870001 15601 498702.7181283273 -15858 225120.0 -15601.0 158740.17500000002 -6432.0 35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:50.205 YY83652Ij 15601.0 -6.0 -1761560547 15601 -493572.58251611097 -15858 38592.0 -15601.0 158740.17500000002 -6432.0 6.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:13.954 YaD841mDwJGjwjRgGtNU2 15601.0 -35.0 -994591123 15601 -278675.0134491454 -15858 225120.0 -15601.0 158740.17500000002 -6432.0 35.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:00.614 Ydu8G8I0720hU85E53t 15601.0 27.0 -2043827141 15601 -572661.0089660969 -15858 -173664.0 -15601.0 158740.17500000002 -6432.0 -27.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:55.218 YfGW4JvD 15601.0 36.0 445347927 15601 124782.27150462315 -15858 -231552.0 -15601.0 158740.17500000002 -6432.0 -36.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:10.649 YfL70dofbs6lhgKMX8kGsJ 15601.0 -47.0 -493471535 15601 -138266.05071448584 -15858 302304.0 -15601.0 158740.17500000002 -6432.0 47.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.098 Yfj785H813DA8 15601.0 44.0 -1144200805 15601 -320594.2294760437 -15858 -283008.0 -15601.0 158740.17500000002 -6432.0 -44.0 NULL -15601.0 -2.43391201E8 +1969-12-31 16:00:14.525 YiKM5PHS02HelmT2C 15601.0 -15.0 364559164 15601 102146.02521714766 -15858 96480.0 -15601.0 158740.17500000002 -6432.0 15.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:54.292 Ym27dR7t0Txx8Syq40cdvJD5 15601.0 -45.0 -1022657523 15601 -286538.95292799105 -15858 289440.0 -15601.0 158740.17500000002 -6432.0 45.0 NULL -15601.0 -2.43391201E8 +1969-12-31 15:59:51.164 YoE3rCoae83u101q 15601.0 -21.0 142487106 15601 39923.53768562622 -15858 135072.0 -15601.0 158740.17500000002 -6432.0 21.0 NULL -15601.0 -2.43391201E8 +PREHOOK: query: -- TargetTypeClasses: Double, String, Long +-- Functions: StDev, Sum, VarP, Count +-- ArithmeticOps: Remainder, Divide, Subtract +-- FilterOps: GreaterThanOrEqual, Equal, LessThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Double, String, Long +-- Functions: StDev, Sum, VarP, Count +-- ArithmeticOps: Remainder, Divide, Subtract +-- FilterOps: GreaterThanOrEqual, Equal, LessThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL csmallint)) (TOK_SELEXPR (% (TOK_TABLE_OR_COL csmallint) (- 75))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (/ (- 1.389) (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (/ (% (TOK_TABLE_OR_COL csmallint) (- 75)) (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (- (% (TOK_TABLE_OR_COL csmallint) (- 75)))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (- (- (% (TOK_TABLE_OR_COL csmallint) (- 75))))) (TOK_SELEXPR (TOK_FUNCTIONSTAR COUNT)) (TOK_SELEXPR (- (TOK_FUNCTIONSTAR COUNT) (- 89010)))) (TOK_WHERE (AND (>= (TOK_TABLE_OR_COL csmallint) (- 257)) (OR (= (- 6432) (TOK_TABLE_OR_COL csmallint)) (AND (>= (TOK_TABLE_OR_COL cint) (TOK_TABLE_OR_COL cdouble)) (<= (TOK_TABLE_OR_COL ctinyint) (TOK_TABLE_OR_COL cint)))))) (TOK_GROUPBY (TOK_TABLE_OR_COL csmallint)) (TOK_ORDERBY (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL csmallint))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((csmallint >= (- 257)) and (((- 6432) = csmallint) or ((cint >= cdouble) and (ctinyint <= cint)))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: csmallint + type: smallint + expr: cbigint + type: bigint + expr: ctinyint + type: tinyint + outputColumnNames: csmallint, cbigint, ctinyint + Vectorized execution: true + Group By Operator + aggregations: + expr: stddev_samp(csmallint) + expr: sum(cbigint) + expr: var_pop(ctinyint) + expr: count() + bucketGroup: false + keys: + expr: csmallint + type: smallint + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col0 + type: smallint + sort order: + + Map-reduce partition columns: + expr: _col0 + type: smallint + tag: -1 + value expressions: + expr: _col1 + type: struct + expr: _col2 + type: bigint + expr: _col3 + type: struct + expr: _col4 + type: bigint + Reduce Operator Tree: + Group By Operator + aggregations: + expr: stddev_samp(VALUE._col0) + expr: sum(VALUE._col1) + expr: var_pop(VALUE._col2) + expr: count(VALUE._col3) + bucketGroup: false + keys: + expr: KEY._col0 + type: smallint + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Select Operator + expressions: + expr: _col0 + type: smallint + expr: (_col0 % (- 75)) + type: int + expr: _col1 + type: double + expr: ((- 1.389) / _col0) + type: double + expr: _col2 + type: bigint + expr: ((_col0 % (- 75)) / _col2) + type: double + expr: (- (_col0 % (- 75))) + type: int + expr: _col3 + type: double + expr: (- (- (_col0 % (- 75)))) + type: int + expr: _col4 + type: bigint + expr: (_col4 - (- 89010)) + type: bigint + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + + Stage: Stage-2 + Map Reduce + Alias -> Map Operator Tree: +#### A masked pattern was here #### + TableScan + Reduce Output Operator + key expressions: + expr: _col0 + type: smallint + sort order: + + tag: -1 + value expressions: + expr: _col0 + type: smallint + expr: _col1 + type: int + expr: _col2 + type: double + expr: _col3 + type: double + expr: _col4 + type: bigint + expr: _col5 + type: double + expr: _col6 + type: int + expr: _col7 + type: double + expr: _col8 + type: int + expr: _col9 + type: bigint + expr: _col10 + type: bigint + Reduce Operator Tree: + Extract + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT csmallint, + (csmallint % -75), + STDDEV_SAMP(csmallint), + (-1.389 / csmallint), + SUM(cbigint), + ((csmallint % -75) / SUM(cbigint)), + (-((csmallint % -75))), + VAR_POP(ctinyint), + (-((-((csmallint % -75))))), + COUNT(*), + (COUNT(*) - -89010) +FROM alltypesorc +WHERE (((csmallint >= -257)) + AND ((-6432 = csmallint) + OR ((cint >= cdouble) + AND (ctinyint <= cint)))) +GROUP BY csmallint +ORDER BY csmallint +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +-257 -32 0.0 0.005404669260700389 NULL NULL 32 0.0 -32 2 89012 +-220 -70 0.0 0.006313636363636363 NULL NULL 70 0.0 -70 1 89011 +-217 -67 0.0 0.006400921658986175 NULL NULL 67 0.0 -67 1 89011 +-203 -53 0.0 0.006842364532019704 NULL NULL 53 0.0 -53 1 89011 +-180 -30 0.0 0.007716666666666667 NULL NULL 30 0.0 -30 1 89011 +-171 -21 0.0 0.00812280701754386 NULL NULL 21 0.0 -21 1 89011 +-168 -18 0.0 0.008267857142857143 NULL NULL 18 0.0 -18 1 89011 +-165 -15 0.0 0.008418181818181818 NULL NULL 15 0.0 -15 1 89011 +-118 -43 0.0 0.011771186440677966 NULL NULL 43 0.0 -43 1 89011 +-113 -38 0.0 0.01229203539823009 NULL NULL 38 0.0 -38 1 89011 +-100 -25 0.0 0.01389 NULL NULL 25 0.0 -25 1 89011 +-95 -20 0.0 0.014621052631578948 NULL NULL 20 0.0 -20 1 89011 +-89 -14 0.0 0.015606741573033708 NULL NULL 14 0.0 -14 1 89011 +-84 -9 0.0 0.016535714285714286 NULL NULL 9 0.0 -9 1 89011 +-77 -2 0.0 0.01803896103896104 NULL NULL 2 0.0 -2 1 89011 +-75 0 0.0 0.018520000000000002 NULL NULL 0 107.55555555555556 0 3 89013 +-62 -62 0.0 0.022403225806451613 NULL NULL 62 0.0 -62 1 89011 +-49 -49 0.0 0.028346938775510203 NULL NULL 49 0.0 -49 1 89011 +-42 -42 0.0 0.03307142857142857 NULL NULL 42 0.0 -42 1 89011 +-29 -29 0.0 0.04789655172413793 NULL NULL 29 0.0 -29 1 89011 +-14 -14 0.0 0.09921428571428571 NULL NULL 14 0.0 -14 1 89011 +7 7 0.0 -0.19842857142857143 NULL NULL -7 0.0 7 1 89011 +8 8 0.0 -0.173625 NULL NULL -8 156.25 8 2 89012 +10 10 0.0 -0.1389 NULL NULL -10 0.0 10 1 89011 +19 19 0.0 -0.07310526315789474 NULL NULL -19 0.0 19 1 89011 +20 20 0.0 -0.06945 NULL NULL -20 0.0 20 1 89011 +25 25 0.0 -0.05556 NULL NULL -25 0.0 25 1 89011 +32 32 0.0 -0.04340625 NULL NULL -32 0.0 32 1 89011 +37 37 0.0 -0.03754054054054054 NULL NULL -37 0.0 37 1 89011 +41 41 0.0 -0.03387804878048781 NULL NULL -41 0.0 41 1 89011 +56 56 0.0 -0.02480357142857143 NULL NULL -56 0.0 56 1 89011 +72 72 0.0 -0.019291666666666665 NULL NULL -72 0.0 72 1 89011 +74 74 0.0 -0.01877027027027027 NULL NULL -74 16.0 74 2 89012 +77 2 0.0 -0.01803896103896104 NULL NULL -2 0.0 2 1 89011 +94 19 0.0 -0.014776595744680852 NULL NULL -19 0.0 19 1 89011 +99 24 0.0 -0.01403030303030303 NULL NULL -24 0.0 24 1 89011 +102 27 0.0 -0.01361764705882353 NULL NULL -27 0.0 27 1 89011 +130 55 0.0 -0.010684615384615384 NULL NULL -55 0.0 55 1 89011 +163 13 0.0 -0.008521472392638037 NULL NULL -13 0.0 13 1 89011 +181 31 0.0 -0.007674033149171271 NULL NULL -31 0.0 31 1 89011 +197 47 0.0 -0.007050761421319797 NULL NULL -47 256.88888888888886 47 6 89016 +199 49 0.0 -0.006979899497487437 NULL NULL -49 0.0 49 1 89011 +225 0 0.0 -0.006173333333333334 NULL NULL 0 0.0 0 1 89011 +239 14 0.0 -0.005811715481171548 NULL NULL -14 0.0 14 1 89011 +259 34 0.0 -0.005362934362934363 NULL NULL -34 0.0 34 1 89011 +265 40 0.0 -0.005241509433962264 NULL NULL -40 0.0 40 1 89011 +278 53 0.0 -0.004996402877697842 NULL NULL -53 0.0 53 1 89011 +283 58 0.0 -0.004908127208480565 NULL NULL -58 0.0 58 1 89011 +287 62 0.0 -0.0048397212543554 NULL NULL -62 0.0 62 1 89011 +306 6 0.0 -0.0045392156862745095 NULL NULL -6 0.0 6 1 89011 +308 8 0.0 -0.00450974025974026 NULL NULL -8 0.0 8 1 89011 +315 15 0.0 -0.004409523809523809 NULL NULL -15 0.0 15 1 89011 +340 40 0.0 -0.0040852941176470585 NULL NULL -40 0.0 40 1 89011 +359 59 0.0 -0.0038690807799442897 NULL NULL -59 64.0 59 2 89012 +363 63 0.0 -0.0038264462809917354 NULL NULL -63 0.0 63 1 89011 +367 67 0.0 -0.003784741144414169 NULL NULL -67 0.0 67 1 89011 +373 73 0.0 -0.0037238605898123325 NULL NULL -73 0.0 73 1 89011 +377 2 0.0 -0.0036843501326259947 NULL NULL -2 0.0 2 1 89011 +390 15 0.0 -0.0035615384615384615 NULL NULL -15 0.0 15 1 89011 +395 20 0.0 -0.0035164556962025318 NULL NULL -20 12.25 20 2 89012 +411 36 0.0 -0.0033795620437956204 NULL NULL -36 0.0 36 1 89011 +436 61 0.0 -0.0031857798165137617 NULL NULL -61 0.0 61 1 89011 +447 72 0.0 -0.0031073825503355706 NULL NULL -72 0.0 72 1 89011 +465 15 0.0 -0.0029870967741935485 NULL NULL -15 0.0 15 1 89011 +467 17 0.0 -0.002974304068522484 NULL NULL -17 0.0 17 1 89011 +486 36 0.0 -0.002858024691358025 NULL NULL -36 0.0 36 1 89011 +510 60 0.0 -0.002723529411764706 NULL NULL -60 0.0 60 1 89011 +516 66 0.0 -0.002691860465116279 NULL NULL -66 0.0 66 1 89011 +532 7 0.0 -0.0026109022556390976 NULL NULL -7 0.0 7 1 89011 +533 8 0.0 -0.0026060037523452156 NULL NULL -8 0.0 8 1 89011 +546 21 0.0 -0.002543956043956044 NULL NULL -21 256.0 21 2 89012 +547 22 0.0 -0.0025393053016453384 NULL NULL -22 0.0 22 1 89011 +557 32 0.0 -0.002493716337522442 NULL NULL -32 12.25 32 2 89012 +574 49 0.0 -0.0024198606271777 NULL NULL -49 0.0 49 1 89011 +594 69 0.0 -0.0023383838383838383 NULL NULL -69 0.0 69 1 89011 +611 11 0.0 -0.0022733224222585926 NULL NULL -11 0.0 11 1 89011 +612 12 0.0 -0.0022696078431372548 NULL NULL -12 0.0 12 1 89011 +645 45 0.0 -0.0021534883720930233 NULL NULL -45 0.0 45 1 89011 +650 50 0.0 -0.002136923076923077 NULL NULL -50 0.0 50 1 89011 +659 59 0.0 -0.0021077389984825493 NULL NULL -59 0.0 59 1 89011 +682 7 0.0 -0.0020366568914956013 NULL NULL -7 0.0 7 1 89011 +726 51 0.0 -0.0019132231404958677 NULL NULL -51 0.0 51 1 89011 +762 12 0.0 -0.0018228346456692914 NULL NULL -12 0.0 12 1 89011 +767 17 0.0 -0.0018109517601043025 NULL NULL -17 0.0 17 1 89011 +778 28 0.0 -0.0017853470437017994 NULL NULL -28 0.0 28 1 89011 +803 53 0.0 -0.001729763387297634 NULL NULL -53 25.0 53 2 89012 +834 9 0.0 -0.0016654676258992807 NULL NULL -9 0.0 9 1 89011 +838 13 0.0 -0.0016575178997613365 NULL NULL -13 0.0 13 1 89011 +859 34 0.0 -0.0016169965075669382 NULL NULL -34 0.0 34 1 89011 +865 40 0.0 -0.0016057803468208093 NULL NULL -40 0.0 40 1 89011 +876 51 0.0 -0.0015856164383561645 NULL NULL -51 0.0 51 1 89011 +893 68 0.0 -0.001555431131019037 NULL NULL -68 0.0 68 1 89011 +899 74 0.0 -0.0015450500556173526 NULL NULL -74 0.0 74 1 89011 +909 9 0.0 -0.001528052805280528 NULL NULL -9 0.0 9 1 89011 +960 60 0.0 -0.001446875 NULL NULL -60 0.0 60 1 89011 +987 12 0.0 -0.0014072948328267478 NULL NULL -12 0.0 12 1 89011 +995 20 0.0 -0.0013959798994974874 NULL NULL -20 0.0 20 1 89011 +997 22 0.0 -0.0013931795386158475 NULL NULL -22 0.0 22 1 89011 +1028 53 0.0 -0.0013511673151750973 NULL NULL -53 0.0 53 1 89011 +1049 74 0.0 -0.0013241182078169685 NULL NULL -74 0.0 74 1 89011 +1050 0 0.0 -0.0013228571428571428 NULL NULL 0 600.25 0 2 89012 +1083 33 0.0 -0.0012825484764542937 NULL NULL -33 0.0 33 1 89011 +1091 41 0.0 -0.0012731439046746104 NULL NULL -41 0.0 41 1 89011 +1097 47 0.0 -0.0012661804922515952 NULL NULL -47 0.0 47 1 89011 +1111 61 0.0 -0.0012502250225022503 NULL NULL -61 0.0 61 1 89011 +1121 71 0.0 -0.0012390722569134702 NULL NULL -71 0.0 71 1 89011 +1126 1 0.0 -0.001233570159857904 NULL NULL -1 0.0 1 1 89011 +1128 3 0.0 -0.0012313829787234042 NULL NULL -3 0.0 3 1 89011 +1135 10 0.0 -0.0012237885462555067 NULL NULL -10 0.0 10 1 89011 +1148 23 0.0 -0.00120993031358885 NULL NULL -23 0.0 23 1 89011 +1151 26 0.0 -0.001206776715899218 NULL NULL -26 342.25 26 2 89012 +1196 71 0.0 -0.001161371237458194 NULL NULL -71 0.0 71 1 89011 +1202 2 0.0 -0.0011555740432612313 NULL NULL -2 0.0 2 1 89011 +1206 6 0.0 -0.0011517412935323384 NULL NULL -6 0.0 6 1 89011 +1228 28 0.0 -0.0011311074918566775 NULL NULL -28 0.0 28 1 89011 +1232 32 0.0 -0.001127435064935065 NULL NULL -32 0.0 32 1 89011 +1246 46 0.0 -0.0011147672552166935 NULL NULL -46 0.0 46 1 89011 +1268 68 0.0 -0.0010954258675078864 NULL NULL -68 0.0 68 1 89011 +1270 70 0.0 -0.001093700787401575 NULL NULL -70 0.0 70 1 89011 +1274 74 0.0 -0.0010902668759811616 NULL NULL -74 0.0 74 1 89011 +1276 1 0.0 -0.0010885579937304076 NULL NULL -1 0.0 1 1 89011 +1282 7 0.0 -0.0010834633385335413 NULL NULL -7 0.0 7 1 89011 +1289 14 0.0 -0.001077579519006982 NULL NULL -14 0.0 14 1 89011 +1307 32 0.0 -0.0010627390971690894 NULL NULL -32 0.0 32 1 89011 +1310 35 0.0 -0.0010603053435114503 NULL NULL -35 0.0 35 1 89011 +1345 70 0.0 -0.0010327137546468402 NULL NULL -70 0.0 70 1 89011 +1346 71 0.0 -0.0010319465081723626 NULL NULL -71 0.0 71 1 89011 +1356 6 0.0 -0.0010243362831858407 NULL NULL -6 0.0 6 1 89011 +1358 8 0.0 -0.0010228276877761414 NULL NULL -8 0.0 8 1 89011 +1369 19 0.0 -0.001014609203798393 NULL NULL -19 0.0 19 1 89011 +1374 24 0.0 -0.0010109170305676856 NULL NULL -24 0.0 24 1 89011 +1399 49 0.0 -9.928520371694067E-4 NULL NULL -49 0.0 49 1 89011 +1416 66 0.0 -9.809322033898305E-4 NULL NULL -66 0.0 66 1 89011 +1419 69 0.0 -9.788583509513743E-4 NULL NULL -69 0.0 69 1 89011 +1435 10 0.0 -9.679442508710802E-4 NULL NULL -10 0.0 10 1 89011 +1437 12 0.0 -9.665970772442589E-4 NULL NULL -12 0.0 12 1 89011 +1444 19 0.0 -9.619113573407202E-4 NULL NULL -19 0.0 19 1 89011 +1455 30 0.0 -9.54639175257732E-4 NULL NULL -30 0.0 30 1 89011 +1458 33 0.0 -9.526748971193415E-4 NULL NULL -33 0.0 33 1 89011 +1464 39 0.0 -9.487704918032787E-4 NULL NULL -39 0.0 39 1 89011 +1467 42 0.0 -9.468302658486707E-4 NULL NULL -42 0.0 42 1 89011 +1475 50 0.0 -9.416949152542373E-4 NULL NULL -50 0.0 50 1 89011 +1496 71 0.0 -9.28475935828877E-4 NULL NULL -71 0.0 71 1 89011 +1502 2 0.0 -9.247669773635154E-4 NULL NULL -2 0.0 2 1 89011 +1505 5 0.0 -9.229235880398671E-4 NULL NULL -5 0.0 5 1 89011 +1512 12 0.0 -9.186507936507937E-4 NULL NULL -12 0.0 12 1 89011 +1515 15 0.0 -9.168316831683168E-4 NULL NULL -15 0.0 15 1 89011 +1542 42 0.0 -9.007782101167315E-4 NULL NULL -42 0.0 42 1 89011 +1546 46 0.0 -8.984476067270376E-4 NULL NULL -46 0.0 46 1 89011 +1556 56 0.0 -8.926735218508997E-4 NULL NULL -56 0.0 56 1 89011 +1562 62 0.0 -8.892445582586427E-4 NULL NULL -62 0.0 62 1 89011 +1567 67 0.0 -8.864071474154435E-4 NULL NULL -67 0.0 67 1 89011 +1577 2 0.0 -8.807863031071655E-4 NULL NULL -2 0.0 2 1 89011 +1600 25 0.0 -8.68125E-4 NULL NULL -25 0.0 25 1 89011 +1603 28 0.0 -8.66500311915159E-4 NULL NULL -28 0.0 28 1 89011 +1626 51 0.0 -8.542435424354244E-4 NULL NULL -51 0.0 51 1 89011 +1627 52 0.0 -8.537185003073141E-4 NULL NULL -52 0.0 52 1 89011 +1634 59 0.0 -8.500611995104039E-4 NULL NULL -59 0.0 59 1 89011 +1639 64 0.0 -8.474679682733375E-4 NULL NULL -64 0.0 64 1 89011 +1640 65 0.0 -8.469512195121952E-4 NULL NULL -65 0.0 65 1 89011 +1642 67 0.0 -8.459196102314251E-4 NULL NULL -67 0.0 67 1 89011 +1653 3 0.0 -8.402903811252269E-4 NULL NULL -3 0.0 3 1 89011 +1658 8 0.0 -8.377563329312425E-4 NULL NULL -8 0.0 8 1 89011 +1660 10 0.0 -8.367469879518073E-4 NULL NULL -10 0.0 10 1 89011 +1674 24 0.0 -8.297491039426523E-4 NULL NULL -24 0.0 24 1 89011 +1685 35 0.0 -8.243323442136499E-4 NULL NULL -35 0.0 35 1 89011 +1703 53 0.0 -8.15619495008808E-4 NULL NULL -53 0.0 53 1 89011 +1706 56 0.0 -8.141852286049238E-4 NULL NULL -56 0.0 56 1 89011 +1734 9 0.0 -8.01038062283737E-4 NULL NULL -9 0.0 9 1 89011 +1736 11 0.0 -8.001152073732719E-4 NULL NULL -11 0.0 11 1 89011 +1743 18 0.0 -7.969018932874355E-4 NULL NULL -18 0.0 18 1 89011 +1746 21 0.0 -7.955326460481099E-4 NULL NULL -21 0.0 21 1 89011 +1752 27 0.0 -7.928082191780822E-4 NULL NULL -27 0.0 27 1 89011 +1764 39 0.0 -7.874149659863946E-4 NULL NULL -39 462.25 39 2 89012 +1781 56 0.0 -7.798989331836047E-4 NULL NULL -56 0.0 56 1 89011 +1785 60 0.0 -7.781512605042017E-4 NULL NULL -60 0.0 60 1 89011 +1809 9 0.0 -7.678275290215589E-4 NULL NULL -9 0.0 9 1 89011 +1813 13 0.0 -7.661334804191947E-4 NULL NULL -13 0.0 13 1 89011 +1815 15 0.0 -7.652892561983471E-4 NULL NULL -15 0.0 15 1 89011 +1822 22 0.0 -7.623490669593852E-4 NULL NULL -22 0.0 22 1 89011 +1824 24 0.0 -7.615131578947369E-4 NULL NULL -24 0.0 24 1 89011 +1843 43 0.0 -7.5366250678242E-4 NULL NULL -43 0.0 43 1 89011 +1845 45 0.0 -7.528455284552846E-4 NULL NULL -45 0.0 45 1 89011 +1850 50 0.0 -7.508108108108108E-4 NULL NULL -50 0.0 50 1 89011 +1888 13 0.0 -7.356991525423729E-4 NULL NULL -13 0.0 13 1 89011 +1901 26 0.0 -7.306680694371384E-4 NULL NULL -26 0.0 26 1 89011 +1923 48 0.0 -7.223088923556943E-4 NULL NULL -48 0.0 48 1 89011 +1931 56 0.0 -7.193164163645779E-4 NULL NULL -56 361.0 56 2 89012 +1947 72 0.0 -7.134052388289676E-4 NULL NULL -72 0.0 72 1 89011 +1951 1 0.0 -7.119425935417735E-4 NULL NULL -1 0.0 1 1 89011 +1965 15 0.0 -7.068702290076336E-4 NULL NULL -15 0.0 15 1 89011 +1967 17 0.0 -7.061514997458058E-4 NULL NULL -17 0.0 17 1 89011 +1979 29 0.0 -7.018696311268317E-4 NULL NULL -29 0.0 29 1 89011 +2000 50 0.0 -6.945E-4 NULL NULL -50 0.0 50 1 89011 +2006 56 0.0 -6.924227318045863E-4 NULL NULL -56 0.0 56 1 89011 +2007 57 0.0 -6.920777279521674E-4 NULL NULL -57 0.0 57 1 89011 +2011 61 0.0 -6.907011437095972E-4 NULL NULL -61 930.25 61 2 89012 +2014 64 0.0 -6.896722939424032E-4 NULL NULL -64 0.0 64 1 89011 +2015 65 0.0 -6.893300248138958E-4 NULL NULL -65 0.0 65 1 89011 +2021 71 0.0 -6.872835230084117E-4 NULL NULL -71 0.0 71 1 89011 +2075 50 0.0 -6.693975903614458E-4 NULL NULL -50 0.0 50 1 89011 +2078 53 0.0 -6.684311838306064E-4 NULL NULL -53 0.0 53 1 89011 +2109 9 0.0 -6.58605974395448E-4 NULL NULL -9 0.0 9 1 89011 +2112 12 0.0 -6.576704545454545E-4 NULL NULL -12 0.0 12 1 89011 +2119 19 0.0 -6.554978763567721E-4 NULL NULL -19 0.0 19 1 89011 +2123 23 0.0 -6.542628356099859E-4 NULL NULL -23 0.0 23 1 89011 +2157 57 0.0 -6.439499304589708E-4 NULL NULL -57 0.0 57 1 89011 +2164 64 0.0 -6.418669131238447E-4 NULL NULL -64 0.0 64 1 89011 +2166 66 0.0 -6.412742382271468E-4 NULL NULL -66 0.0 66 1 89011 +2170 70 0.0 -6.400921658986175E-4 NULL NULL -70 0.0 70 1 89011 +2171 71 0.0 -6.397973284200829E-4 NULL NULL -71 0.0 71 1 89011 +2176 1 0.0 -6.38327205882353E-4 NULL NULL -1 0.0 1 1 89011 +2192 17 0.0 -6.336678832116788E-4 NULL NULL -17 0.0 17 1 89011 +2201 26 0.0 -6.310767832803272E-4 NULL NULL -26 0.0 26 1 89011 +2208 33 0.0 -6.290760869565217E-4 NULL NULL -33 0.0 33 1 89011 +2211 36 0.0 -6.282225237449118E-4 NULL NULL -36 0.0 36 1 89011 +2213 38 0.0 -6.276547672842296E-4 NULL NULL -38 0.0 38 1 89011 +2216 41 0.0 -6.268050541516245E-4 NULL NULL -41 0.0 41 1 89011 +2227 52 0.0 -6.237090255949708E-4 NULL NULL -52 0.0 52 1 89011 +2234 59 0.0 -6.217547000895255E-4 NULL NULL -59 0.0 59 1 89011 +2242 67 0.0 -6.195361284567351E-4 NULL NULL -67 0.0 67 1 89011 +2251 1 0.0 -6.170590848511773E-4 NULL NULL -1 0.0 1 1 89011 +2269 19 0.0 -6.121639488761569E-4 NULL NULL -19 0.0 19 1 89011 +2272 22 0.0 -6.113556338028169E-4 NULL NULL -22 0.0 22 1 89011 +2280 30 0.0 -6.092105263157895E-4 NULL NULL -30 0.0 30 1 89011 +2284 34 0.0 -6.081436077057794E-4 NULL NULL -34 0.0 34 1 89011 +2308 58 0.0 -6.018197573656846E-4 NULL NULL -58 0.0 58 1 89011 +2310 60 0.0 -6.012987012987013E-4 NULL NULL -60 0.0 60 1 89011 +2316 66 0.0 -5.997409326424871E-4 NULL NULL -66 0.0 66 1 89011 +2319 69 0.0 -5.989650711513584E-4 NULL NULL -69 0.0 69 1 89011 +2322 72 0.0 -5.981912144702843E-4 NULL NULL -72 0.0 72 1 89011 +2339 14 0.0 -5.938435228730227E-4 NULL NULL -14 0.0 14 1 89011 +2353 28 0.0 -5.903102422439439E-4 NULL NULL -28 225.0 28 2 89012 +2359 34 0.0 -5.888088172954642E-4 NULL NULL -34 0.0 34 1 89011 +2372 47 0.0 -5.855817875210792E-4 NULL NULL -47 0.0 47 1 89011 +2384 59 0.0 -5.826342281879195E-4 NULL NULL -59 0.0 59 1 89011 +2389 64 0.0 -5.814148179154458E-4 NULL NULL -64 0.0 64 1 89011 +2396 71 0.0 -5.797161936560935E-4 NULL NULL -71 0.0 71 1 89011 +2403 3 0.0 -5.780274656679151E-4 NULL NULL -3 0.0 3 1 89011 +2404 4 0.0 -5.777870216306157E-4 NULL NULL -4 0.0 4 1 89011 +2407 7 0.0 -5.770668882426257E-4 NULL NULL -7 0.0 7 1 89011 +2443 43 0.0 -5.685632419156775E-4 NULL NULL -43 0.0 43 1 89011 +2445 45 0.0 -5.680981595092025E-4 NULL NULL -45 0.0 45 1 89011 +2448 48 0.0 -5.674019607843137E-4 NULL NULL -48 0.0 48 1 89011 +2452 52 0.0 -5.664763458401305E-4 NULL NULL -52 0.0 52 1 89011 +2479 4 0.0 -5.603065752319483E-4 NULL NULL -4 0.0 4 1 89011 +2488 13 0.0 -5.582797427652733E-4 NULL NULL -13 0.0 13 1 89011 +2492 17 0.0 -5.573836276083467E-4 NULL NULL -17 0.0 17 1 89011 +2494 19 0.0 -5.569366479550922E-4 NULL NULL -19 0.0 19 1 89011 +2496 21 0.0 -5.564903846153847E-4 NULL NULL -21 600.25 21 2 89012 +2497 22 0.0 -5.562675210252303E-4 NULL NULL -22 0.0 22 1 89011 +2508 33 0.0 -5.538277511961722E-4 NULL NULL -33 0.0 33 1 89011 +2541 66 0.0 -5.466351829988194E-4 NULL NULL -66 0.0 66 1 89011 +2578 28 0.0 -5.38789759503491E-4 NULL NULL -28 0.0 28 1 89011 +2580 30 0.0 -5.383720930232558E-4 NULL NULL -30 0.0 30 1 89011 +2582 32 0.0 -5.379550735863672E-4 NULL NULL -32 0.0 32 1 89011 +2585 35 0.0 -5.37330754352031E-4 NULL NULL -35 0.0 35 1 89011 +2592 42 0.0 -5.358796296296296E-4 NULL NULL -42 0.0 42 1 89011 +2594 44 0.0 -5.354664610639938E-4 NULL NULL -44 0.0 44 1 89011 +2601 51 0.0 -5.340253748558247E-4 NULL NULL -51 0.0 51 1 89011 +2610 60 0.0 -5.32183908045977E-4 NULL NULL -60 0.0 60 1 89011 +2611 61 0.0 -5.319800842589047E-4 NULL NULL -61 0.0 61 1 89011 +2617 67 0.0 -5.30760412686282E-4 NULL NULL -67 0.0 67 1 89011 +2643 18 0.0 -5.255391600454029E-4 NULL NULL -18 0.0 18 1 89011 +2657 32 0.0 -5.227700414000753E-4 NULL NULL -32 0.0 32 1 89011 +2666 41 0.0 -5.210052513128282E-4 NULL NULL -41 0.0 41 1 89011 +2676 51 0.0 -5.190582959641256E-4 NULL NULL -51 0.0 51 1 89011 +2696 71 0.0 -5.152077151335311E-4 NULL NULL -71 0.0 71 1 89011 +2698 73 0.0 -5.148257968865827E-4 NULL NULL -73 0.0 73 1 89011 +2700 0 0.0 -5.144444444444444E-4 NULL NULL 0 0.0 0 1 89011 +2707 7 0.0 -5.131141485038789E-4 NULL NULL -7 0.0 7 1 89011 +2710 10 0.0 -5.125461254612546E-4 NULL NULL -10 0.0 10 1 89011 +2719 19 0.0 -5.108495770503862E-4 NULL NULL -19 0.0 19 1 89011 +2752 52 0.0 -5.047238372093023E-4 NULL NULL -52 0.0 52 1 89011 +2775 0 0.0 -5.005405405405406E-4 NULL NULL 0 0.0 0 1 89011 +2804 29 0.0 -4.953637660485022E-4 NULL NULL -29 0.0 29 1 89011 +2814 39 0.0 -4.936034115138592E-4 NULL NULL -39 0.0 39 1 89011 +2820 45 0.0 -4.925531914893618E-4 NULL NULL -45 0.0 45 1 89011 +2824 49 0.0 -4.918555240793201E-4 NULL NULL -49 0.0 49 1 89011 +2826 51 0.0 -4.915074309978769E-4 NULL NULL -51 0.0 51 1 89011 +2844 69 0.0 -4.883966244725738E-4 NULL NULL -69 0.0 69 1 89011 +2915 65 0.0 -4.7650085763293313E-4 NULL NULL -65 0.0 65 1 89011 +2921 71 0.0 -4.755220814789456E-4 NULL NULL -71 0.0 71 1 89011 +2922 72 0.0 -4.753593429158111E-4 NULL NULL -72 1521.0 72 2 89012 +2925 0 0.0 -4.748717948717949E-4 NULL NULL 0 182.25 0 2 89012 +2928 3 0.0 -4.7438524590163935E-4 NULL NULL -3 0.0 3 1 89011 +2933 8 0.0 -4.735765427889533E-4 NULL NULL -8 0.0 8 1 89011 +2969 44 0.0 -4.6783428763893565E-4 NULL NULL -44 0.0 44 1 89011 +2972 47 0.0 -4.673620457604307E-4 NULL NULL -47 0.0 47 1 89011 +2974 49 0.0 -4.670477471418964E-4 NULL NULL -49 0.0 49 1 89011 +2986 61 0.0 -4.651707970529136E-4 NULL NULL -61 0.0 61 1 89011 +2997 72 0.0 -4.6346346346346347E-4 NULL NULL -72 0.0 72 1 89011 +3018 18 0.0 -4.602385685884692E-4 NULL NULL -18 0.0 18 1 89011 +3030 30 0.0 -4.584158415841584E-4 NULL NULL -30 484.0 30 2 89012 +3058 58 0.0 -4.542184434270765E-4 NULL NULL -58 0.0 58 1 89011 +3066 66 0.0 -4.5303326810176126E-4 NULL NULL -66 0.0 66 1 89011 +3088 13 0.0 -4.498056994818653E-4 NULL NULL -13 0.0 13 1 89011 +3090 15 0.0 -4.4951456310679614E-4 NULL NULL -15 0.0 15 1 89011 +3110 35 0.0 -4.4662379421221867E-4 NULL NULL -35 0.0 35 1 89011 +3116 41 0.0 -4.457637997432606E-4 NULL NULL -41 0.0 41 1 89011 +3119 44 0.0 -4.4533504328310355E-4 NULL NULL -44 1.0 44 2 89012 +3139 64 0.0 -4.424976107040459E-4 NULL NULL -64 0.0 64 1 89011 +3140 65 0.0 -4.4235668789808916E-4 NULL NULL -65 0.0 65 1 89011 +3145 70 0.0 -4.4165341812400636E-4 NULL NULL -70 0.0 70 1 89011 +3152 2 0.0 -4.406725888324873E-4 NULL NULL -2 0.0 2 1 89011 +3168 18 0.0 -4.384469696969697E-4 NULL NULL -18 0.0 18 1 89011 +3192 42 0.0 -4.3515037593984965E-4 NULL NULL -42 0.0 42 1 89011 +3199 49 0.0 -4.341981869334167E-4 NULL NULL -49 0.0 49 1 89011 +3208 58 0.0 -4.3298004987531174E-4 NULL NULL -58 0.0 58 1 89011 +3211 61 0.0 -4.3257552164434755E-4 NULL NULL -61 0.0 61 1 89011 +3220 70 0.0 -4.313664596273292E-4 NULL NULL -70 0.0 70 1 89011 +3229 4 0.0 -4.3016413750387116E-4 NULL NULL -4 0.0 4 1 89011 +3236 11 0.0 -4.292336217552534E-4 NULL NULL -11 0.0 11 1 89011 +3248 23 0.0 -4.276477832512315E-4 NULL NULL -23 420.25 23 2 89012 +3256 31 0.0 -4.265970515970516E-4 NULL NULL -31 0.0 31 1 89011 +3333 33 0.0 -4.1674167416741676E-4 NULL NULL -33 0.0 33 1 89011 +3349 49 0.0 -4.14750671842341E-4 NULL NULL -49 0.0 49 1 89011 +3357 57 0.0 -4.1376228775692585E-4 NULL NULL -57 0.0 57 1 89011 +3366 66 0.0 -4.126559714795009E-4 NULL NULL -66 0.0 66 1 89011 +3377 2 0.0 -4.1131181522061E-4 NULL NULL -2 0.0 2 1 89011 +3406 31 0.0 -4.07809747504404E-4 NULL NULL -31 0.0 31 1 89011 +3437 62 0.0 -4.0413151003782367E-4 NULL NULL -62 0.0 62 1 89011 +3440 65 0.0 -4.037790697674419E-4 NULL NULL -65 0.0 65 1 89011 +3446 71 0.0 -4.030760301799188E-4 NULL NULL -71 0.0 71 1 89011 +3510 60 0.0 -3.957264957264957E-4 NULL NULL -60 0.0 60 1 89011 +3519 69 0.0 -3.9471440750213127E-4 NULL NULL -69 0.0 69 1 89011 +3520 70 0.0 -3.946022727272727E-4 NULL NULL -70 81.0 70 2 89012 +3522 72 0.0 -3.9437819420783647E-4 NULL NULL -72 0.0 72 1 89011 +3538 13 0.0 -3.9259468626342566E-4 NULL NULL -13 0.0 13 1 89011 +3555 30 0.0 -3.907172995780591E-4 NULL NULL -30 0.0 30 1 89011 +3571 46 0.0 -3.8896667600112013E-4 NULL NULL -46 0.0 46 1 89011 +3601 1 0.0 -3.857261871702305E-4 NULL NULL -1 0.0 1 1 89011 +3613 13 0.0 -3.8444505950733463E-4 NULL NULL -13 0.0 13 1 89011 +3617 17 0.0 -3.8401990599944705E-4 NULL NULL -17 0.0 17 1 89011 +3630 30 0.0 -3.8264462809917355E-4 NULL NULL -30 0.0 30 1 89011 +3666 66 0.0 -3.7888707037643206E-4 NULL NULL -66 0.0 66 1 89011 +3684 9 0.0 -3.770358306188925E-4 NULL NULL -9 0.0 9 1 89011 +3694 19 0.0 -3.7601515971846236E-4 NULL NULL -19 0.0 19 1 89011 +3708 33 0.0 -3.7459546925566343E-4 NULL NULL -33 0.0 33 1 89011 +3722 47 0.0 -3.7318645889306825E-4 NULL NULL -47 0.0 47 1 89011 +3725 50 0.0 -3.7288590604026846E-4 NULL NULL -50 0.0 50 1 89011 +3730 55 0.0 -3.7238605898123325E-4 NULL NULL -55 0.0 55 1 89011 +3737 62 0.0 -3.716885202033717E-4 NULL NULL -62 0.0 62 1 89011 +3768 18 0.0 -3.6863057324840767E-4 NULL NULL -18 0.0 18 1 89011 +3782 32 0.0 -3.672659968270756E-4 NULL NULL -32 0.0 32 1 89011 +3794 44 0.0 -3.661043753294676E-4 NULL NULL -44 0.0 44 1 89011 +3797 47 0.0 -3.6581511719778774E-4 NULL NULL -47 0.0 47 1 89011 +3799 49 0.0 -3.6562253224532774E-4 NULL NULL -49 0.0 49 1 89011 +3805 55 0.0 -3.650459921156373E-4 NULL NULL -55 1.0 55 2 89012 +3815 65 0.0 -3.6408912188728705E-4 NULL NULL -65 0.0 65 1 89011 +3817 67 0.0 -3.638983494891276E-4 NULL NULL -67 0.0 67 1 89011 +3827 2 0.0 -3.6294747844264436E-4 NULL NULL -2 0.0 2 1 89011 +3834 9 0.0 -3.6228482003129893E-4 NULL NULL -9 0.0 9 1 89011 +3846 21 0.0 -3.6115444617784714E-4 NULL NULL -21 0.0 21 1 89011 +3847 22 0.0 -3.610605666753314E-4 NULL NULL -22 0.0 22 1 89011 +3855 30 0.0 -3.603112840466926E-4 NULL NULL -30 0.0 30 1 89011 +3856 31 0.0 -3.6021784232365145E-4 NULL NULL -31 0.0 31 1 89011 +3874 49 0.0 -3.5854414042333504E-4 NULL NULL -49 0.0 49 1 89011 +3885 60 0.0 -3.575289575289575E-4 NULL NULL -60 0.0 60 1 89011 +3897 72 0.0 -3.5642802155504236E-4 NULL NULL -72 0.0 72 1 89011 +3908 8 0.0 -3.5542476970317296E-4 NULL NULL -8 0.0 8 1 89011 +3911 11 0.0 -3.5515213500383533E-4 NULL NULL -11 0.0 11 1 89011 +3944 44 0.0 -3.521805273833671E-4 NULL NULL -44 0.0 44 1 89011 +3945 45 0.0 -3.520912547528517E-4 NULL NULL -45 0.0 45 1 89011 +3958 58 0.0 -3.5093481556341586E-4 NULL NULL -58 0.0 58 1 89011 +3961 61 0.0 -3.5066902297399647E-4 NULL NULL -61 0.0 61 1 89011 +3971 71 0.0 -3.4978594812389827E-4 NULL NULL -71 0.0 71 1 89011 +4003 28 0.0 -3.469897576817387E-4 NULL NULL -28 0.0 28 1 89011 +4008 33 0.0 -3.465568862275449E-4 NULL NULL -33 0.0 33 1 89011 +4020 45 0.0 -3.455223880597015E-4 NULL NULL -45 0.0 45 1 89011 +4024 49 0.0 -3.451789264413519E-4 NULL NULL -49 0.0 49 1 89011 +4033 58 0.0 -3.4440862881229855E-4 NULL NULL -58 0.0 58 1 89011 +4055 5 0.0 -3.4254007398273737E-4 NULL NULL -5 0.0 5 1 89011 +4087 37 0.0 -3.3985808661609983E-4 NULL NULL -37 0.0 37 1 89011 +4096 46 0.0 -3.39111328125E-4 NULL NULL -46 0.0 46 1 89011 +4120 70 0.0 -3.371359223300971E-4 NULL NULL -70 0.0 70 1 89011 +4124 74 0.0 -3.368089233753637E-4 NULL NULL -74 0.0 74 1 89011 +4128 3 0.0 -3.364825581395349E-4 NULL NULL -3 36.0 3 2 89012 +4136 11 0.0 -3.3583172147001934E-4 NULL NULL -11 0.0 11 1 89011 +4151 26 0.0 -3.346181642977596E-4 NULL NULL -26 0.0 26 1 89011 +4153 28 0.0 -3.3445701902239344E-4 NULL NULL -28 0.0 28 1 89011 +4154 29 0.0 -3.343765045739047E-4 NULL NULL -29 0.0 29 1 89011 +4159 34 0.0 -3.3397451310411157E-4 NULL NULL -34 0.0 34 1 89011 +4162 37 0.0 -3.3373378183565596E-4 NULL NULL -37 0.0 37 1 89011 +4165 40 0.0 -3.334933973589436E-4 NULL NULL -40 0.0 40 1 89011 +4169 44 0.0 -3.331734228831854E-4 NULL NULL -44 0.0 44 1 89011 +4181 56 0.0 -3.3221717292513753E-4 NULL NULL -56 0.0 56 1 89011 +4197 72 0.0 -3.309506790564689E-4 NULL NULL -72 0.0 72 1 89011 +4207 7 0.0 -3.301640123603518E-4 NULL NULL -7 0.0 7 1 89011 +4228 28 0.0 -3.2852412488174076E-4 NULL NULL -28 0.0 28 1 89011 +4245 45 0.0 -3.2720848056537103E-4 NULL NULL -45 0.0 45 1 89011 +4256 56 0.0 -3.263627819548872E-4 NULL NULL -56 0.0 56 1 89011 +4261 61 0.0 -3.259798169443793E-4 NULL NULL -61 0.0 61 1 89011 +4264 64 0.0 -3.2575046904315195E-4 NULL NULL -64 0.0 64 1 89011 +4268 68 0.0 -3.2544517338331774E-4 NULL NULL -68 0.0 68 1 89011 +4292 17 0.0 -3.2362534948741846E-4 NULL NULL -17 0.0 17 1 89011 +4306 31 0.0 -3.2257315373896886E-4 NULL NULL -31 0.0 31 1 89011 +4322 47 0.0 -3.2137899120777416E-4 NULL NULL -47 1056.25 47 2 89012 +4336 61 0.0 -3.203413284132841E-4 NULL NULL -61 0.0 61 1 89011 +4357 7 0.0 -3.187973376176268E-4 NULL NULL -7 0.0 7 1 89011 +4368 18 0.0 -3.179945054945055E-4 NULL NULL -18 0.0 18 1 89011 +4370 20 0.0 -3.1784897025171623E-4 NULL NULL -20 0.0 20 1 89011 +4388 38 0.0 -3.165451230628988E-4 NULL NULL -38 0.0 38 1 89011 +4432 7 0.0 -3.1340252707581225E-4 NULL NULL -7 0.0 7 1 89011 +4440 15 0.0 -3.1283783783783785E-4 NULL NULL -15 0.0 15 1 89011 +4469 44 0.0 -3.108077869769523E-4 NULL NULL -44 0.0 44 1 89011 +4472 47 0.0 -3.105992844364937E-4 NULL NULL -47 0.0 47 1 89011 +4488 63 0.0 -3.094919786096257E-4 NULL NULL -63 0.0 63 1 89011 +4495 70 0.0 -3.0901001112347055E-4 NULL NULL -70 0.0 70 1 89011 +4513 13 0.0 -3.077775315754487E-4 NULL NULL -13 0.0 13 1 89011 +4539 39 0.0 -3.0601454064771975E-4 NULL NULL -39 0.0 39 1 89011 +4544 44 0.0 -3.0567781690140846E-4 NULL NULL -44 0.0 44 1 89011 +4568 68 0.0 -3.040718038528897E-4 NULL NULL -68 0.0 68 1 89011 +4572 72 0.0 -3.038057742782152E-4 NULL NULL -72 0.0 72 1 89011 +4575 0 0.0 -3.036065573770492E-4 NULL NULL 0 0.0 0 1 89011 +4577 2 0.0 -3.0347389119510595E-4 NULL NULL -2 0.0 2 1 89011 +4579 4 0.0 -3.0334134090412757E-4 NULL NULL -4 0.0 4 1 89011 +4585 10 0.0 -3.029443838604144E-4 NULL NULL -10 0.0 10 1 89011 +4587 12 0.0 -3.02812295618051E-4 NULL NULL -12 0.0 12 1 89011 +4612 37 0.0 -3.0117085862966175E-4 NULL NULL -37 0.0 37 1 89011 +4617 42 0.0 -3.008447043534763E-4 NULL NULL -42 0.0 42 1 89011 +4625 50 0.0 -3.003243243243243E-4 NULL NULL -50 0.0 50 1 89011 +4647 72 0.0 -2.989025177533893E-4 NULL NULL -72 0.0 72 1 89011 +4662 12 0.0 -2.979407979407979E-4 NULL NULL -12 0.0 12 1 89011 +4673 23 0.0 -2.972394607318639E-4 NULL NULL -23 0.0 23 1 89011 +4696 46 0.0 -2.957836456558773E-4 NULL NULL -46 0.0 46 1 89011 +4711 61 0.0 -2.9484185947781786E-4 NULL NULL -61 0.0 61 1 89011 +4783 58 0.0 -2.904035124398913E-4 NULL NULL -58 0.0 58 1 89011 +4811 11 0.0 -2.8871336520473913E-4 NULL NULL -11 0.25 11 2 89012 +4812 12 0.0 -2.886533665835411E-4 NULL NULL -12 0.0 12 1 89011 +4828 28 0.0 -2.876967688483844E-4 NULL NULL -28 0.0 28 1 89011 +4832 32 0.0 -2.874586092715232E-4 NULL NULL -32 0.0 32 1 89011 +4836 36 0.0 -2.872208436724566E-4 NULL NULL -36 0.0 36 1 89011 +4871 71 0.0 -2.8515705194005335E-4 NULL NULL -71 0.0 71 1 89011 +4936 61 0.0 -2.8140194489465153E-4 NULL NULL -61 0.0 61 1 89011 +4956 6 0.0 -2.8026634382566584E-4 NULL NULL -6 0.0 6 1 89011 +4963 13 0.0 -2.798710457384646E-4 NULL NULL -13 0.0 13 1 89011 +4967 17 0.0 -2.7964566136500906E-4 NULL NULL -17 0.0 17 1 89011 +4977 27 0.0 -2.7908378541289933E-4 NULL NULL -27 56.0 27 3 89013 +4978 28 0.0 -2.7902772197669744E-4 NULL NULL -28 0.0 28 1 89011 +4983 33 0.0 -2.787477423239013E-4 NULL NULL -33 0.0 33 1 89011 +4994 44 0.0 -2.7813376051261514E-4 NULL NULL -44 0.0 44 1 89011 +4997 47 0.0 -2.779667800680408E-4 NULL NULL -47 0.0 47 1 89011 +5000 50 0.0 -2.778E-4 NULL NULL -50 0.0 50 1 89011 +5015 65 0.0 -2.769690927218345E-4 NULL NULL -65 0.0 65 1 89011 +5025 0 0.0 -2.764179104477612E-4 NULL NULL 0 0.0 0 1 89011 +5028 3 0.0 -2.762529832935561E-4 NULL NULL -3 0.0 3 1 89011 +5042 17 0.0 -2.754859182863943E-4 NULL NULL -17 0.0 17 1 89011 +5063 38 0.0 -2.7434327473829746E-4 NULL NULL -38 0.0 38 1 89011 +5070 45 0.0 -2.7396449704142014E-4 NULL NULL -45 0.0 45 1 89011 +5085 60 0.0 -2.7315634218289084E-4 NULL NULL -60 0.0 60 1 89011 +5092 67 0.0 -2.727808326787117E-4 NULL NULL -67 0.0 67 1 89011 +5105 5 0.0 -2.720861900097943E-4 NULL NULL -5 0.0 5 1 89011 +5109 9 0.0 -2.71873165002936E-4 NULL NULL -9 0.0 9 1 89011 +5130 30 0.0 -2.7076023391812867E-4 NULL NULL -30 0.0 30 1 89011 +5147 47 0.0 -2.6986594132504373E-4 NULL NULL -47 0.0 47 1 89011 +5159 59 0.0 -2.692382244621051E-4 NULL NULL -59 0.0 59 1 89011 +5169 69 0.0 -2.6871735345327915E-4 NULL NULL -69 0.0 69 1 89011 +5190 15 0.0 -2.676300578034682E-4 NULL NULL -15 0.0 15 1 89011 +5201 26 0.0 -2.6706402614881756E-4 NULL NULL -26 0.0 26 1 89011 +5211 36 0.0 -2.665515256188831E-4 NULL NULL -36 0.0 36 1 89011 +5214 39 0.0 -2.663981588032221E-4 NULL NULL -39 0.0 39 1 89011 +5218 43 0.0 -2.6619394403986203E-4 NULL NULL -43 0.0 43 1 89011 +5219 44 0.0 -2.661429392603947E-4 NULL NULL -44 0.0 44 1 89011 +5240 65 0.0 -2.6507633587786257E-4 NULL NULL -65 0.0 65 1 89011 +5241 66 0.0 -2.6502575844304524E-4 NULL NULL -66 529.0 66 2 89012 +5248 73 0.0 -2.64672256097561E-4 NULL NULL -73 0.0 73 1 89011 +5259 9 0.0 -2.641186537364518E-4 NULL NULL -9 0.0 9 1 89011 +5290 40 0.0 -2.6257088846880905E-4 NULL NULL -40 0.0 40 1 89011 +5323 73 0.0 -2.6094307721209845E-4 NULL NULL -73 0.0 73 1 89011 +5327 2 0.0 -2.607471372254552E-4 NULL NULL -2 0.0 2 1 89011 +5348 23 0.0 -2.5972326103216155E-4 NULL NULL -23 0.0 23 1 89011 +5356 31 0.0 -2.5933532486930547E-4 NULL NULL -31 0.0 31 1 89011 +5369 44 0.0 -2.587073943006146E-4 NULL NULL -44 0.0 44 1 89011 +5377 52 0.0 -2.583224846568719E-4 NULL NULL -52 0.0 52 1 89011 +5383 58 0.0 -2.5803455322310977E-4 NULL NULL -58 0.0 58 1 89011 +5393 68 0.0 -2.5755609122937143E-4 NULL NULL -68 0.0 68 1 89011 +5394 69 0.0 -2.575083426028921E-4 NULL NULL -69 0.0 69 1 89011 +5400 0 0.0 -2.572222222222222E-4 NULL NULL 0 0.0 0 1 89011 +5406 6 0.0 -2.569367369589345E-4 NULL NULL -6 0.0 6 1 89011 +5412 12 0.0 -2.566518847006652E-4 NULL NULL -12 0.0 12 1 89011 +5420 20 0.0 -2.562730627306273E-4 NULL NULL -20 0.0 20 1 89011 +5451 51 0.0 -2.5481563015960373E-4 NULL NULL -51 552.25 51 2 89012 +5484 9 0.0 -2.5328227571115976E-4 NULL NULL -9 0.0 9 1 89011 +5487 12 0.0 -2.531437944231821E-4 NULL NULL -12 0.0 12 1 89011 +5495 20 0.0 -2.5277525022747953E-4 NULL NULL -20 0.0 20 1 89011 +5507 32 0.0 -2.5222444161975666E-4 NULL NULL -32 0.0 32 1 89011 +5521 46 0.0 -2.515848578156131E-4 NULL NULL -46 0.0 46 1 89011 +5562 12 0.0 -2.4973031283710896E-4 NULL NULL -12 0.0 12 1 89011 +5568 18 0.0 -2.4946120689655173E-4 NULL NULL -18 0.0 18 1 89011 +5580 30 0.0 -2.489247311827957E-4 NULL NULL -30 0.0 30 1 89011 +5603 53 0.0 -2.479029091558094E-4 NULL NULL -53 0.0 53 1 89011 +5617 67 0.0 -2.4728502759480147E-4 NULL NULL -67 0.0 67 1 89011 +5630 5 0.0 -2.467140319715808E-4 NULL NULL -5 0.0 5 1 89011 +5641 16 0.0 -2.462329374224428E-4 NULL NULL -16 0.0 16 1 89011 +5643 18 0.0 -2.461456671982988E-4 NULL NULL -18 0.0 18 1 89011 +5645 20 0.0 -2.4605845881310893E-4 NULL NULL -20 0.0 20 1 89011 +5654 29 0.0 -2.456667845772904E-4 NULL NULL -29 0.0 29 1 89011 +5661 36 0.0 -2.453630100688924E-4 NULL NULL -36 0.0 36 1 89011 +5663 38 0.0 -2.4527635528871625E-4 NULL NULL -38 0.0 38 1 89011 +5680 55 0.0 -2.4454225352112677E-4 NULL NULL -55 0.0 55 1 89011 +5687 62 0.0 -2.4424125197819587E-4 NULL NULL -62 0.0 62 1 89011 +5707 7 0.0 -2.4338531627825477E-4 NULL NULL -7 0.0 7 1 89011 +5716 16 0.0 -2.4300209937018895E-4 NULL NULL -16 0.0 16 1 89011 +5722 22 0.0 -2.4274729115693813E-4 NULL NULL -22 0.0 22 1 89011 +5741 41 0.0 -2.419439122104163E-4 NULL NULL -41 0.0 41 1 89011 +5752 52 0.0 -2.4148122392211405E-4 NULL NULL -52 0.0 52 1 89011 +5764 64 0.0 -2.4097848716169326E-4 NULL NULL -64 0.0 64 1 89011 +5780 5 0.0 -2.403114186851211E-4 NULL NULL -5 930.25 5 2 89012 +5785 10 0.0 -2.401037165082109E-4 NULL NULL -10 0.0 10 1 89011 +5786 11 0.0 -2.4006221914967162E-4 NULL NULL -11 0.0 11 1 89011 +5790 15 0.0 -2.3989637305699482E-4 NULL NULL -15 0.0 15 1 89011 +5792 17 0.0 -2.3981353591160222E-4 NULL NULL -17 0.0 17 1 89011 +5793 18 0.0 -2.3977213878819266E-4 NULL NULL -18 0.0 18 1 89011 +5814 39 0.0 -2.3890608875129E-4 NULL NULL -39 0.0 39 1 89011 +5815 40 0.0 -2.3886500429922615E-4 NULL NULL -40 0.0 40 1 89011 +5847 72 0.0 -2.375577219086711E-4 NULL NULL -72 0.0 72 1 89011 +5851 1 0.0 -2.3739531703982226E-4 NULL NULL -1 0.0 1 1 89011 +5855 5 0.0 -2.372331340734415E-4 NULL NULL -5 0.0 5 1 89011 +5865 15 0.0 -2.3682864450127878E-4 NULL NULL -15 0.0 15 1 89011 +5885 35 0.0 -2.3602378929481733E-4 NULL NULL -35 12.25 35 2 89012 +5892 42 0.0 -2.3574338085539714E-4 NULL NULL -42 0.0 42 1 89011 +5898 48 0.0 -2.3550356052899288E-4 NULL NULL -48 0.0 48 1 89011 +5927 2 0.0 -2.3435127383161802E-4 NULL NULL -2 0.0 2 1 89011 +5929 4 0.0 -2.342722212852083E-4 NULL NULL -4 0.0 4 1 89011 +5941 16 0.0 -2.3379902373337822E-4 NULL NULL -16 0.0 16 1 89011 +5944 19 0.0 -2.3368102288021534E-4 NULL NULL -19 0.0 19 1 89011 +5961 36 0.0 -2.3301459486663311E-4 NULL NULL -36 0.0 36 1 89011 +5972 47 0.0 -2.325853985264568E-4 NULL NULL -47 0.0 47 1 89011 +5977 52 0.0 -2.3239083152082986E-4 NULL NULL -52 0.0 52 1 89011 +5988 63 0.0 -2.3196392785571141E-4 NULL NULL -63 0.0 63 1 89011 +6004 4 0.0 -2.3134576948700866E-4 NULL NULL -4 0.0 4 1 89011 +6015 15 0.0 -2.309226932668329E-4 NULL NULL -15 0.0 15 1 89011 +6018 18 0.0 -2.308075772681954E-4 NULL NULL -18 0.0 18 1 89011 +6036 36 0.0 -2.301192842942346E-4 NULL NULL -36 0.25 36 2 89012 +6048 48 0.0 -2.296626984126984E-4 NULL NULL -48 0.0 48 1 89011 +6062 62 0.0 -2.2913229957109864E-4 NULL NULL -62 0.0 62 1 89011 +6069 69 0.0 -2.2886801779535343E-4 NULL NULL -69 0.0 69 1 89011 +6072 72 0.0 -2.2875494071146246E-4 NULL NULL -72 0.0 72 1 89011 +6090 15 0.0 -2.2807881773399016E-4 NULL NULL -15 0.0 15 1 89011 +6103 28 0.0 -2.2759298705554647E-4 NULL NULL -28 0.0 28 1 89011 +6114 39 0.0 -2.2718351324828263E-4 NULL NULL -39 0.0 39 1 89011 +6183 33 0.0 -2.2464822901504123E-4 NULL NULL -33 0.0 33 1 89011 +6192 42 0.0 -2.2432170542635658E-4 NULL NULL -42 0.0 42 1 89011 +6228 3 0.0 -2.2302504816955684E-4 NULL NULL -3 0.0 3 1 89011 +6246 21 0.0 -2.223823246878002E-4 NULL NULL -21 0.0 21 1 89011 +6248 23 0.0 -2.2231113956466068E-4 NULL NULL -23 0.0 23 1 89011 +6256 31 0.0 -2.2202685421994885E-4 NULL NULL -31 0.0 31 1 89011 +6264 39 0.0 -2.217432950191571E-4 NULL NULL -39 0.0 39 1 89011 +6297 72 0.0 -2.2058122915674132E-4 NULL NULL -72 0.0 72 1 89011 +6300 0 0.0 -2.2047619047619048E-4 NULL NULL 0 0.0 0 1 89011 +6303 3 0.0 -2.2037125178486436E-4 NULL NULL -3 0.0 3 1 89011 +6311 11 0.0 -2.2009190302646174E-4 NULL NULL -11 0.0 11 1 89011 +6321 21 0.0 -2.197437114380636E-4 NULL NULL -21 0.0 21 1 89011 +6327 27 0.0 -2.1953532479848268E-4 NULL NULL -27 0.0 27 1 89011 +6340 40 0.0 -2.190851735015773E-4 NULL NULL -40 0.0 40 1 89011 +6346 46 0.0 -2.1887803340687046E-4 NULL NULL -46 0.0 46 1 89011 +6349 49 0.0 -2.187746101748307E-4 NULL NULL -49 0.0 49 1 89011 +6380 5 0.0 -2.177115987460815E-4 NULL NULL -5 0.0 5 1 89011 +6385 10 0.0 -2.1754111198120596E-4 NULL NULL -10 0.0 10 1 89011 +6389 14 0.0 -2.174049146971357E-4 NULL NULL -14 0.0 14 1 89011 +6413 38 0.0 -2.165912989240605E-4 NULL NULL -38 0.0 38 1 89011 +6453 3 0.0 -2.1524872152487215E-4 NULL NULL -3 0.0 3 1 89011 +6469 19 0.0 -2.1471633946514146E-4 NULL NULL -19 0.0 19 1 89011 +6506 56 0.0 -2.1349523516753767E-4 NULL NULL -56 0.0 56 1 89011 +6511 61 0.0 -2.133312855168177E-4 NULL NULL -61 0.0 61 1 89011 +6513 63 0.0 -2.1326577614002763E-4 NULL NULL -63 0.0 63 1 89011 +6516 66 0.0 -2.1316758747697974E-4 NULL NULL -66 0.0 66 1 89011 +6523 73 0.0 -2.12938831825847E-4 NULL NULL -73 0.0 73 1 89011 +6546 21 0.0 -2.1219065077910174E-4 NULL NULL -21 0.0 21 1 89011 +6554 29 0.0 -2.119316447970705E-4 NULL NULL -29 0.0 29 1 89011 +6556 31 0.0 -2.1186699206833436E-4 NULL NULL -31 0.0 31 1 89011 +6557 32 0.0 -2.118346804941284E-4 NULL NULL -32 0.0 32 1 89011 +6576 51 0.0 -2.1122262773722627E-4 NULL NULL -51 0.0 51 1 89011 +6578 53 0.0 -2.1115840681058072E-4 NULL NULL -53 0.0 53 1 89011 +6596 71 0.0 -2.10582171012735E-4 NULL NULL -71 0.0 71 1 89011 +6616 16 0.0 -2.0994558645707375E-4 NULL NULL -16 0.0 16 1 89011 +6626 26 0.0 -2.0962873528523995E-4 NULL NULL -26 0.0 26 1 89011 +6654 54 0.0 -2.0874661857529306E-4 NULL NULL -54 0.0 54 1 89011 +6658 58 0.0 -2.086212075698408E-4 NULL NULL -58 0.0 58 1 89011 +6663 63 0.0 -2.0846465556055831E-4 NULL NULL -63 0.0 63 1 89011 +6666 66 0.0 -2.0837083708370838E-4 NULL NULL -66 0.0 66 1 89011 +6667 67 0.0 -2.0833958302084895E-4 NULL NULL -67 0.0 67 1 89011 +6690 15 0.0 -2.0762331838565022E-4 NULL NULL -15 0.0 15 1 89011 +6725 50 0.0 -2.0654275092936802E-4 NULL NULL -50 0.0 50 1 89011 +6731 56 0.0 -2.0635863913237261E-4 NULL NULL -56 0.0 56 1 89011 +6732 57 0.0 -2.0632798573975045E-4 NULL NULL -57 0.0 57 1 89011 +6738 63 0.0 -2.0614425645592164E-4 NULL NULL -63 0.0 63 1 89011 +6749 74 0.0 -2.058082678915395E-4 NULL NULL -74 0.0 74 1 89011 +6760 10 0.0 -2.054733727810651E-4 NULL NULL -10 0.0 10 1 89011 +6775 25 0.0 -2.0501845018450185E-4 NULL NULL -25 0.0 25 1 89011 +6776 26 0.0 -2.0498819362455727E-4 NULL NULL -26 0.0 26 1 89011 +6777 27 0.0 -2.0495794599380258E-4 NULL NULL -27 0.0 27 1 89011 +6790 40 0.0 -2.0456553755522828E-4 NULL NULL -40 0.0 40 1 89011 +6793 43 0.0 -2.044751950537318E-4 NULL NULL -43 0.0 43 1 89011 +6798 48 0.0 -2.0432480141218006E-4 NULL NULL -48 0.0 48 1 89011 +6802 52 0.0 -2.042046456924434E-4 NULL NULL -52 0.0 52 1 89011 +6811 61 0.0 -2.039348113346058E-4 NULL NULL -61 0.0 61 1 89011 +6823 73 0.0 -2.0357613952806683E-4 NULL NULL -73 0.0 73 1 89011 +6827 2 0.0 -2.034568624578878E-4 NULL NULL -2 0.0 2 1 89011 +6838 13 0.0 -2.0312957004972213E-4 NULL NULL -13 0.0 13 1 89011 +6848 23 0.0 -2.0283294392523364E-4 NULL NULL -23 0.0 23 1 89011 +6849 24 0.0 -2.0280332895313184E-4 NULL NULL -24 0.0 24 1 89011 +6852 27 0.0 -2.0271453590192646E-4 NULL NULL -27 0.0 27 1 89011 +6864 39 0.0 -2.0236013986013986E-4 NULL NULL -39 0.0 39 1 89011 +6866 41 0.0 -2.0230119429070784E-4 NULL NULL -41 0.0 41 1 89011 +6898 73 0.0 -2.013627138300957E-4 NULL NULL -73 0.0 73 1 89011 +6903 3 0.0 -2.012168622338114E-4 NULL NULL -3 0.0 3 1 89011 +6910 10 0.0 -2.0101302460202606E-4 NULL NULL -10 0.0 10 1 89011 +6912 12 0.0 -2.0095486111111111E-4 NULL NULL -12 0.0 12 1 89011 +6923 23 0.0 -2.0063556261736243E-4 NULL NULL -23 0.0 23 1 89011 +6935 35 0.0 -2.0028839221341023E-4 NULL NULL -35 0.0 35 1 89011 +6941 41 0.0 -2.001152571675551E-4 NULL NULL -41 0.0 41 1 89011 +6958 58 0.0 -1.9962632940500143E-4 NULL NULL -58 0.0 58 1 89011 +6961 61 0.0 -1.9954029593449217E-4 NULL NULL -61 0.0 61 1 89011 +6967 67 0.0 -1.9936845127027414E-4 NULL NULL -67 0.0 67 1 89011 +6974 74 0.0 -1.9916833954688844E-4 NULL NULL -74 0.0 74 1 89011 +6995 20 0.0 -1.9857040743388136E-4 NULL NULL -20 0.0 20 1 89011 +7006 31 0.0 -1.98258635455324E-4 NULL NULL -31 0.0 31 1 89011 +7007 32 0.0 -1.9823034108748395E-4 NULL NULL -32 0.0 32 1 89011 +7021 46 0.0 -1.978350662298818E-4 NULL NULL -46 0.0 46 1 89011 +7022 47 0.0 -1.9780689262318427E-4 NULL NULL -47 0.0 47 1 89011 +7046 71 0.0 -1.9713312517740563E-4 NULL NULL -71 0.0 71 1 89011 +7060 10 0.0 -1.9674220963172804E-4 NULL NULL -10 0.0 10 1 89011 +7062 12 0.0 -1.9668649107901446E-4 NULL NULL -12 0.0 12 1 89011 +7077 27 0.0 -1.9626960576515473E-4 NULL NULL -27 0.0 27 1 89011 +7085 35 0.0 -1.9604798870853917E-4 NULL NULL -35 0.0 35 1 89011 +7109 59 0.0 -1.9538613025742017E-4 NULL NULL -59 0.0 59 1 89011 +7111 61 0.0 -1.953311770496414E-4 NULL NULL -61 0.0 61 1 89011 +7118 68 0.0 -1.9513908401236303E-4 NULL NULL -68 0.0 68 1 89011 +7162 37 0.0 -1.939402401563809E-4 NULL NULL -37 0.0 37 1 89011 +7175 50 0.0 -1.9358885017421604E-4 NULL NULL -50 0.0 50 1 89011 +7178 53 0.0 -1.9350794093062136E-4 NULL NULL -53 0.0 53 1 89011 +7179 54 0.0 -1.9348098620977853E-4 NULL NULL -54 0.0 54 1 89011 +7180 55 0.0 -1.934540389972145E-4 NULL NULL -55 0.0 55 1 89011 +7182 57 0.0 -1.9340016708437762E-4 NULL NULL -57 0.0 57 1 89011 +7205 5 0.0 -1.9278278972935462E-4 NULL NULL -5 0.0 5 1 89011 +7207 7 0.0 -1.927292909671153E-4 NULL NULL -7 0.0 7 1 89011 +7212 12 0.0 -1.925956738768719E-4 NULL NULL -12 0.0 12 1 89011 +7238 38 0.0 -1.9190384084001106E-4 NULL NULL -38 0.0 38 1 89011 +7243 43 0.0 -1.9177136545630265E-4 NULL NULL -43 0.0 43 1 89011 +7249 49 0.0 -1.916126362256863E-4 NULL NULL -49 0.0 49 1 89011 +7276 1 0.0 -1.9090159428257285E-4 NULL NULL -1 0.0 1 1 89011 +7279 4 0.0 -1.908229152356093E-4 NULL NULL -4 0.0 4 1 89011 +7287 12 0.0 -1.906134211609716E-4 NULL NULL -12 0.0 12 1 89011 +7288 13 0.0 -1.905872667398463E-4 NULL NULL -13 0.0 13 1 89011 +7290 15 0.0 -1.905349794238683E-4 NULL NULL -15 0.0 15 1 89011 +7302 27 0.0 -1.9022185702547247E-4 NULL NULL -27 0.0 27 1 89011 +7316 41 0.0 -1.8985784581738654E-4 NULL NULL -41 0.0 41 1 89011 +7350 0 0.0 -1.8897959183673468E-4 NULL NULL 0 0.0 0 1 89011 +7364 14 0.0 -1.8862031504617057E-4 NULL NULL -14 0.0 14 1 89011 +7365 15 0.0 -1.8859470468431772E-4 NULL NULL -15 0.0 15 1 89011 +7372 22 0.0 -1.88415626695605E-4 NULL NULL -22 0.0 22 1 89011 +7375 25 0.0 -1.8833898305084746E-4 NULL NULL -25 0.0 25 1 89011 +7398 48 0.0 -1.8775344687753446E-4 NULL NULL -48 0.0 48 1 89011 +7412 62 0.0 -1.8739881273610362E-4 NULL NULL -62 0.0 62 1 89011 +7423 73 0.0 -1.8712111006331672E-4 NULL NULL -73 0.0 73 1 89011 +7442 17 0.0 -1.8664337543671056E-4 NULL NULL -17 0.0 17 1 89011 +7457 32 0.0 -1.8626793616735953E-4 NULL NULL -32 0.0 32 1 89011 +7463 38 0.0 -1.861181830363125E-4 NULL NULL -38 0.0 38 1 89011 +7476 51 0.0 -1.8579454253611556E-4 NULL NULL -51 0.0 51 1 89011 +7477 52 0.0 -1.857696937274308E-4 NULL NULL -52 0.0 52 1 89011 +7482 57 0.0 -1.8564554931836409E-4 NULL NULL -57 0.0 57 1 89011 +7485 60 0.0 -1.8557114228456915E-4 NULL NULL -60 0.0 60 1 89011 +7493 68 0.0 -1.8537301481382623E-4 NULL NULL -68 0.0 68 1 89011 +7497 72 0.0 -1.8527410964385755E-4 NULL NULL -72 0.0 72 1 89011 +7500 0 0.0 -1.852E-4 NULL NULL 0 0.0 0 1 89011 +7511 11 0.0 -1.849287711356677E-4 NULL NULL -11 0.0 11 1 89011 +7513 13 0.0 -1.848795421269799E-4 NULL NULL -13 0.0 13 1 89011 +7536 36 0.0 -1.8431528662420384E-4 NULL NULL -36 0.0 36 1 89011 +7538 38 0.0 -1.8426638365614222E-4 NULL NULL -38 0.0 38 1 89011 +7541 41 0.0 -1.8419307784113513E-4 NULL NULL -41 0.0 41 1 89011 +7548 48 0.0 -1.8402225755166933E-4 NULL NULL -48 0.0 48 1 89011 +7552 52 0.0 -1.8392478813559322E-4 NULL NULL -52 0.0 52 1 89011 +7556 56 0.0 -1.8382742191635788E-4 NULL NULL -56 0.0 56 1 89011 +7559 59 0.0 -1.837544648763064E-4 NULL NULL -59 0.0 59 1 89011 +7574 74 0.0 -1.8339054660681278E-4 NULL NULL -74 0.0 74 1 89011 +7588 13 0.0 -1.830521876647338E-4 NULL NULL -13 0.0 13 1 89011 +7599 24 0.0 -1.8278720884326886E-4 NULL NULL -24 0.0 24 1 89011 +7607 32 0.0 -1.8259497830945182E-4 NULL NULL -32 0.0 32 1 89011 +7616 41 0.0 -1.8237920168067228E-4 NULL NULL -41 0.0 41 1 89011 +7623 48 0.0 -1.8221172766627312E-4 NULL NULL -48 0.0 48 1 89011 +7636 61 0.0 -1.8190151911995809E-4 NULL NULL -61 0.0 61 1 89011 +7642 67 0.0 -1.8175870191049464E-4 NULL NULL -67 0.0 67 1 89011 +7648 73 0.0 -1.8161610878661088E-4 NULL NULL -73 256.0 73 2 89012 +7651 1 0.0 -1.8154489609201413E-4 NULL NULL -1 0.0 1 1 89011 +7661 11 0.0 -1.813079232476178E-4 NULL NULL -11 0.0 11 1 89011 +7675 25 0.0 -1.809771986970684E-4 NULL NULL -25 0.0 25 1 89011 +7705 55 0.0 -1.8027255029201818E-4 NULL NULL -55 64.0 55 2 89012 +7709 59 0.0 -1.8017901154494746E-4 NULL NULL -59 0.0 59 1 89011 +7712 62 0.0 -1.8010892116182572E-4 NULL NULL -62 0.0 62 1 89011 +7713 63 0.0 -1.8008556981719174E-4 NULL NULL -63 0.0 63 1 89011 +7723 73 0.0 -1.798523889680176E-4 NULL NULL -73 0.0 73 1 89011 +7731 6 0.0 -1.796662786185487E-4 NULL NULL -6 0.0 6 1 89011 +7759 34 0.0 -1.7901791467972677E-4 NULL NULL -34 0.0 34 1 89011 +7777 52 0.0 -1.786035746431786E-4 NULL NULL -52 0.0 52 1 89011 +7787 62 0.0 -1.7837421343264414E-4 NULL NULL -62 0.0 62 1 89011 +7812 12 0.0 -1.7780337941628263E-4 NULL NULL -12 0.0 12 1 89011 +7813 13 0.0 -1.7778062204018943E-4 NULL NULL -13 0.0 13 1 89011 +7828 28 0.0 -1.7743995912110374E-4 NULL NULL -28 0.0 28 1 89011 +7836 36 0.0 -1.7725880551301685E-4 NULL NULL -36 0.0 36 1 89011 +7847 47 0.0 -1.7701032241621E-4 NULL NULL -47 0.0 47 1 89011 +7854 54 0.0 -1.768525592055004E-4 NULL NULL -54 0.0 54 1 89011 +7860 60 0.0 -1.767175572519084E-4 NULL NULL -60 0.0 60 1 89011 +7891 16 0.0 -1.760233177037131E-4 NULL NULL -16 0.0 16 1 89011 +7902 27 0.0 -1.7577828397873955E-4 NULL NULL -27 0.0 27 1 89011 +7903 28 0.0 -1.7575604200936355E-4 NULL NULL -28 0.0 28 1 89011 +7940 65 0.0 -1.7493702770780858E-4 NULL NULL -65 0.0 65 1 89011 +7942 67 0.0 -1.7489297406194913E-4 NULL NULL -67 0.0 67 1 89011 +7952 2 0.0 -1.7467303822937626E-4 NULL NULL -2 0.0 2 1 89011 +7972 22 0.0 -1.74234821876568E-4 NULL NULL -22 0.0 22 1 89011 +7974 24 0.0 -1.7419112114371707E-4 NULL NULL -24 0.0 24 1 89011 +7985 35 0.0 -1.7395115842204132E-4 NULL NULL -35 0.0 35 1 89011 +7993 43 0.0 -1.7377705492305768E-4 NULL NULL -43 0.0 43 1 89011 +8000 50 0.0 -1.73625E-4 NULL NULL -50 0.0 50 1 89011 +8001 51 0.0 -1.7360329958755156E-4 NULL NULL -51 0.0 51 1 89011 +8007 57 0.0 -1.7347321094042712E-4 NULL NULL -57 0.0 57 1 89011 +8031 6 0.0 -1.72954800149421E-4 NULL NULL -6 0.0 6 1 89011 +8035 10 0.0 -1.7286869943995023E-4 NULL NULL -10 0.0 10 1 89011 +8046 21 0.0 -1.726323639075317E-4 NULL NULL -21 0.0 21 1 89011 +8048 23 0.0 -1.7258946322067594E-4 NULL NULL -23 0.0 23 1 89011 +8050 25 0.0 -1.7254658385093167E-4 NULL NULL -25 0.0 25 1 89011 +8063 38 0.0 -1.7226838645665384E-4 NULL NULL -38 0.0 38 1 89011 +8072 47 0.0 -1.720763131813677E-4 NULL NULL -47 0.0 47 1 89011 +8076 51 0.0 -1.7199108469539377E-4 NULL NULL -51 0.0 51 1 89011 +8084 59 0.0 -1.7182088075210291E-4 NULL NULL -59 0.0 59 1 89011 +8091 66 0.0 -1.7167222840192806E-4 NULL NULL -66 0.0 66 1 89011 +8096 71 0.0 -1.7156620553359685E-4 NULL NULL -71 0.0 71 1 89011 +8104 4 0.0 -1.713968410661402E-4 NULL NULL -4 0.0 4 1 89011 +8105 5 0.0 -1.713756940160395E-4 NULL NULL -5 0.0 5 1 89011 +8129 29 0.0 -1.7086972567351459E-4 NULL NULL -29 0.0 29 1 89011 +8142 42 0.0 -1.7059690493736183E-4 NULL NULL -42 0.0 42 1 89011 +8191 16 0.0 -1.69576364302283E-4 NULL NULL -16 0.0 16 1 89011 +8201 26 0.0 -1.6936958907450312E-4 NULL NULL -26 0.0 26 1 89011 +8229 54 0.0 -1.6879329201604083E-4 NULL NULL -54 0.0 54 1 89011 +8231 56 0.0 -1.6875227797351477E-4 NULL NULL -56 0.0 56 1 89011 +8234 59 0.0 -1.6869079426767064E-4 NULL NULL -59 0.0 59 1 89011 +8237 62 0.0 -1.686293553478208E-4 NULL NULL -62 0.0 62 1 89011 +8267 17 0.0 -1.680174186524737E-4 NULL NULL -17 0.0 17 1 89011 +8270 20 0.0 -1.6795646916565902E-4 NULL NULL -20 0.0 20 1 89011 +8296 46 0.0 -1.674300867888139E-4 NULL NULL -46 0.0 46 1 89011 +8301 51 0.0 -1.6732923744127213E-4 NULL NULL -51 0.0 51 1 89011 +8319 69 0.0 -1.6696718355571584E-4 NULL NULL -69 0.0 69 1 89011 +8340 15 0.0 -1.6654676258992805E-4 NULL NULL -15 30.25 15 2 89012 +8341 16 0.0 -1.6652679534827957E-4 NULL NULL -16 0.0 16 1 89011 +8346 21 0.0 -1.6642703091301222E-4 NULL NULL -21 0.0 21 1 89011 +8347 22 0.0 -1.6640709236851565E-4 NULL NULL -22 0.0 22 1 89011 +8351 26 0.0 -1.6632738594180339E-4 NULL NULL -26 0.0 26 1 89011 +8353 28 0.0 -1.6628756135520173E-4 NULL NULL -28 0.0 28 1 89011 +8354 29 0.0 -1.6626765621259278E-4 NULL NULL -29 0.0 29 1 89011 +8365 40 0.0 -1.6604901374775853E-4 NULL NULL -40 0.0 40 1 89011 +8368 43 0.0 -1.6598948374760993E-4 NULL NULL -43 0.0 43 1 89011 +8370 45 0.0 -1.6594982078853046E-4 NULL NULL -45 0.0 45 1 89011 +8375 50 0.0 -1.6585074626865673E-4 NULL NULL -50 0.0 50 1 89011 +8384 59 0.0 -1.6567270992366413E-4 NULL NULL -59 0.0 59 1 89011 +8386 61 0.0 -1.656331981874553E-4 NULL NULL -61 0.0 61 1 89011 +8402 2 0.0 -1.6531778148059985E-4 NULL NULL -2 0.0 2 1 89011 +8408 8 0.0 -1.6519980970504283E-4 NULL NULL -8 0.0 8 1 89011 +8429 29 0.0 -1.6478823110689287E-4 NULL NULL -29 0.0 29 1 89011 +8442 42 0.0 -1.6453447050461976E-4 NULL NULL -42 0.0 42 1 89011 +8445 45 0.0 -1.644760213143872E-4 NULL NULL -45 0.0 45 1 89011 +8448 48 0.0 -1.6441761363636363E-4 NULL NULL -48 0.0 48 1 89011 +8451 51 0.0 -1.6435924742634007E-4 NULL NULL -51 0.0 51 1 89011 +8465 65 0.0 -1.6408741878322505E-4 NULL NULL -65 0.0 65 1 89011 +8471 71 0.0 -1.6397119584464644E-4 NULL NULL -71 0.0 71 1 89011 +8487 12 0.0 -1.6366207140332273E-4 NULL NULL -12 0.0 12 1 89011 +8499 24 0.0 -1.6343099188139782E-4 NULL NULL -24 0.0 24 1 89011 +8505 30 0.0 -1.6331569664902997E-4 NULL NULL -30 0.0 30 1 89011 +8523 48 0.0 -1.6297078493488209E-4 NULL NULL -48 0.0 48 1 89011 +8540 65 0.0 -1.626463700234192E-4 NULL NULL -65 0.0 65 1 89011 +8549 74 0.0 -1.6247514329161306E-4 NULL NULL -74 36.0 74 2 89012 +8580 30 0.0 -1.618881118881119E-4 NULL NULL -30 0.0 30 1 89011 +8584 34 0.0 -1.6181267474370923E-4 NULL NULL -34 0.0 34 1 89011 +8625 0 0.0 -1.6104347826086956E-4 NULL NULL 0 0.0 0 1 89011 +8648 23 0.0 -1.6061517113783534E-4 NULL NULL -23 0.0 23 1 89011 +8661 36 0.0 -1.6037409075164531E-4 NULL NULL -36 0.0 36 1 89011 +8662 37 0.0 -1.603555760794274E-4 NULL NULL -37 0.0 37 1 89011 +8675 50 0.0 -1.6011527377521613E-4 NULL NULL -50 0.0 50 1 89011 +8676 51 0.0 -1.6009681881051175E-4 NULL NULL -51 0.0 51 1 89011 +8683 58 0.0 -1.5996775308073247E-4 NULL NULL -58 0.0 58 1 89011 +8692 67 0.0 -1.5980211688909341E-4 NULL NULL -67 0.0 67 1 89011 +8693 68 0.0 -1.5978373403888185E-4 NULL NULL -68 0.0 68 1 89011 +8695 70 0.0 -1.5974698102357677E-4 NULL NULL -70 0.0 70 1 89011 +8703 3 0.0 -1.5960013788348846E-4 NULL NULL -3 0.0 3 1 89011 +8704 4 0.0 -1.5958180147058825E-4 NULL NULL -4 0.0 4 1 89011 +8709 9 0.0 -1.5949018256975544E-4 NULL NULL -9 0.0 9 1 89011 +8726 26 0.0 -1.5917946367178547E-4 NULL NULL -26 0.0 26 1 89011 +8740 40 0.0 -1.5892448512585812E-4 NULL NULL -40 0.0 40 1 89011 +8742 42 0.0 -1.5888812628689087E-4 NULL NULL -42 0.0 42 1 89011 +8744 44 0.0 -1.5885178408051235E-4 NULL NULL -44 0.0 44 1 89011 +8745 45 0.0 -1.588336192109777E-4 NULL NULL -45 0.0 45 1 89011 +8748 48 0.0 -1.5877914951989026E-4 NULL NULL -48 0.0 48 1 89011 +8757 57 0.0 -1.5861596437136006E-4 NULL NULL -57 0.0 57 1 89011 +8762 62 0.0 -1.585254508103173E-4 NULL NULL -62 0.0 62 1 89011 +8781 6 0.0 -1.5818243935770415E-4 NULL NULL -6 0.0 6 1 89011 +8784 9 0.0 -1.5812841530054645E-4 NULL NULL -9 0.0 9 1 89011 +8785 10 0.0 -1.5811041548093342E-4 NULL NULL -10 0.0 10 1 89011 +8790 15 0.0 -1.5802047781569967E-4 NULL NULL -15 0.0 15 1 89011 +8793 18 0.0 -1.5796656431252132E-4 NULL NULL -18 0.0 18 1 89011 +8804 29 0.0 -1.577691958200818E-4 NULL NULL -29 0.0 29 1 89011 +8827 52 0.0 -1.5735810581171407E-4 NULL NULL -52 0.0 52 1 89011 +8837 62 0.0 -1.5718003847459545E-4 NULL NULL -62 0.0 62 1 89011 +8841 66 0.0 -1.5710892432982694E-4 NULL NULL -66 0.0 66 1 89011 +8852 2 0.0 -1.569136918210574E-4 NULL NULL -2 0.0 2 1 89011 +8854 4 0.0 -1.568782471199458E-4 NULL NULL -4 0.0 4 1 89011 +8868 18 0.0 -1.5663058186738836E-4 NULL NULL -18 0.0 18 1 89011 +8875 25 0.0 -1.5650704225352114E-4 NULL NULL -25 0.0 25 1 89011 +8876 26 0.0 -1.5648940964398377E-4 NULL NULL -26 0.0 26 1 89011 +8882 32 0.0 -1.5638369736545822E-4 NULL NULL -32 0.0 32 1 89011 +8884 34 0.0 -1.5634849167041874E-4 NULL NULL -34 0.0 34 1 89011 +8896 46 0.0 -1.5613758992805756E-4 NULL NULL -46 289.0 46 2 89012 +8941 16 0.0 -1.5535175036349402E-4 NULL NULL -16 0.0 16 1 89011 +8950 25 0.0 -1.5519553072625698E-4 NULL NULL -25 0.0 25 1 89011 +8983 58 0.0 -1.5462540354002003E-4 NULL NULL -58 0.0 58 1 89011 +8986 61 0.0 -1.5457378143779213E-4 NULL NULL -61 0.0 61 1 89011 +9001 1 0.0 -1.543161870903233E-4 NULL NULL -1 0.0 1 1 89011 +9011 11 0.0 -1.541449339695927E-4 NULL NULL -11 0.0 11 1 89011 +9050 50 0.0 -1.534806629834254E-4 NULL NULL -50 0.0 50 1 89011 +9052 52 0.0 -1.5344675209898366E-4 NULL NULL -52 0.0 52 1 89011 +9059 59 0.0 -1.5332818191853405E-4 NULL NULL -59 0.0 59 1 89011 +9063 63 0.0 -1.5326050976497847E-4 NULL NULL -63 0.0 63 1 89011 +9100 25 0.0 -1.5263736263736264E-4 NULL NULL -25 0.0 25 1 89011 +9107 32 0.0 -1.5252003953003185E-4 NULL NULL -32 0.0 32 1 89011 +9111 36 0.0 -1.5245307869608167E-4 NULL NULL -36 0.0 36 1 89011 +9128 53 0.0 -1.5216914986853638E-4 NULL NULL -53 0.0 53 1 89011 +9140 65 0.0 -1.5196936542669586E-4 NULL NULL -65 0.0 65 1 89011 +9161 11 0.0 -1.516210020740094E-4 NULL NULL -11 0.0 11 1 89011 +9168 18 0.0 -1.5150523560209425E-4 NULL NULL -18 0.0 18 1 89011 +9169 19 0.0 -1.514887119642273E-4 NULL NULL -19 0.0 19 1 89011 +9182 32 0.0 -1.5127423219342192E-4 NULL NULL -32 0.0 32 1 89011 +9210 60 0.0 -1.50814332247557E-4 NULL NULL -60 0.0 60 1 89011 +9227 2 0.0 -1.5053646905819877E-4 NULL NULL -2 0.0 2 1 89011 +9235 10 0.0 -1.5040606388738495E-4 NULL NULL -10 0.0 10 1 89011 +9237 12 0.0 -1.5037349788892497E-4 NULL NULL -12 0.0 12 1 89011 +9238 13 0.0 -1.503572201775276E-4 NULL NULL -13 0.0 13 1 89011 +9243 18 0.0 -1.5027588445309963E-4 NULL NULL -18 0.0 18 1 89011 +9292 67 0.0 -1.4948342660352993E-4 NULL NULL -67 0.0 67 1 89011 +9304 4 0.0 -1.4929062768701633E-4 NULL NULL -4 0.0 4 1 89011 +9315 15 0.0 -1.4911433172302738E-4 NULL NULL -15 0.0 15 1 89011 +9351 51 0.0 -1.4854026307346808E-4 NULL NULL -51 0.0 51 1 89011 +9353 53 0.0 -1.4850849994654122E-4 NULL NULL -53 0.0 53 1 89011 +9360 60 0.0 -1.4839743589743589E-4 NULL NULL -60 0.0 60 1 89011 +9364 64 0.0 -1.4833404527979496E-4 NULL NULL -64 0.0 64 1 89011 +9365 65 0.0 -1.4831820608649226E-4 NULL NULL -65 0.0 65 1 89011 +9366 66 0.0 -1.4830237027546446E-4 NULL NULL -66 0.0 66 1 89011 +9373 73 0.0 -1.481916142110317E-4 NULL NULL -73 0.0 73 1 89011 +9388 13 0.0 -1.4795483596080102E-4 NULL NULL -13 0.0 13 1 89011 +9390 15 0.0 -1.4792332268370606E-4 NULL NULL -15 0.0 15 1 89011 +9393 18 0.0 -1.4787607793037368E-4 NULL NULL -18 0.0 18 1 89011 +9395 20 0.0 -1.4784459819052687E-4 NULL NULL -20 0.0 20 1 89011 +9402 27 0.0 -1.477345245692406E-4 NULL NULL -27 0.0 27 1 89011 +9404 29 0.0 -1.477031050616759E-4 NULL NULL -29 0.0 29 1 89011 +9426 51 0.0 -1.4735837046467217E-4 NULL NULL -51 0.0 51 1 89011 +9433 58 0.0 -1.472490193999788E-4 NULL NULL -58 1024.0 58 2 89012 +9442 67 0.0 -1.471086634187672E-4 NULL NULL -67 0.0 67 1 89011 +9444 69 0.0 -1.4707750952986024E-4 NULL NULL -69 0.0 69 1 89011 +9447 72 0.0 -1.470308034296602E-4 NULL NULL -72 0.0 72 1 89011 +9452 2 0.0 -1.469530258146424E-4 NULL NULL -2 16.0 2 2 89012 +9455 5 0.0 -1.4690639873083026E-4 NULL NULL -5 0.0 5 1 89011 +9472 22 0.0 -1.4664273648648648E-4 NULL NULL -22 0.0 22 1 89011 +9476 26 0.0 -1.465808357956944E-4 NULL NULL -26 0.0 26 1 89011 +9498 48 0.0 -1.4624131396083386E-4 NULL NULL -48 0.0 48 1 89011 +9510 60 0.0 -1.4605678233438487E-4 NULL NULL -60 0.0 60 1 89011 +9512 62 0.0 -1.4602607232968882E-4 NULL NULL -62 0.0 62 1 89011 +9539 14 0.0 -1.4561274766747038E-4 NULL NULL -14 2704.0 14 2 89012 +9556 31 0.0 -1.4535370447886145E-4 NULL NULL -31 0.0 31 1 89011 +9561 36 0.0 -1.452776906181362E-4 NULL NULL -36 0.0 36 1 89011 +9583 58 0.0 -1.4494417197119899E-4 NULL NULL -58 0.0 58 1 89011 +9597 72 0.0 -1.4473272897780557E-4 NULL NULL -72 0.0 72 1 89011 +9642 42 0.0 -1.4405724953329185E-4 NULL NULL -42 0.0 42 1 89011 +9644 44 0.0 -1.4402737453338865E-4 NULL NULL -44 0.0 44 1 89011 +9650 50 0.0 -1.439378238341969E-4 NULL NULL -50 0.0 50 1 89011 +9659 59 0.0 -1.4380370638782483E-4 NULL NULL -59 0.0 59 1 89011 +9682 7 0.0 -1.4346209460855197E-4 NULL NULL -7 0.0 7 1 89011 +9719 44 0.0 -1.4291593785368864E-4 NULL NULL -44 0.0 44 1 89011 +9720 45 0.0 -1.4290123456790123E-4 NULL NULL -45 0.0 45 1 89011 +9723 48 0.0 -1.4285714285714287E-4 NULL NULL -48 0.0 48 1 89011 +9740 65 0.0 -1.4260780287474333E-4 NULL NULL -65 0.0 65 1 89011 +9752 2 0.0 -1.4243232157506154E-4 NULL NULL -2 0.0 2 1 89011 +9759 9 0.0 -1.4233015677835844E-4 NULL NULL -9 0.0 9 1 89011 +9761 11 0.0 -1.423009937506403E-4 NULL NULL -11 0.0 11 1 89011 +9767 17 0.0 -1.4221357632845295E-4 NULL NULL -17 0.0 17 1 89011 +9782 32 0.0 -1.419955019423431E-4 NULL NULL -32 0.0 32 1 89011 +9786 36 0.0 -1.4193746167995096E-4 NULL NULL -36 0.0 36 1 89011 +9791 41 0.0 -1.4186497804105812E-4 NULL NULL -41 0.0 41 1 89011 +9792 42 0.0 -1.4185049019607842E-4 NULL NULL -42 0.0 42 1 89011 +9801 51 0.0 -1.4172023262932354E-4 NULL NULL -51 0.0 51 1 89011 +9802 52 0.0 -1.4170577433176903E-4 NULL NULL -52 0.0 52 1 89011 +9828 3 0.0 -1.4133089133089134E-4 NULL NULL -3 0.0 3 1 89011 +9842 17 0.0 -1.4112985165616745E-4 NULL NULL -17 0.0 17 1 89011 +9857 32 0.0 -1.409150857258801E-4 NULL NULL -32 0.0 32 1 89011 +9883 58 0.0 -1.4054436911868865E-4 NULL NULL -58 0.0 58 1 89011 +9892 67 0.0 -1.4041649818034776E-4 NULL NULL -67 0.0 67 1 89011 +9907 7 0.0 -1.4020389623498535E-4 NULL NULL -7 0.0 7 1 89011 +9922 22 0.0 -1.3999193710945374E-4 NULL NULL -22 0.0 22 1 89011 +9924 24 0.0 -1.3996372430471584E-4 NULL NULL -24 0.0 24 1 89011 +9925 25 0.0 -1.3994962216624685E-4 NULL NULL -25 0.0 25 1 89011 +9926 26 0.0 -1.399355228692323E-4 NULL NULL -26 0.0 26 1 89011 +9929 29 0.0 -1.3989324201833014E-4 NULL NULL -29 0.0 29 1 89011 +9930 30 0.0 -1.3987915407854984E-4 NULL NULL -30 0.0 30 1 89011 +9934 34 0.0 -1.3982283068250453E-4 NULL NULL -34 0.0 34 1 89011 +9951 51 0.0 -1.3958396141091348E-4 NULL NULL -51 0.0 51 1 89011 +9969 69 0.0 -1.393319289798375E-4 NULL NULL -69 0.0 69 1 89011 +9971 71 0.0 -1.3930398154648481E-4 NULL NULL -71 0.0 71 1 89011 +9987 12 0.0 -1.3908080504656053E-4 NULL NULL -12 0.0 12 1 89011 +10036 61 0.0 -1.384017536867278E-4 NULL NULL -61 0.0 61 1 89011 +10044 69 0.0 -1.382915173237754E-4 NULL NULL -69 0.0 69 1 89011 +10058 8 0.0 -1.380990256512229E-4 NULL NULL -8 0.0 8 1 89011 +10065 15 0.0 -1.3800298062593145E-4 NULL NULL -15 0.0 15 1 89011 +10077 27 0.0 -1.3783864245311105E-4 NULL NULL -27 0.0 27 1 89011 +10096 46 0.0 -1.3757923930269415E-4 NULL NULL -46 0.0 46 1 89011 +10097 47 0.0 -1.3756561354857878E-4 NULL NULL -47 0.0 47 1 89011 +10104 54 0.0 -1.3747030878859858E-4 NULL NULL -54 0.0 54 1 89011 +10120 70 0.0 -1.3725296442687748E-4 NULL NULL -70 0.0 70 1 89011 +10129 4 0.0 -1.3713100997136932E-4 NULL NULL -4 0.0 4 1 89011 +10131 6 0.0 -1.3710393840687E-4 NULL NULL -6 0.0 6 1 89011 +10139 14 0.0 -1.3699575895058684E-4 NULL NULL -14 0.0 14 1 89011 +10149 24 0.0 -1.3686077446053798E-4 NULL NULL -24 0.0 24 1 89011 +10174 49 0.0 -1.365244741497936E-4 NULL NULL -49 0.0 49 1 89011 +10187 62 0.0 -1.3635025031903406E-4 NULL NULL -62 0.0 62 1 89011 +10198 73 0.0 -1.3620317709354775E-4 NULL NULL -73 0.0 73 1 89011 +10205 5 0.0 -1.3610975012248898E-4 NULL NULL -5 0.0 5 1 89011 +10211 11 0.0 -1.3602977181470963E-4 NULL NULL -11 0.0 11 1 89011 +10227 27 0.0 -1.3581695511880317E-4 NULL NULL -27 0.0 27 1 89011 +10230 30 0.0 -1.3577712609970675E-4 NULL NULL -30 0.0 30 1 89011 +10242 42 0.0 -1.3561804335090802E-4 NULL NULL -42 0.0 42 1 89011 +10273 73 0.0 -1.3520879976637788E-4 NULL NULL -73 0.0 73 1 89011 +10284 9 0.0 -1.3506417736289383E-4 NULL NULL -9 0.0 9 1 89011 +10285 10 0.0 -1.35051045211473E-4 NULL NULL -10 0.0 10 1 89011 +10295 20 0.0 -1.3491986401165614E-4 NULL NULL -20 0.0 20 1 89011 +10304 29 0.0 -1.3480201863354038E-4 NULL NULL -29 0.0 29 1 89011 +10310 35 0.0 -1.3472356935014548E-4 NULL NULL -35 0.0 35 1 89011 +10312 37 0.0 -1.3469743987587276E-4 NULL NULL -37 0.0 37 1 89011 +10321 46 0.0 -1.3457998255982947E-4 NULL NULL -46 0.0 46 1 89011 +10346 71 0.0 -1.3425478445776146E-4 NULL NULL -71 0.0 71 1 89011 +10364 14 0.0 -1.3402161327672713E-4 NULL NULL -14 0.0 14 1 89011 +10383 33 0.0 -1.3377636521236637E-4 NULL NULL -33 0.0 33 1 89011 +10394 44 0.0 -1.336347893015201E-4 NULL NULL -44 900.0 44 2 89012 +10401 51 0.0 -1.335448514565907E-4 NULL NULL -51 0.0 51 1 89011 +10403 53 0.0 -1.3351917716043448E-4 NULL NULL -53 0.0 53 1 89011 +10415 65 0.0 -1.3336533845415268E-4 NULL NULL -65 0.0 65 1 89011 +10436 11 0.0 -1.3309697201993102E-4 NULL NULL -11 0.0 11 1 89011 +10451 26 0.0 -1.3290594201511818E-4 NULL NULL -26 0.0 26 1 89011 +10452 27 0.0 -1.3289322617680827E-4 NULL NULL -27 0.0 27 1 89011 +10467 42 0.0 -1.3270278016623674E-4 NULL NULL -42 0.0 42 1 89011 +10470 45 0.0 -1.326647564469914E-4 NULL NULL -45 812.25 45 2 89012 +10484 59 0.0 -1.324876001526135E-4 NULL NULL -59 0.0 59 1 89011 +10485 60 0.0 -1.3247496423462088E-4 NULL NULL -60 1600.0 60 2 89012 +10495 70 0.0 -1.323487374940448E-4 NULL NULL -70 0.0 70 1 89011 +10496 71 0.0 -1.323361280487805E-4 NULL NULL -71 12.25 71 2 89012 +10520 20 0.0 -1.320342205323194E-4 NULL NULL -20 0.0 20 1 89011 +10522 22 0.0 -1.320091237407337E-4 NULL NULL -22 0.0 22 1 89011 +10528 28 0.0 -1.319338905775076E-4 NULL NULL -28 0.0 28 1 89011 +10532 32 0.0 -1.3188378275731105E-4 NULL NULL -32 0.0 32 1 89011 +10538 38 0.0 -1.3180869235148986E-4 NULL NULL -38 0.0 38 1 89011 +10548 48 0.0 -1.3168373151308305E-4 NULL NULL -48 0.0 48 1 89011 +10551 51 0.0 -1.3164628945123684E-4 NULL NULL -51 0.0 51 1 89011 +10553 53 0.0 -1.3162133990334503E-4 NULL NULL -53 0.0 53 1 89011 +10554 54 0.0 -1.3160886867538373E-4 NULL NULL -54 0.0 54 1 89011 +10558 58 0.0 -1.3155900738776282E-4 NULL NULL -58 0.0 58 1 89011 +10576 1 0.0 -1.3133509833585476E-4 NULL NULL -1 0.0 1 1 89011 +10592 17 0.0 -1.3113670694864048E-4 NULL NULL -17 0.0 17 1 89011 +10601 26 0.0 -1.3102537496462597E-4 NULL NULL -26 0.0 26 1 89011 +10637 62 0.0 -1.3058193099558147E-4 NULL NULL -62 0.0 62 1 89011 +10649 74 0.0 -1.3043478260869564E-4 NULL NULL -74 0.0 74 1 89011 +10652 2 0.0 -1.303980473150582E-4 NULL NULL -2 0.0 2 1 89011 +10653 3 0.0 -1.303858068149817E-4 NULL NULL -3 0.0 3 1 89011 +10663 13 0.0 -1.3026352808778017E-4 NULL NULL -13 0.0 13 1 89011 +10666 16 0.0 -1.3022688918057379E-4 NULL NULL -16 0.0 16 1 89011 +10672 22 0.0 -1.301536731634183E-4 NULL NULL -22 0.0 22 1 89011 +10688 38 0.0 -1.2995883233532935E-4 NULL NULL -38 0.0 38 1 89011 +10701 51 0.0 -1.298009531819456E-4 NULL NULL -51 0.0 51 1 89011 +10713 63 0.0 -1.2965555866704004E-4 NULL NULL -63 0.0 63 1 89011 +10723 73 0.0 -1.295346451552737E-4 NULL NULL -73 0.0 73 1 89011 +10725 0 0.0 -1.2951048951048951E-4 NULL NULL 0 0.0 0 1 89011 +10770 45 0.0 -1.2896935933147632E-4 NULL NULL -45 0.0 45 1 89011 +10785 60 0.0 -1.2878998609179416E-4 NULL NULL -60 0.0 60 1 89011 +10802 2 0.0 -1.2858729864839846E-4 NULL NULL -2 0.0 2 1 89011 +10807 7 0.0 -1.285278060516332E-4 NULL NULL -7 0.0 7 1 89011 +10827 27 0.0 -1.282903851482405E-4 NULL NULL -27 0.0 27 1 89011 +10845 45 0.0 -1.280774550484094E-4 NULL NULL -45 0.0 45 1 89011 +10858 58 0.0 -1.2792411125437465E-4 NULL NULL -58 0.0 58 1 89011 +10861 61 0.0 -1.2788877635576835E-4 NULL NULL -61 0.0 61 1 89011 +10867 67 0.0 -1.2781816508696052E-4 NULL NULL -67 0.0 67 1 89011 +10871 71 0.0 -1.2777113421028424E-4 NULL NULL -71 0.0 71 1 89011 +10903 28 0.0 -1.2739612950564064E-4 NULL NULL -28 0.0 28 1 89011 +10907 32 0.0 -1.2734940863665537E-4 NULL NULL -32 0.0 32 1 89011 +10912 37 0.0 -1.2729105571847508E-4 NULL NULL -37 0.0 37 1 89011 +10921 46 0.0 -1.2718615511400055E-4 NULL NULL -46 0.0 46 1 89011 +10922 47 0.0 -1.2717451016297382E-4 NULL NULL -47 0.0 47 1 89011 +10952 2 0.0 -1.2682615047479912E-4 NULL NULL -2 0.0 2 1 89011 +10953 3 0.0 -1.2681457135031498E-4 NULL NULL -3 0.0 3 1 89011 +11014 64 0.0 -1.2611222080987833E-4 NULL NULL -64 0.0 64 1 89011 +11022 72 0.0 -1.2602068590092543E-4 NULL NULL -72 0.0 72 1 89011 +11028 3 0.0 -1.2595212187159957E-4 NULL NULL -3 0.0 3 1 89011 +11044 19 0.0 -1.2576964867801521E-4 NULL NULL -19 0.0 19 1 89011 +11049 24 0.0 -1.2571273418408906E-4 NULL NULL -24 0.0 24 1 89011 +11054 29 0.0 -1.2565587117785418E-4 NULL NULL -29 0.0 29 1 89011 +11059 34 0.0 -1.2559905958947463E-4 NULL NULL -34 0.0 34 1 89011 +11065 40 0.0 -1.2553095345684592E-4 NULL NULL -40 0.0 40 1 89011 +11080 55 0.0 -1.253610108303249E-4 NULL NULL -55 0.0 55 1 89011 +11081 56 0.0 -1.2534969768071474E-4 NULL NULL -56 0.0 56 1 89011 +11083 58 0.0 -1.2532707750609041E-4 NULL NULL -58 0.0 58 1 89011 +11092 67 0.0 -1.2522538766678688E-4 NULL NULL -67 0.0 67 1 89011 +11097 72 0.0 -1.2516896458502299E-4 NULL NULL -72 0.0 72 1 89011 +11102 2 0.0 -1.2511259232570707E-4 NULL NULL -2 0.0 2 1 89011 +11112 12 0.0 -1.25E-4 NULL NULL -12 0.0 12 1 89011 +11148 48 0.0 -1.2459634015069966E-4 NULL NULL -48 0.0 48 1 89011 +11150 50 0.0 -1.2457399103139015E-4 NULL NULL -50 64.0 50 2 89012 +11165 65 0.0 -1.2440662785490373E-4 NULL NULL -65 0.0 65 1 89011 +11168 68 0.0 -1.2437320916905444E-4 NULL NULL -68 0.0 68 1 89011 +11181 6 0.0 -1.2422860209283606E-4 NULL NULL -6 0.0 6 1 89011 +11189 14 0.0 -1.2413978014121012E-4 NULL NULL -14 0.0 14 1 89011 +11197 22 0.0 -1.2405108511208358E-4 NULL NULL -22 0.0 22 1 89011 +11214 39 0.0 -1.2386302835741038E-4 NULL NULL -39 0.0 39 1 89011 +11230 55 0.0 -1.2368655387355297E-4 NULL NULL -55 0.0 55 1 89011 +11231 56 0.0 -1.2367554091354286E-4 NULL NULL -56 0.0 56 1 89011 +11236 61 0.0 -1.2362050551797794E-4 NULL NULL -61 0.0 61 1 89011 +11242 67 0.0 -1.235545276641167E-4 NULL NULL -67 0.0 67 1 89011 +11246 71 0.0 -1.2351058154010314E-4 NULL NULL -71 0.0 71 1 89011 +11286 36 0.0 -1.230728335991494E-4 NULL NULL -36 0.0 36 1 89011 +11302 52 0.0 -1.2289860201734207E-4 NULL NULL -52 0.0 52 1 89011 +11319 69 0.0 -1.2271402067320434E-4 NULL NULL -69 0.0 69 1 89011 +11333 8 0.0 -1.225624283067149E-4 NULL NULL -8 0.0 8 1 89011 +11334 9 0.0 -1.2255161461090523E-4 NULL NULL -9 0.0 9 1 89011 +11342 17 0.0 -1.224651736907071E-4 NULL NULL -17 0.0 17 1 89011 +11343 18 0.0 -1.2245437714890242E-4 NULL NULL -18 0.0 18 1 89011 +11350 25 0.0 -1.2237885462555067E-4 NULL NULL -25 0.0 25 1 89011 +11357 32 0.0 -1.22303425200317E-4 NULL NULL -32 0.0 32 1 89011 +11359 34 0.0 -1.222818910115327E-4 NULL NULL -34 0.0 34 1 89011 +11391 66 0.0 -1.2193837239926257E-4 NULL NULL -66 0.0 66 1 89011 +11394 69 0.0 -1.2190626645602949E-4 NULL NULL -69 0.0 69 1 89011 +11401 1 0.0 -1.2183141829664064E-4 NULL NULL -1 0.0 1 1 89011 +11411 11 0.0 -1.2172465165191482E-4 NULL NULL -11 0.0 11 1 89011 +11419 19 0.0 -1.2163937297486645E-4 NULL NULL -19 0.0 19 1 89011 +11443 43 0.0 -1.2138425238136852E-4 NULL NULL -43 0.0 43 1 89011 +11449 49 0.0 -1.213206393571491E-4 NULL NULL -49 0.0 49 1 89011 +11457 57 0.0 -1.2123592563498298E-4 NULL NULL -57 0.0 57 1 89011 +11459 59 0.0 -1.2121476568636007E-4 NULL NULL -59 0.0 59 1 89011 +11476 1 0.0 -1.2103520390379924E-4 NULL NULL -1 0.0 1 1 89011 +11494 19 0.0 -1.208456586044893E-4 NULL NULL -19 0.0 19 1 89011 +11505 30 0.0 -1.2073011734028684E-4 NULL NULL -30 0.0 30 1 89011 +11511 36 0.0 -1.2066718790721918E-4 NULL NULL -36 0.0 36 1 89011 +11515 40 0.0 -1.206252713851498E-4 NULL NULL -40 0.0 40 1 89011 +11528 53 0.0 -1.2048924358084663E-4 NULL NULL -53 0.0 53 1 89011 +11534 59 0.0 -1.2042656493844287E-4 NULL NULL -59 0.0 59 1 89011 +11561 11 0.0 -1.2014531614912205E-4 NULL NULL -11 0.0 11 1 89011 +11565 15 0.0 -1.2010376134889754E-4 NULL NULL -15 0.0 15 1 89011 +11579 29 0.0 -1.1995854564297434E-4 NULL NULL -29 0.0 29 1 89011 +11583 33 0.0 -1.1991711991711992E-4 NULL NULL -33 0.0 33 1 89011 +11595 45 0.0 -1.1979301423027167E-4 NULL NULL -45 0.0 45 1 89011 +11598 48 0.0 -1.1976202793585102E-4 NULL NULL -48 0.0 48 1 89011 +11625 0 0.0 -1.1948387096774193E-4 NULL NULL 0 0.0 0 1 89011 +11632 7 0.0 -1.1941196698762036E-4 NULL NULL -7 0.0 7 1 89011 +11641 16 0.0 -1.193196460785156E-4 NULL NULL -16 0.0 16 1 89011 +11642 17 0.0 -1.1930939701082288E-4 NULL NULL -17 0.0 17 1 89011 +11654 29 0.0 -1.1918654539214004E-4 NULL NULL -29 0.0 29 1 89011 +11658 33 0.0 -1.1914565105506949E-4 NULL NULL -33 0.0 33 1 89011 +11668 43 0.0 -1.1904353788138499E-4 NULL NULL -43 0.0 43 1 89011 +11673 48 0.0 -1.1899254690310974E-4 NULL NULL -48 0.0 48 1 89011 +11675 50 0.0 -1.1897216274089935E-4 NULL NULL -50 0.0 50 1 89011 +11681 56 0.0 -1.1891105213594727E-4 NULL NULL -56 0.0 56 1 89011 +11737 37 0.0 -1.1834369941211553E-4 NULL NULL -37 0.0 37 1 89011 +11758 58 0.0 -1.1813233543119579E-4 NULL NULL -58 0.0 58 1 89011 +11767 67 0.0 -1.1804198181354636E-4 NULL NULL -67 0.0 67 1 89011 +11771 71 0.0 -1.1800186900008496E-4 NULL NULL -71 0.0 71 1 89011 +11794 19 0.0 -1.1777174834661693E-4 NULL NULL -19 0.0 19 1 89011 +11811 36 0.0 -1.176022352044704E-4 NULL NULL -36 0.0 36 1 89011 +11833 58 0.0 -1.1738358827009211E-4 NULL NULL -58 0.0 58 1 89011 +11841 66 0.0 -1.1730428173296175E-4 NULL NULL -66 0.0 66 1 89011 +11847 72 0.0 -1.1724487211952393E-4 NULL NULL -72 100.0 72 2 89012 +11867 17 0.0 -1.1704727395297885E-4 NULL NULL -17 0.0 17 1 89011 +11883 33 0.0 -1.168896743246655E-4 NULL NULL -33 1406.25 33 2 89012 +11886 36 0.0 -1.1686017163048965E-4 NULL NULL -36 0.0 36 1 89011 +11913 63 0.0 -1.1659531604129942E-4 NULL NULL -63 0.0 63 1 89011 +11932 7 0.0 -1.1640965471002346E-4 NULL NULL -7 0.0 7 1 89011 +11935 10 0.0 -1.1638039379974864E-4 NULL NULL -10 0.0 10 1 89011 +11936 11 0.0 -1.1637064343163539E-4 NULL NULL -11 0.0 11 1 89011 +11952 27 0.0 -1.1621485943775101E-4 NULL NULL -27 0.0 27 1 89011 +11953 28 0.0 -1.1620513678574417E-4 NULL NULL -28 0.0 28 1 89011 +11977 52 0.0 -1.1597228020372381E-4 NULL NULL -52 0.0 52 1 89011 +11979 54 0.0 -1.1595291760581017E-4 NULL NULL -54 0.0 54 1 89011 +11996 71 0.0 -1.1578859619873292E-4 NULL NULL -71 0.0 71 1 89011 +12024 24 0.0 -1.1551896207584831E-4 NULL NULL -24 0.0 24 1 89011 +12034 34 0.0 -1.1542296825660629E-4 NULL NULL -34 0.0 34 1 89011 +12050 50 0.0 -1.1526970954356847E-4 NULL NULL -50 0.0 50 1 89011 +12059 59 0.0 -1.1518368023882577E-4 NULL NULL -59 0.0 59 1 89011 +12060 60 0.0 -1.1517412935323383E-4 NULL NULL -60 0.0 60 1 89011 +12078 3 0.0 -1.1500248385494287E-4 NULL NULL -3 0.0 3 1 89011 +12081 6 0.0 -1.1497392599950335E-4 NULL NULL -6 0.0 6 1 89011 +12104 29 0.0 -1.1475545274289491E-4 NULL NULL -29 0.0 29 1 89011 +12112 37 0.0 -1.1467965653896962E-4 NULL NULL -37 0.0 37 1 89011 +12136 61 0.0 -1.1445286750164798E-4 NULL NULL -61 0.0 61 1 89011 +12141 66 0.0 -1.1440573264146281E-4 NULL NULL -66 0.0 66 1 89011 +12157 7 0.0 -1.1425516163527185E-4 NULL NULL -7 0.0 7 1 89011 +12161 11 0.0 -1.1421758079105337E-4 NULL NULL -11 0.0 11 1 89011 +12170 20 0.0 -1.1413311421528348E-4 NULL NULL -20 0.0 20 1 89011 +12176 26 0.0 -1.1407687253613667E-4 NULL NULL -26 0.0 26 1 89011 +12181 31 0.0 -1.1403004679418767E-4 NULL NULL -31 0.0 31 1 89011 +12183 33 0.0 -1.1401132725929574E-4 NULL NULL -33 1482.25 33 2 89012 +12200 50 0.0 -1.1385245901639344E-4 NULL NULL -50 0.0 50 1 89011 +12208 58 0.0 -1.1377785058977719E-4 NULL NULL -58 0.0 58 1 89011 +12227 2 0.0 -1.1360104686349881E-4 NULL NULL -2 0.0 2 1 89011 +12230 5 0.0 -1.1357318070318888E-4 NULL NULL -5 0.0 5 1 89011 +12235 10 0.0 -1.1352676747037188E-4 NULL NULL -10 0.0 10 1 89011 +12269 44 0.0 -1.1321216073029587E-4 NULL NULL -44 0.0 44 1 89011 +12272 47 0.0 -1.1318448500651891E-4 NULL NULL -47 0.0 47 1 89011 +12273 48 0.0 -1.131752627719384E-4 NULL NULL -48 0.0 48 1 89011 +12291 66 0.0 -1.1300951916036124E-4 NULL NULL -66 272.25 66 2 89012 +12292 67 0.0 -1.13000325414904E-4 NULL NULL -67 0.0 67 1 89011 +12322 22 0.0 -1.127252069469242E-4 NULL NULL -22 0.0 22 1 89011 +12339 39 0.0 -1.1256990031607099E-4 NULL NULL -39 1892.25 39 2 89012 +12348 48 0.0 -1.1248785228377065E-4 NULL NULL -48 0.0 48 1 89011 +12353 53 0.0 -1.1244232170322999E-4 NULL NULL -53 0.0 53 1 89011 +12363 63 0.0 -1.1235137102644989E-4 NULL NULL -63 0.0 63 1 89011 +12375 0 0.0 -1.1224242424242424E-4 NULL NULL 0 0.0 0 1 89011 +12400 25 0.0 -1.1201612903225807E-4 NULL NULL -25 0.0 25 1 89011 +12403 28 0.0 -1.1198903491090865E-4 NULL NULL -28 0.0 28 1 89011 +12417 42 0.0 -1.1186276878473061E-4 NULL NULL -42 0.0 42 1 89011 +12420 45 0.0 -1.1183574879227053E-4 NULL NULL -45 0.0 45 1 89011 +12422 47 0.0 -1.1181774271453872E-4 NULL NULL -47 0.0 47 1 89011 +12470 20 0.0 -1.1138732959101844E-4 NULL NULL -20 0.0 20 1 89011 +12473 23 0.0 -1.1136053876372965E-4 NULL NULL -23 0.0 23 1 89011 +12477 27 0.0 -1.1132483770137052E-4 NULL NULL -27 0.0 27 1 89011 +12494 44 0.0 -1.1117336321434288E-4 NULL NULL -44 0.0 44 1 89011 +12520 70 0.0 -1.1094249201277955E-4 NULL NULL -70 0.0 70 1 89011 +12525 0 0.0 -1.1089820359281437E-4 NULL NULL 0 0.0 0 1 89011 +12526 1 0.0 -1.1088935015168449E-4 NULL NULL -1 0.0 1 1 89011 +12529 4 0.0 -1.1086279830792561E-4 NULL NULL -4 0.0 4 1 89011 +12531 6 0.0 -1.1084510414172851E-4 NULL NULL -6 0.0 6 1 89011 +12550 25 0.0 -1.1067729083665338E-4 NULL NULL -25 0.0 25 1 89011 +12554 29 0.0 -1.1064202644575435E-4 NULL NULL -29 0.0 29 1 89011 +12557 32 0.0 -1.1061559289639245E-4 NULL NULL -32 0.0 32 1 89011 +12560 35 0.0 -1.1058917197452229E-4 NULL NULL -35 0.0 35 1 89011 +12563 38 0.0 -1.1056276367109768E-4 NULL NULL -38 0.0 38 1 89011 +12574 49 0.0 -1.104660410370606E-4 NULL NULL -49 0.0 49 1 89011 +12581 56 0.0 -1.1040457833240601E-4 NULL NULL -56 0.0 56 1 89011 +12593 68 0.0 -1.1029937266735488E-4 NULL NULL -68 0.0 68 1 89011 +12613 13 0.0 -1.101244747482756E-4 NULL NULL -13 0.0 13 1 89011 +12641 41 0.0 -1.0988054742504549E-4 NULL NULL -41 0.0 41 1 89011 +12643 43 0.0 -1.0986316538796172E-4 NULL NULL -43 0.0 43 1 89011 +12652 52 0.0 -1.0978501422699968E-4 NULL NULL -52 0.0 52 1 89011 +12660 60 0.0 -1.0971563981042654E-4 NULL NULL -60 0.0 60 1 89011 +12665 65 0.0 -1.0967232530596132E-4 NULL NULL -65 0.0 65 1 89011 +12734 59 0.0 -1.0907805874038009E-4 NULL NULL -59 0.0 59 1 89011 +12746 71 0.0 -1.089753648203358E-4 NULL NULL -71 0.0 71 1 89011 +12750 0 0.0 -1.0894117647058824E-4 NULL NULL 0 0.0 0 1 89011 +12752 2 0.0 -1.0892409033877039E-4 NULL NULL -2 0.0 2 1 89011 +12772 22 0.0 -1.0875352333228939E-4 NULL NULL -22 0.0 22 1 89011 +12778 28 0.0 -1.0870245734856785E-4 NULL NULL -28 0.0 28 1 89011 +12781 31 0.0 -1.0867694233628042E-4 NULL NULL -31 169.0 31 2 89012 +12849 24 0.0 -1.0810179780527668E-4 NULL NULL -24 0.0 24 1 89011 +12857 32 0.0 -1.080345337170413E-4 NULL NULL -32 0.0 32 1 89011 +12870 45 0.0 -1.0792540792540792E-4 NULL NULL -45 0.0 45 1 89011 +12880 55 0.0 -1.078416149068323E-4 NULL NULL -55 0.0 55 1 89011 +12901 1 0.0 -1.0766607239748857E-4 NULL NULL -1 0.0 1 1 89011 +12905 5 0.0 -1.0763270050368074E-4 NULL NULL -5 0.0 5 1 89011 +12918 18 0.0 -1.075243845796563E-4 NULL NULL -18 0.0 18 1 89011 +12935 35 0.0 -1.0738306919211443E-4 NULL NULL -35 0.0 35 1 89011 +12936 36 0.0 -1.073747680890538E-4 NULL NULL -36 0.0 36 1 89011 +12940 40 0.0 -1.0734157650695519E-4 NULL NULL -40 0.0 40 1 89011 +13008 33 0.0 -1.0678044280442804E-4 NULL NULL -33 0.0 33 1 89011 +13023 48 0.0 -1.0665745219995393E-4 NULL NULL -48 0.0 48 1 89011 +13026 51 0.0 -1.0663288807001381E-4 NULL NULL -51 0.0 51 1 89011 +13062 12 0.0 -1.0633899862195683E-4 NULL NULL -12 0.0 12 1 89011 +13071 21 0.0 -1.062657792058756E-4 NULL NULL -21 0.0 21 1 89011 +13074 24 0.0 -1.0624139513538321E-4 NULL NULL -24 0.0 24 1 89011 +13078 28 0.0 -1.0620890044349289E-4 NULL NULL -28 0.0 28 1 89011 +13087 37 0.0 -1.0613586001375411E-4 NULL NULL -37 0.0 37 1 89011 +13092 42 0.0 -1.0609532538955087E-4 NULL NULL -42 0.0 42 1 89011 +13093 43 0.0 -1.0608722217979074E-4 NULL NULL -43 0.0 43 1 89011 +13117 67 0.0 -1.0589311580391858E-4 NULL NULL -67 0.0 67 1 89011 +13132 7 0.0 -1.057721596101127E-4 NULL NULL -7 0.0 7 1 89011 +13144 19 0.0 -1.0567559342665856E-4 NULL NULL -19 0.0 19 1 89011 +13153 28 0.0 -1.0560328442180491E-4 NULL NULL -28 0.0 28 1 89011 +13164 39 0.0 -1.0551504102096627E-4 NULL NULL -39 0.0 39 1 89011 +13169 44 0.0 -1.0547497911762472E-4 NULL NULL -44 0.0 44 1 89011 +13192 67 0.0 -1.052910855063675E-4 NULL NULL -67 0.0 67 1 89011 +13209 9 0.0 -1.0515557574381104E-4 NULL NULL -9 0.0 9 1 89011 +13221 21 0.0 -1.0506013160880418E-4 NULL NULL -21 0.0 21 1 89011 +13232 32 0.0 -1.0497279322853688E-4 NULL NULL -32 0.0 32 1 89011 +13253 53 0.0 -1.0480645891496266E-4 NULL NULL -53 0.0 53 1 89011 +13259 59 0.0 -1.0475903160117655E-4 NULL NULL -59 0.0 59 1 89011 +13271 71 0.0 -1.0466430562881471E-4 NULL NULL -71 0.0 71 1 89011 +13300 25 0.0 -1.044360902255639E-4 NULL NULL -25 0.0 25 1 89011 +13338 63 0.0 -1.0413855150697256E-4 NULL NULL -63 0.0 63 1 89011 +13347 72 0.0 -1.0406832996178917E-4 NULL NULL -72 0.0 72 1 89011 +13350 0 0.0 -1.0404494382022472E-4 NULL NULL 0 0.0 0 1 89011 +13352 2 0.0 -1.0402935889754344E-4 NULL NULL -2 0.0 2 1 89011 +13374 24 0.0 -1.0385823239120682E-4 NULL NULL -24 0.0 24 1 89011 +13383 33 0.0 -1.0378838825375477E-4 NULL NULL -33 2916.0 33 2 89012 +13387 37 0.0 -1.0375737655934862E-4 NULL NULL -37 0.0 37 1 89011 +13396 46 0.0 -1.0368766796058525E-4 NULL NULL -46 0.0 46 1 89011 +13404 54 0.0 -1.0362578334825425E-4 NULL NULL -54 0.0 54 1 89011 +13411 61 0.0 -1.035716948773395E-4 NULL NULL -61 0.0 61 1 89011 +13422 72 0.0 -1.0348681269557443E-4 NULL NULL -72 0.0 72 1 89011 +13436 11 0.0 -1.0337898183983328E-4 NULL NULL -11 0.0 11 1 89011 +13438 13 0.0 -1.0336359577318054E-4 NULL NULL -13 0.0 13 1 89011 +13439 14 0.0 -1.0335590445717688E-4 NULL NULL -14 0.0 14 1 89011 +13455 30 0.0 -1.032329988851728E-4 NULL NULL -30 0.0 30 1 89011 +13495 70 0.0 -1.0292701000370507E-4 NULL NULL -70 0.0 70 1 89011 +13539 39 0.0 -1.0259251052514956E-4 NULL NULL -39 0.0 39 1 89011 +13567 67 0.0 -1.0238077688508882E-4 NULL NULL -67 0.0 67 1 89011 +13589 14 0.0 -1.0221502685996026E-4 NULL NULL -14 0.0 14 1 89011 +13605 30 0.0 -1.0209481808158765E-4 NULL NULL -30 0.0 30 1 89011 +13612 37 0.0 -1.0204231560387894E-4 NULL NULL -37 0.0 37 1 89011 +13613 38 0.0 -1.0203481965768015E-4 NULL NULL -38 0.0 38 1 89011 +13638 63 0.0 -1.0184777826660801E-4 NULL NULL -63 0.0 63 1 89011 +13677 27 0.0 -1.0155735906997149E-4 NULL NULL -27 0.0 27 1 89011 +13678 28 0.0 -1.0154993420090656E-4 NULL NULL -28 0.0 28 1 89011 +13680 30 0.0 -1.0153508771929825E-4 NULL NULL -30 0.0 30 1 89011 +13684 34 0.0 -1.0150540777550424E-4 NULL NULL -34 0.0 34 1 89011 +13686 36 0.0 -1.0149057430951338E-4 NULL NULL -36 0.0 36 1 89011 +13701 51 0.0 -1.013794613531859E-4 NULL NULL -51 0.0 51 1 89011 +13710 60 0.0 -1.0131291028446389E-4 NULL NULL -60 0.0 60 1 89011 +13717 67 0.0 -1.0126120871910768E-4 NULL NULL -67 0.0 67 1 89011 +13720 70 0.0 -1.0123906705539358E-4 NULL NULL -70 0.0 70 1 89011 +13741 16 0.0 -1.010843461174587E-4 NULL NULL -16 625.0 16 2 89012 +13748 23 0.0 -1.0103287750945592E-4 NULL NULL -23 0.0 23 1 89011 +13752 27 0.0 -1.0100349040139616E-4 NULL NULL -27 0.0 27 1 89011 +13783 58 0.0 -1.0077631865341363E-4 NULL NULL -58 0.0 58 1 89011 +13800 0 0.0 -1.0065217391304348E-4 NULL NULL 0 0.0 0 1 89011 +13801 1 0.0 -1.0064488080573871E-4 NULL NULL -1 0.0 1 1 89011 +13802 2 0.0 -1.0063758875525286E-4 NULL NULL -2 0.0 2 1 89011 +13825 25 0.0 -1.0047016274864376E-4 NULL NULL -25 0.0 25 1 89011 +13833 33 0.0 -1.0041205812188246E-4 NULL NULL -33 0.0 33 1 89011 +13835 35 0.0 -1.0039754246476329E-4 NULL NULL -35 0.0 35 1 89011 +13893 18 0.0 -9.997840639170806E-5 NULL NULL -18 0.0 18 1 89011 +13909 34 0.0 -9.986339779998562E-5 NULL NULL -34 0.0 34 1 89011 +13941 66 0.0 -9.96341725844631E-5 NULL NULL -66 0.0 66 1 89011 +13947 72 0.0 -9.9591309959131E-5 NULL NULL -72 0.0 72 1 89011 +13953 3 0.0 -9.954848419694689E-5 NULL NULL -3 2162.25 3 2 89012 +13958 8 0.0 -9.951282418684626E-5 NULL NULL -8 0.0 8 1 89011 +13978 28 0.0 -9.937043926169695E-5 NULL NULL -28 0.0 28 1 89011 +13987 37 0.0 -9.930649889182813E-5 NULL NULL -37 0.0 37 1 89011 +13994 44 0.0 -9.925682435329427E-5 NULL NULL -44 0.0 44 1 89011 +14011 61 0.0 -9.91363928342017E-5 NULL NULL -61 0.0 61 1 89011 +14040 15 0.0 -9.893162393162393E-5 NULL NULL -15 0.0 15 1 89011 +14043 18 0.0 -9.89104892117069E-5 NULL NULL -18 0.0 18 1 89011 +14071 46 0.0 -9.871366640608343E-5 NULL NULL -46 0.0 46 1 89011 +14072 47 0.0 -9.87066515065378E-5 NULL NULL -47 0.0 47 1 89011 +14073 48 0.0 -9.86996376039224E-5 NULL NULL -48 0.0 48 1 89011 +14076 51 0.0 -9.867860187553282E-5 NULL NULL -51 0.0 51 1 89011 +14084 59 0.0 -9.862255041181483E-5 NULL NULL -59 0.0 59 1 89011 +14111 11 0.0 -9.843384593579477E-5 NULL NULL -11 0.0 11 1 89011 +14118 18 0.0 -9.838504037399065E-5 NULL NULL -18 0.0 18 1 89011 +14120 20 0.0 -9.837110481586402E-5 NULL NULL -20 0.0 20 1 89011 +14127 27 0.0 -9.832236143554896E-5 NULL NULL -27 0.0 27 1 89011 +14133 33 0.0 -9.828061982593929E-5 NULL NULL -33 0.0 33 1 89011 +14143 43 0.0 -9.821112918051333E-5 NULL NULL -43 0.0 43 1 89011 +14152 52 0.0 -9.814867156585641E-5 NULL NULL -52 0.0 52 1 89011 +14154 54 0.0 -9.813480288257736E-5 NULL NULL -54 0.0 54 1 89011 +14159 59 0.0 -9.810014831555901E-5 NULL NULL -59 0.0 59 1 89011 +14172 72 0.0 -9.801016088060965E-5 NULL NULL -72 0.0 72 1 89011 +14191 16 0.0 -9.78789373546614E-5 NULL NULL -16 0.0 16 1 89011 +14195 20 0.0 -9.785135611130679E-5 NULL NULL -20 0.0 20 1 89011 +14225 50 0.0 -9.764499121265377E-5 NULL NULL -50 0.0 50 1 89011 +14239 64 0.0 -9.754898518154365E-5 NULL NULL -64 0.0 64 1 89011 +14241 66 0.0 -9.753528544343796E-5 NULL NULL -66 0.0 66 1 89011 +14247 72 0.0 -9.749420930722258E-5 NULL NULL -72 0.0 72 1 89011 +14282 32 0.0 -9.725528637445735E-5 NULL NULL -32 0.0 32 1 89011 +14318 68 0.0 -9.701075569213577E-5 NULL NULL -68 0.0 68 1 89011 +14341 16 0.0 -9.685517049020292E-5 NULL NULL -16 0.0 16 1 89011 +14343 18 0.0 -9.684166492365614E-5 NULL NULL -18 0.0 18 1 89011 +14347 22 0.0 -9.681466508677772E-5 NULL NULL -22 0.0 22 1 89011 +14349 24 0.0 -9.68011708132971E-5 NULL NULL -24 0.0 24 1 89011 +14370 45 0.0 -9.665970772442588E-5 NULL NULL -45 0.0 45 1 89011 +14388 63 0.0 -9.653878231859883E-5 NULL NULL -63 0.0 63 1 89011 +14404 4 0.0 -9.643154679255763E-5 NULL NULL -4 0.0 4 1 89011 +14410 10 0.0 -9.639139486467731E-5 NULL NULL -10 0.0 10 1 89011 +14436 36 0.0 -9.621778886118039E-5 NULL NULL -36 0.0 36 1 89011 +14517 42 0.0 -9.5680925811118E-5 NULL NULL -42 0.0 42 1 89011 +14524 49 0.0 -9.563481134673643E-5 NULL NULL -49 0.0 49 1 89011 +14530 55 0.0 -9.559532002752925E-5 NULL NULL -55 0.0 55 1 89011 +14536 61 0.0 -9.55558613098514E-5 NULL NULL -61 0.0 61 1 89011 +14547 72 0.0 -9.548360486698288E-5 NULL NULL -72 0.0 72 1 89011 +14548 73 0.0 -9.54770415177344E-5 NULL NULL -73 0.0 73 1 89011 +14562 12 0.0 -9.53852492789452E-5 NULL NULL -12 0.0 12 1 89011 +14567 17 0.0 -9.53525090959017E-5 NULL NULL -17 0.0 17 1 89011 +14569 19 0.0 -9.533941931498387E-5 NULL NULL -19 0.0 19 1 89011 +14582 32 0.0 -9.525442326155534E-5 NULL NULL -32 0.0 32 1 89011 +14605 55 0.0 -9.510441629578912E-5 NULL NULL -55 0.0 55 1 89011 +14609 59 0.0 -9.507837634334998E-5 NULL NULL -59 0.0 59 1 89011 +14625 0 0.0 -9.497435897435898E-5 NULL NULL 0 0.0 0 1 89011 +14626 1 0.0 -9.496786544509778E-5 NULL NULL -1 0.0 1 1 89011 +14662 37 0.0 -9.47346883099168E-5 NULL NULL -37 0.0 37 1 89011 +14685 60 0.0 -9.458631256384066E-5 NULL NULL -60 0.0 60 1 89011 +14689 64 0.0 -9.456055551773435E-5 NULL NULL -64 0.0 64 1 89011 +14694 69 0.0 -9.452837893017558E-5 NULL NULL -69 3025.0 69 2 89012 +14709 9 0.0 -9.443198042015093E-5 NULL NULL -9 0.0 9 1 89011 +14744 44 0.0 -9.42078133478025E-5 NULL NULL -44 0.0 44 1 89011 +14751 51 0.0 -9.416310758592637E-5 NULL NULL -51 0.0 51 1 89011 +14761 61 0.0 -9.40993157645146E-5 NULL NULL -61 0.0 61 1 89011 +14778 3 0.0 -9.399106780349168E-5 NULL NULL -3 0.0 3 1 89011 +14785 10 0.0 -9.39465674670274E-5 NULL NULL -10 0.0 10 1 89011 +14806 31 0.0 -9.381331892476024E-5 NULL NULL -31 0.0 31 1 89011 +14809 34 0.0 -9.379431426835033E-5 NULL NULL -34 0.0 34 1 89011 +14821 46 0.0 -9.371837257944809E-5 NULL NULL -46 0.0 46 1 89011 +14822 47 0.0 -9.371204965591688E-5 NULL NULL -47 0.0 47 1 89011 +14848 73 0.0 -9.35479525862069E-5 NULL NULL -73 0.0 73 1 89011 +14854 4 0.0 -9.351016561195638E-5 NULL NULL -4 0.0 4 1 89011 +14872 22 0.0 -9.339698762775686E-5 NULL NULL -22 0.0 22 1 89011 +14889 39 0.0 -9.329034857948821E-5 NULL NULL -39 0.0 39 1 89011 +14899 49 0.0 -9.32277334049265E-5 NULL NULL -49 0.0 49 1 89011 +14900 50 0.0 -9.322147651006712E-5 NULL NULL -50 0.0 50 1 89011 +14907 57 0.0 -9.317770175085531E-5 NULL NULL -57 225.0 57 2 89012 +14909 59 0.0 -9.316520222684285E-5 NULL NULL -59 0.0 59 1 89011 +14921 71 0.0 -9.309027545070706E-5 NULL NULL -71 0.0 71 1 89011 +14933 8 0.0 -9.30154690952923E-5 NULL NULL -8 0.0 8 1 89011 +14965 40 0.0 -9.281657200133645E-5 NULL NULL -40 0.0 40 1 89011 +14966 41 0.0 -9.281037017239075E-5 NULL NULL -41 0.0 41 1 89011 +14974 49 0.0 -9.276078536129291E-5 NULL NULL -49 0.0 49 1 89011 +14985 60 0.0 -9.269269269269269E-5 NULL NULL -60 36.0 60 2 89012 +15006 6 0.0 -9.256297481007597E-5 NULL NULL -6 0.0 6 1 89011 +15007 7 0.0 -9.255680682348237E-5 NULL NULL -7 0.0 7 1 89011 +15012 12 0.0 -9.25259792166267E-5 NULL NULL -12 0.0 12 1 89011 +15013 13 0.0 -9.251981615932858E-5 NULL NULL -13 0.0 13 1 89011 +15014 14 0.0 -9.25136539230052E-5 NULL NULL -14 0.0 14 1 89011 +15035 35 0.0 -9.238443631526438E-5 NULL NULL -35 0.0 35 1 89011 +15038 38 0.0 -9.236600611783483E-5 NULL NULL -38 0.0 38 1 89011 +15061 61 0.0 -9.222495186242614E-5 NULL NULL -61 0.0 61 1 89011 +15065 65 0.0 -9.22004646531696E-5 NULL NULL -65 0.0 65 1 89011 +15071 71 0.0 -9.216375821113397E-5 NULL NULL -71 0.0 71 1 89011 +15082 7 0.0 -9.209653892056756E-5 NULL NULL -7 0.0 7 1 89011 +15091 16 0.0 -9.204161420714332E-5 NULL NULL -16 0.0 16 1 89011 +15092 17 0.0 -9.203551550490326E-5 NULL NULL -17 0.0 17 1 89011 +15101 26 0.0 -9.19806635322164E-5 NULL NULL -26 0.0 26 1 89011 +15103 28 0.0 -9.196848308283122E-5 NULL NULL -28 0.0 28 1 89011 +15111 36 0.0 -9.19197935278936E-5 NULL NULL -36 0.0 36 1 89011 +15112 37 0.0 -9.191371095817894E-5 NULL NULL -37 0.0 37 1 89011 +15119 44 0.0 -9.187115549970236E-5 NULL NULL -44 0.0 44 1 89011 +15143 68 0.0 -9.172554975896454E-5 NULL NULL -68 0.0 68 1 89011 +15148 73 0.0 -9.169527330340639E-5 NULL NULL -73 0.0 73 1 89011 +15153 3 0.0 -9.166501682835082E-5 NULL NULL -3 0.0 3 1 89011 +15169 19 0.0 -9.156833014701034E-5 NULL NULL -19 0.0 19 1 89011 +15180 30 0.0 -9.150197628458498E-5 NULL NULL -30 0.0 30 1 89011 +15188 38 0.0 -9.145377929944693E-5 NULL NULL -38 0.0 38 1 89011 +15193 43 0.0 -9.142368195879682E-5 NULL NULL -43 0.0 43 1 89011 +15198 48 0.0 -9.139360442163443E-5 NULL NULL -48 0.0 48 1 89011 +15223 73 0.0 -9.124351310516981E-5 NULL NULL -73 0.0 73 1 89011 +15227 2 0.0 -9.121954423064294E-5 NULL NULL -2 0.0 2 1 89011 +15232 7 0.0 -9.118960084033614E-5 NULL NULL -7 0.0 7 1 89011 +15234 9 0.0 -9.117762898779047E-5 NULL NULL -9 0.0 9 1 89011 +15242 17 0.0 -9.112977299566986E-5 NULL NULL -17 400.0 17 2 89012 +15254 29 0.0 -9.105808312573752E-5 NULL NULL -29 0.0 29 1 89011 +15275 50 0.0 -9.09328968903437E-5 NULL NULL -50 0.0 50 1 89011 +15277 52 0.0 -9.092099234142829E-5 NULL NULL -52 0.0 52 1 89011 +15278 53 0.0 -9.091504123576385E-5 NULL NULL -53 0.0 53 1 89011 +15296 71 0.0 -9.080805439330544E-5 NULL NULL -71 0.0 71 1 89011 +15298 73 0.0 -9.079618250751732E-5 NULL NULL -73 0.0 73 1 89011 +15313 13 0.0 -9.070724221249919E-5 NULL NULL -13 0.0 13 1 89011 +15324 24 0.0 -9.064212999216915E-5 NULL NULL -24 0.0 24 1 89011 +15325 25 0.0 -9.063621533442089E-5 NULL NULL -25 0.0 25 1 89011 +15328 28 0.0 -9.061847599164927E-5 NULL NULL -28 0.0 28 1 89011 +15340 40 0.0 -9.054758800521513E-5 NULL NULL -40 0.0 40 1 89011 +15369 69 0.0 -9.037673238336912E-5 NULL NULL -69 0.0 69 1 89011 +15375 0 0.0 -9.034146341463415E-5 NULL NULL 0 0.0 0 1 89011 +15401 26 0.0 -9.018894876956042E-5 NULL NULL -26 0.0 26 1 89011 +15416 41 0.0 -9.010119356512714E-5 NULL NULL -41 0.0 41 1 89011 +15417 42 0.0 -9.009534928974509E-5 NULL NULL -42 0.0 42 1 89011 +15423 48 0.0 -9.006029955261622E-5 NULL NULL -48 0.0 48 1 89011 +15429 54 0.0 -9.002527707563679E-5 NULL NULL -54 0.0 54 1 89011 +15436 61 0.0 -8.998445193055195E-5 NULL NULL -61 0.0 61 1 89011 +15443 68 0.0 -8.994366379589458E-5 NULL NULL -68 0.0 68 1 89011 +15456 6 0.0 -8.986801242236025E-5 NULL NULL -6 0.0 6 1 89011 +15509 59 0.0 -8.956090012250952E-5 NULL NULL -59 0.0 59 1 89011 +15512 62 0.0 -8.95435791645178E-5 NULL NULL -62 0.0 62 1 89011 +15516 66 0.0 -8.952049497293117E-5 NULL NULL -66 0.0 66 1 89011 +15523 73 0.0 -8.948012626425304E-5 NULL NULL -73 0.0 73 1 89011 +15541 16 0.0 -8.937648799948523E-5 NULL NULL -16 0.0 16 1 89011 +15545 20 0.0 -8.93534898681248E-5 NULL NULL -20 0.0 20 1 89011 +15548 23 0.0 -8.933624903524569E-5 NULL NULL -23 0.0 23 1 89011 +15549 24 0.0 -8.933050356936138E-5 NULL NULL -24 0.0 24 1 89011 +15551 26 0.0 -8.93190148543502E-5 NULL NULL -26 0.0 26 1 89011 +15588 63 0.0 -8.910700538876059E-5 NULL NULL -63 0.0 63 1 89011 +15593 68 0.0 -8.907843263002629E-5 NULL NULL -68 0.0 68 1 89011 +15602 2 0.0 -8.902704781438277E-5 NULL NULL -2 0.0 2 1 89011 +15605 5 0.0 -8.900993271387376E-5 NULL NULL -5 0.0 5 1 89011 +15609 9 0.0 -8.89871228137613E-5 NULL NULL -9 0.0 9 1 89011 +15616 16 0.0 -8.894723360655738E-5 NULL NULL -16 0.0 16 1 89011 +15620 20 0.0 -8.892445582586428E-5 NULL NULL -20 0.0 20 1 89011 +15625 25 0.0 -8.8896E-5 NULL NULL -25 0.0 25 1 89011 +15626 26 0.0 -8.889031102009471E-5 NULL NULL -26 0.0 26 1 89011 +15646 46 0.0 -8.877668413652051E-5 NULL NULL -46 0.0 46 1 89011 +15655 55 0.0 -8.872564675822421E-5 NULL NULL -55 0.0 55 1 89011 +15668 68 0.0 -8.865202961450089E-5 NULL NULL -68 0.0 68 1 89011 +15678 3 0.0 -8.859548411787218E-5 NULL NULL -3 0.0 3 1 89011 +15694 19 0.0 -8.8505161208105E-5 NULL NULL -19 0.0 19 1 89011 +15699 24 0.0 -8.847697305560863E-5 NULL NULL -24 0.0 24 1 89011 +15705 30 0.0 -8.844317096466093E-5 NULL NULL -30 0.0 30 1 89011 +15707 32 0.0 -8.843190933978481E-5 NULL NULL -32 0.0 32 1 89011 +15717 42 0.0 -8.837564420690972E-5 NULL NULL -42 0.0 42 1 89011 +15726 51 0.0 -8.8325066768409E-5 NULL NULL -51 0.0 51 1 89011 +15745 70 0.0 -8.821848205779612E-5 NULL NULL -70 0.0 70 1 89011 +15749 74 0.0 -8.819607594132961E-5 NULL NULL -74 0.0 74 1 89011 +15752 2 0.0 -8.817927882173692E-5 NULL NULL -2 0.0 2 1 89011 +15754 4 0.0 -8.81680842960518E-5 NULL NULL -4 0.0 4 1 89011 +15764 14 0.0 -8.811215427556457E-5 NULL NULL -14 0.0 14 1 89011 +15769 19 0.0 -8.808421586657366E-5 NULL NULL -19 0.0 19 1 89011 +15827 2 0.0 -8.776142035761673E-5 NULL NULL -2 0.0 2 1 89011 +15841 16 0.0 -8.768385834227637E-5 NULL NULL -16 0.0 16 1 89011 +15861 36 0.0 -8.757329298278797E-5 NULL NULL -36 0.0 36 1 89011 +15890 65 0.0 -8.741346758967904E-5 NULL NULL -65 0.0 65 1 89011 +15909 9 0.0 -8.730907033754479E-5 NULL NULL -9 0.0 9 1 89011 +15921 21 0.0 -8.724326361409459E-5 NULL NULL -21 0.0 21 1 89011 +15932 32 0.0 -8.718302786844088E-5 NULL NULL -32 0.0 32 1 89011 +15933 33 0.0 -8.717755601581623E-5 NULL NULL -33 0.0 33 1 89011 +15956 56 0.0 -8.705189270493858E-5 NULL NULL -56 0.0 56 1 89011 +15958 58 0.0 -8.704098257927059E-5 NULL NULL -58 0.0 58 1 89011 +15965 65 0.0 -8.70028186658315E-5 NULL NULL -65 0.0 65 1 89011 +15969 69 0.0 -8.698102573736615E-5 NULL NULL -69 0.0 69 1 89011 +15973 73 0.0 -8.695924372378389E-5 NULL NULL -73 0.0 73 1 89011 +15985 10 0.0 -8.689396309039725E-5 NULL NULL -10 0.0 10 1 89011 +16030 55 0.0 -8.665003119151591E-5 NULL NULL -55 0.0 55 1 89011 +16036 61 0.0 -8.661761037665253E-5 NULL NULL -61 0.0 61 1 89011 +16045 70 0.0 -8.656902461826114E-5 NULL NULL -70 0.0 70 1 89011 +16055 5 0.0 -8.651510432886951E-5 NULL NULL -5 0.0 5 1 89011 +16056 6 0.0 -8.650971599402093E-5 NULL NULL -6 0.0 6 1 89011 +16069 19 0.0 -8.643972867011015E-5 NULL NULL -19 0.0 19 1 89011 +16070 20 0.0 -8.643434971997511E-5 NULL NULL -20 0.0 20 1 89011 +16096 46 0.0 -8.629473161033797E-5 NULL NULL -46 342.25 46 2 89012 +16125 0 0.0 -8.613953488372093E-5 NULL NULL 0 0.0 0 1 89011 +16127 2 0.0 -8.612885223538166E-5 NULL NULL -2 0.0 2 1 89011 +16146 21 0.0 -8.602749907097733E-5 NULL NULL -21 0.0 21 1 89011 +16165 40 0.0 -8.59263841633158E-5 NULL NULL -40 0.0 40 1 89011 +16174 49 0.0 -8.587857054531965E-5 NULL NULL -49 0.0 49 1 89011 +16178 53 0.0 -8.585733712449006E-5 NULL NULL -53 0.0 53 1 89011 +16189 64 0.0 -8.579899932052628E-5 NULL NULL -64 306.25 64 2 89012 +16191 66 0.0 -8.578840096349824E-5 NULL NULL -66 0.0 66 1 89011 +16212 12 0.0 -8.567727609178386E-5 NULL NULL -12 0.0 12 1 89011 +16219 19 0.0 -8.564029841543868E-5 NULL NULL -19 0.0 19 1 89011 +16227 27 0.0 -8.559807727860973E-5 NULL NULL -27 0.0 27 1 89011 +16228 28 0.0 -8.559280256347055E-5 NULL NULL -28 0.0 28 1 89011 +16232 32 0.0 -8.557171020206999E-5 NULL NULL -32 306.25 32 2 89012 +16238 38 0.0 -8.554009114422959E-5 NULL NULL -38 0.0 38 1 89011 +16240 40 0.0 -8.552955665024631E-5 NULL NULL -40 0.0 40 1 89011 +16270 70 0.0 -8.537185003073141E-5 NULL NULL -70 0.0 70 1 89011 +16274 74 0.0 -8.535086641268281E-5 NULL NULL -74 0.0 74 1 89011 +16276 1 0.0 -8.534037847136889E-5 NULL NULL -1 0.0 1 1 89011 +16278 3 0.0 -8.532989310726133E-5 NULL NULL -3 0.0 3 1 89011 +16279 4 0.0 -8.53246513913631E-5 NULL NULL -4 0.0 4 1 89011 +16280 5 0.0 -8.531941031941033E-5 NULL NULL -5 0.0 5 1 89011 +16282 7 0.0 -8.530893010686648E-5 NULL NULL -7 0.0 7 1 89011 +16285 10 0.0 -8.529321461467609E-5 NULL NULL -10 0.0 10 1 89011 +16298 23 0.0 -8.522518100380415E-5 NULL NULL -23 0.0 23 1 89011 +16319 44 0.0 -8.511550952877014E-5 NULL NULL -44 0.0 44 1 89011 +16337 62 0.0 -8.502172981575565E-5 NULL NULL -62 0.0 62 1 89011 +16338 63 0.0 -8.501652589056188E-5 NULL NULL -63 0.0 63 1 89011 +16352 2 0.0 -8.494373776908023E-5 NULL NULL -2 0.0 2 1 89011 +16368 18 0.0 -8.486070381231672E-5 NULL NULL -18 0.0 18 1 89011 +16370 20 0.0 -8.485033598045205E-5 NULL NULL -20 0.0 20 1 89011 +WARNING: Comparing a bigint and a double may result in a loss of precision. +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- TargetTypeClasses: Long, Double, Timestamp +-- Functions: Var, Count, Sum, VarP, StDevP +-- ArithmeticOps: Multiply, Add, Subtract, Remainder +-- FilterOps: GreaterThan, LessThan, Equal, LessThanOrEqual, GreaterThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Long, Double, Timestamp +-- Functions: Var, Count, Sum, VarP, StDevP +-- ArithmeticOps: Multiply, Add, Subtract, Remainder +-- FilterOps: GreaterThan, LessThan, Equal, LessThanOrEqual, GreaterThanOrEqual +-- GroupBy: GroupBy +EXPLAIN SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL cdouble)) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (* 2563.58 (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble)))) (TOK_SELEXPR (- (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble)))) (TOK_SELEXPR (TOK_FUNCTION COUNT (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (+ (* 2563.58 (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble))) (- 5638.15))) (TOK_SELEXPR (* (- (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble))) (+ (* 2563.58 (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble))) (- 5638.15)))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (- (TOK_TABLE_OR_COL cdouble) (- (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble))))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (+ (TOK_TABLE_OR_COL cdouble) (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cdouble)))) (TOK_SELEXPR (* (TOK_TABLE_OR_COL cdouble) 762)) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (% (- 863.257) (* (TOK_TABLE_OR_COL cdouble) 762))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cdouble)))) (TOK_WHERE (AND (> (TOK_TABLE_OR_COL cdouble) 2563.58) (OR (OR (AND (>= (TOK_TABLE_OR_COL cbigint) (TOK_TABLE_OR_COL cint)) (AND (< (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL cint)) (< (TOK_TABLE_OR_COL cfloat) (- 5638.15)))) (= 2563.58 (TOK_TABLE_OR_COL ctinyint))) (AND (<= (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cbigint)) (> (- 5638.15) (TOK_TABLE_OR_COL cbigint)))))) (TOK_GROUPBY (TOK_TABLE_OR_COL cdouble)) (TOK_ORDERBY (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cdouble))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((cdouble > 2563.58) and ((((cbigint >= cint) and ((csmallint < cint) and (cfloat < (- 5638.15)))) or false) or ((cdouble <= cbigint) and ((- 5638.15) > cbigint)))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cdouble + type: double + expr: cfloat + type: float + outputColumnNames: cdouble, cfloat + Vectorized execution: true + Group By Operator + aggregations: + expr: var_samp(cdouble) + expr: count(cfloat) + expr: sum(cfloat) + expr: var_pop(cdouble) + expr: stddev_pop(cdouble) + expr: sum(cdouble) + bucketGroup: false + keys: + expr: cdouble + type: double + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col0 + type: double + sort order: + + Map-reduce partition columns: + expr: _col0 + type: double + tag: -1 + value expressions: + expr: _col1 + type: struct + expr: _col2 + type: bigint + expr: _col3 + type: double + expr: _col4 + type: struct + expr: _col5 + type: struct + expr: _col6 + type: double + Reduce Operator Tree: + Group By Operator + aggregations: + expr: var_samp(VALUE._col0) + expr: count(VALUE._col1) + expr: sum(VALUE._col2) + expr: var_pop(VALUE._col3) + expr: stddev_pop(VALUE._col4) + expr: sum(VALUE._col5) + bucketGroup: false + keys: + expr: KEY._col0 + type: double + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6 + Select Operator + expressions: + expr: _col0 + type: double + expr: _col1 + type: double + expr: (2563.58 * _col1) + type: double + expr: (- _col1) + type: double + expr: _col2 + type: bigint + expr: ((2563.58 * _col1) + (- 5638.15)) + type: double + expr: ((- _col1) * ((2563.58 * _col1) + (- 5638.15))) + type: double + expr: _col3 + type: double + expr: _col4 + type: double + expr: (_col0 - (- _col1)) + type: double + expr: _col5 + type: double + expr: (_col0 + _col1) + type: double + expr: (_col0 * 762) + type: double + expr: _col6 + type: double + expr: ((- 863.257) % (_col0 * 762)) + type: double + expr: _col6 + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + + Stage: Stage-2 + Map Reduce + Alias -> Map Operator Tree: +#### A masked pattern was here #### + TableScan + Reduce Output Operator + key expressions: + expr: _col0 + type: double + sort order: + + tag: -1 + value expressions: + expr: _col0 + type: double + expr: _col1 + type: double + expr: _col2 + type: double + expr: _col3 + type: double + expr: _col4 + type: bigint + expr: _col5 + type: double + expr: _col6 + type: double + expr: _col7 + type: double + expr: _col8 + type: double + expr: _col9 + type: double + expr: _col10 + type: double + expr: _col11 + type: double + expr: _col12 + type: double + expr: _col13 + type: double + expr: _col14 + type: double + expr: _col15 + type: double + Reduce Operator Tree: + Extract + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT cdouble, + VAR_SAMP(cdouble), + (2563.58 * VAR_SAMP(cdouble)), + (-(VAR_SAMP(cdouble))), + COUNT(cfloat), + ((2563.58 * VAR_SAMP(cdouble)) + -5638.15), + ((-(VAR_SAMP(cdouble))) * ((2563.58 * VAR_SAMP(cdouble)) + -5638.15)), + SUM(cfloat), + VAR_POP(cdouble), + (cdouble - (-(VAR_SAMP(cdouble)))), + STDDEV_POP(cdouble), + (cdouble + VAR_SAMP(cdouble)), + (cdouble * 762), + SUM(cdouble), + (-863.257 % (cdouble * 762)), + SUM(cdouble) +FROM alltypesorc +WHERE (((cdouble > 2563.58)) + AND (((cbigint >= cint) + AND ((csmallint < cint) + AND (cfloat < -5638.15))) + OR (2563.58 = ctinyint) + OR ((cdouble <= cbigint) + AND (-5638.15 > cbigint)))) +GROUP BY cdouble +ORDER BY cdouble +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +PREHOOK: query: -- TargetTypeClasses: Bool, Timestamp, String, Double, Long +-- Functions: StDevP, Avg, Count, Min, Var, VarP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide, Remainder +-- FilterOps: NotEqual, LessThan, Like, Equal +-- GroupBy: GroupBy +EXPLAIN SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1 +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Bool, Timestamp, String, Double, Long +-- Functions: StDevP, Avg, Count, Min, Var, VarP, Sum +-- ArithmeticOps: Multiply, Subtract, Add, Divide, Remainder +-- FilterOps: NotEqual, LessThan, Like, Equal +-- GroupBy: GroupBy +EXPLAIN SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1 +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL ctimestamp1)) (TOK_SELEXPR (TOK_TABLE_OR_COL cstring1)) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (* (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)) 10.175)) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTIONSTAR COUNT)) (TOK_SELEXPR (- (TOK_FUNCTIONSTAR COUNT))) (TOK_SELEXPR (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))))) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) (TOK_SELEXPR (- (* (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)) 10.175))) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (+ (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint)) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT))))) (TOK_SELEXPR (- (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))))) (TOK_SELEXPR (/ (- (TOK_FUNCTIONSTAR COUNT)) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (/ 10.175 (TOK_FUNCTION AVG (TOK_TABLE_OR_COL csmallint)))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (+ (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint)) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT))))) (TOK_SELEXPR (- (- (* (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)) 10.175)))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (* (- (+ (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint)) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) 10.175)) (TOK_SELEXPR (% 10.175 (/ 10.175 (TOK_FUNCTION AVG (TOK_TABLE_OR_COL csmallint))))) (TOK_SELEXPR (- (TOK_FUNCTION MIN (TOK_TABLE_OR_COL ctinyint)))) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))))) (TOK_SELEXPR (% (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (/ (- 26.28) (- (TOK_FUNCTION MIN (TOK_TABLE_OR_COL ctinyint))))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (/ (+ (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint)) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (- (- (TOK_FUNCTIONSTAR COUNT)))) (TOK_SELEXPR (TOK_FUNCTIONSTAR COUNT)) (TOK_SELEXPR (% (+ (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL csmallint)) (* (* (- (- 26.28) (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint))) (- (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL cint)))) (- (TOK_FUNCTIONSTAR COUNT)))) (- 26.28)))) (TOK_WHERE (AND (!= (TOK_TABLE_OR_COL ctimestamp1) 0) (OR (OR (OR (OR (AND (AND (!= (- 257) (TOK_TABLE_OR_COL ctinyint)) (TOK_FUNCTION TOK_ISNOTNULL (TOK_TABLE_OR_COL cboolean2))) (AND (LIKE (TOK_TABLE_OR_COL cstring1) '%ss') (< (- 10669) (TOK_TABLE_OR_COL ctimestamp1)))) (= (TOK_TABLE_OR_COL ctimestamp2) (- 10669))) (AND (< (TOK_TABLE_OR_COL ctimestamp1) 0) (LIKE (TOK_TABLE_OR_COL cstring2) '%b%'))) (= (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL cint))) (AND (TOK_FUNCTION TOK_ISNULL (TOK_TABLE_OR_COL cboolean1)) (< (TOK_TABLE_OR_COL cfloat) (TOK_TABLE_OR_COL cint)))))) (TOK_GROUPBY (TOK_TABLE_OR_COL ctimestamp1) (TOK_TABLE_OR_COL cstring1)))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: ((ctimestamp1 <> 0) and ((((((((- 257) <> ctinyint) and cboolean2 is not null) and ((cstring1 like '%ss') and ((- 10669) < ctimestamp1))) or (ctimestamp2 = (- 10669))) or ((ctimestamp1 < 0) and (cstring2 like '%b%'))) or (cdouble = cint)) or (cboolean1 is null and (cfloat < cint)))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: ctimestamp1 + type: timestamp + expr: cstring1 + type: string + expr: cint + type: int + expr: csmallint + type: smallint + expr: ctinyint + type: tinyint + expr: cfloat + type: float + expr: cdouble + type: double + outputColumnNames: ctimestamp1, cstring1, cint, csmallint, ctinyint, cfloat, cdouble + Vectorized execution: true + Group By Operator + aggregations: + expr: stddev_pop(cint) + expr: avg(csmallint) + expr: count() + expr: min(ctinyint) + expr: var_samp(csmallint) + expr: var_pop(cfloat) + expr: avg(cint) + expr: var_samp(cfloat) + expr: avg(cfloat) + expr: min(cdouble) + expr: var_pop(csmallint) + expr: stddev_pop(ctinyint) + expr: sum(cint) + bucketGroup: false + keys: + expr: ctimestamp1 + type: timestamp + expr: cstring1 + type: string + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col0 + type: timestamp + expr: _col1 + type: string + sort order: ++ + Map-reduce partition columns: + expr: _col0 + type: timestamp + expr: _col1 + type: string + tag: -1 + value expressions: + expr: _col2 + type: struct + expr: _col3 + type: struct + expr: _col4 + type: bigint + expr: _col5 + type: tinyint + expr: _col6 + type: struct + expr: _col7 + type: struct + expr: _col8 + type: struct + expr: _col9 + type: struct + expr: _col10 + type: struct + expr: _col11 + type: double + expr: _col12 + type: struct + expr: _col13 + type: struct + expr: _col14 + type: bigint + Reduce Operator Tree: + Group By Operator + aggregations: + expr: stddev_pop(VALUE._col0) + expr: avg(VALUE._col1) + expr: count(VALUE._col2) + expr: min(VALUE._col3) + expr: var_samp(VALUE._col4) + expr: var_pop(VALUE._col5) + expr: avg(VALUE._col6) + expr: var_samp(VALUE._col7) + expr: avg(VALUE._col8) + expr: min(VALUE._col9) + expr: var_pop(VALUE._col10) + expr: stddev_pop(VALUE._col11) + expr: sum(VALUE._col12) + bucketGroup: false + keys: + expr: KEY._col0 + type: timestamp + expr: KEY._col1 + type: string + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Select Operator + expressions: + expr: _col0 + type: timestamp + expr: _col1 + type: string + expr: _col2 + type: double + expr: (_col2 * 10.175) + type: double + expr: (- _col2) + type: double + expr: _col3 + type: double + expr: (- _col2) + type: double + expr: ((- 26.28) - _col2) + type: double + expr: _col4 + type: bigint + expr: (- _col4) + type: bigint + expr: (((- 26.28) - _col2) * (- _col2)) + type: double + expr: _col5 + type: tinyint + expr: ((((- 26.28) - _col2) * (- _col2)) * (- _col4)) + type: double + expr: (- (_col2 * 10.175)) + type: double + expr: _col6 + type: double + expr: (_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) + type: double + expr: (- (- _col2)) + type: double + expr: ((- _col4) / _col2) + type: double + expr: _col7 + type: double + expr: (10.175 / _col3) + type: double + expr: _col8 + type: double + expr: _col9 + type: double + expr: ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) - ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) + type: double + expr: (- (- (_col2 * 10.175))) + type: double + expr: _col10 + type: double + expr: (((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) - ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) * 10.175) + type: double + expr: (10.175 % (10.175 / _col3)) + type: double + expr: (- _col5) + type: tinyint + expr: _col11 + type: double + expr: _col12 + type: double + expr: (- (((- 26.28) - _col2) * (- _col2))) + type: double + expr: ((- _col2) % _col10) + type: double + expr: ((- 26.28) / (- _col5)) + type: double + expr: _col13 + type: double + expr: _col14 + type: bigint + expr: ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) / _col7) + type: double + expr: (- (- _col4)) + type: bigint + expr: _col4 + type: bigint + expr: ((_col6 + ((((- 26.28) - _col2) * (- _col2)) * (- _col4))) % (- 26.28)) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22, _col23, _col24, _col25, _col26, _col27, _col28, _col29, _col30, _col31, _col32, _col33, _col34, _col35, _col36, _col37, _col38 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +PREHOOK: query: SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1 +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT ctimestamp1, + cstring1, + STDDEV_POP(cint), + (STDDEV_POP(cint) * 10.175), + (-(STDDEV_POP(cint))), + AVG(csmallint), + (-(STDDEV_POP(cint))), + (-26.28 - STDDEV_POP(cint)), + COUNT(*), + (-(COUNT(*))), + ((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))), + MIN(ctinyint), + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*)))), + (-((STDDEV_POP(cint) * 10.175))), + VAR_SAMP(csmallint), + (VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-(STDDEV_POP(cint))))), + ((-(COUNT(*))) / STDDEV_POP(cint)), + VAR_POP(cfloat), + (10.175 / AVG(csmallint)), + AVG(cint), + VAR_SAMP(cfloat), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))), + (-((-((STDDEV_POP(cint) * 10.175))))), + AVG(cfloat), + (((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) - (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) * 10.175), + (10.175 % (10.175 / AVG(csmallint))), + (-(MIN(ctinyint))), + MIN(cdouble), + VAR_POP(csmallint), + (-(((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))))), + ((-(STDDEV_POP(cint))) % AVG(cfloat)), + (-26.28 / (-(MIN(ctinyint)))), + STDDEV_POP(ctinyint), + SUM(cint), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) / VAR_POP(cfloat)), + (-((-(COUNT(*))))), + COUNT(*), + ((VAR_SAMP(csmallint) + (((-26.28 - STDDEV_POP(cint)) * (-(STDDEV_POP(cint)))) * (-(COUNT(*))))) % -26.28) +FROM alltypesorc +WHERE (((ctimestamp1 != 0)) + AND ((((-257 != ctinyint) + AND (cboolean2 IS NOT NULL)) + AND ((cstring1 LIKE '%ss') + AND (-10669 < ctimestamp1))) + OR (ctimestamp2 = -10669) + OR ((ctimestamp1 < 0) + AND (cstring2 LIKE '%b%')) + OR (cdouble = cint) + OR ((cboolean1 IS NULL) + AND (cfloat < cint)))) +GROUP BY ctimestamp1, cstring1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +1969-12-31 15:59:43.773 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -24 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -24.0 NULL 0.0 24 -200.0 0.0 NULL NULL -1.095 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:43.783 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -11 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -11.0 NULL 0.0 11 -200.0 0.0 NULL NULL -2.389090909090909 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:43.874 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -8 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -8.0 NULL 0.001413979988882123 8 -7196.0 0.0 NULL NULL -3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:43.904 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 7 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 7.0 NULL 0.0 -7 -200.0 0.0 NULL NULL 3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:43.919 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -21 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -21.0 NULL 6.522017819364598E-4 21 15601.0 0.0 NULL NULL -1.2514285714285716 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:43.995 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 31 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 31.0 NULL 0.001413979988882123 -31 -7196.0 0.0 NULL NULL 0.847741935483871 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.07 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -9.0 NULL 6.522017819364598E-4 9 15601.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.081 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 61 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 61.0 NULL 0.001413979988882123 -61 -7196.0 0.0 NULL NULL 0.4308196721311476 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.179 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 34 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 34.0 NULL 6.522017819364598E-4 -34 15601.0 0.0 NULL NULL 0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.286 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 16.0 NULL 0.001413979988882123 -16 -7196.0 0.0 NULL NULL 1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.291 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -32.0 NULL 0.0 32 -200.0 0.0 NULL NULL -0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.394 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 31 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 31.0 NULL 6.522017819364598E-4 -31 15601.0 0.0 NULL NULL 0.847741935483871 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.448 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 22 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 22.0 NULL 0.0 -22 -200.0 0.0 NULL NULL 1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.455 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -25 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -25.0 NULL 0.001413979988882123 25 -7196.0 0.0 NULL NULL -1.0512000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.477 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -42 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -42.0 NULL 6.522017819364598E-4 42 15601.0 0.0 NULL NULL -0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.549 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 59 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 59.0 NULL 0.0 -59 -200.0 0.0 NULL NULL 0.44542372881355935 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.55 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 24 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 24.0 NULL 0.0 -24 -200.0 0.0 NULL NULL 1.095 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.559 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -34 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -34.0 NULL 0.0 34 -200.0 0.0 NULL NULL -0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.568 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 22 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 22.0 NULL 6.522017819364598E-4 -22 15601.0 0.0 NULL NULL 1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.571 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -42 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -42.0 NULL 6.522017819364598E-4 42 15601.0 0.0 NULL NULL -0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.646 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 54 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 54.0 NULL 0.001413979988882123 -54 -7196.0 0.0 NULL NULL 0.4866666666666667 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.708 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -22 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -22.0 NULL 6.522017819364598E-4 22 15601.0 0.0 NULL NULL -1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.782 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 7 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 7.0 NULL 6.522017819364598E-4 -7 15601.0 0.0 NULL NULL 3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:44.904 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 0 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 0.0 NULL 0.0 0 -200.0 0.0 NULL NULL -Infinity 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.137 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -32.0 NULL 0.0 32 -200.0 0.0 NULL NULL -0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.153 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 42 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 42.0 NULL 0.0 -42 -200.0 0.0 NULL NULL 0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.169 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -60 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -60.0 NULL 0.0 60 -200.0 0.0 NULL NULL -0.438 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.198 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 47 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 47.0 NULL 0.0 -47 -200.0 0.0 NULL NULL 0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.314 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 56 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 56.0 NULL 0.0 -56 -200.0 0.0 NULL NULL 0.4692857142857143 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.322 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -15 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -15.0 NULL 0.0 15 -200.0 0.0 NULL NULL -1.752 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.39 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -16.0 NULL 0.0 16 -200.0 0.0 NULL NULL -1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.427 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -7 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -7.0 NULL 0.0 7 -200.0 0.0 NULL NULL -3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.572 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 32.0 NULL 0.001413979988882123 -32 -7196.0 0.0 NULL NULL 0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.644 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -52 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -52.0 NULL 0.0 52 -200.0 0.0 NULL NULL -0.5053846153846154 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.764 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 54 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 54.0 NULL 0.001413979988882123 -54 -7196.0 0.0 NULL NULL 0.4866666666666667 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.816 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 7 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 7.0 NULL 6.522017819364598E-4 -7 15601.0 0.0 NULL NULL 3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.932 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -51 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -51.0 NULL 0.001413979988882123 51 -7196.0 0.0 NULL NULL -0.5152941176470588 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.947 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -59 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -59.0 NULL 0.001413979988882123 59 -7196.0 0.0 NULL NULL -0.44542372881355935 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:45.978 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -52 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -52.0 NULL 0.001413979988882123 52 -7196.0 0.0 NULL NULL -0.5053846153846154 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.015 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 25 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 25.0 NULL 0.001413979988882123 -25 -7196.0 0.0 NULL NULL 1.0512000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.022 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 19 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 19.0 NULL 0.0 -19 -200.0 0.0 NULL NULL 1.3831578947368421 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.114 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -3 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -3.0 NULL 6.522017819364598E-4 3 15601.0 0.0 NULL NULL -8.76 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.38 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 28 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 28.0 NULL 0.0 -28 -200.0 0.0 NULL NULL 0.9385714285714286 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.387 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 3 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 3.0 NULL 0.001413979988882123 -3 -7196.0 0.0 NULL NULL 8.76 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.52 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 8 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 8.0 NULL 0.0 -8 -200.0 0.0 NULL NULL 3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.762 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 12 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 12.0 NULL 0.0 -12 -200.0 0.0 NULL NULL 2.19 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.775 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 4 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 4.0 NULL 0.001413979988882123 -4 -7196.0 0.0 NULL NULL 6.57 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.82 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -46 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -46.0 NULL 6.522017819364598E-4 46 15601.0 0.0 NULL NULL -0.571304347826087 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.847 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -26 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -26.0 NULL 0.001413979988882123 26 -7196.0 0.0 NULL NULL -1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.915 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -25 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -25.0 NULL 0.0 25 -200.0 0.0 NULL NULL -1.0512000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.953 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 47 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 47.0 NULL 6.522017819364598E-4 -47 15601.0 0.0 NULL NULL 0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.966 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 38 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 38.0 NULL 0.001413979988882123 -38 -7196.0 0.0 NULL NULL 0.6915789473684211 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:46.978 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 32.0 NULL 0.001413979988882123 -32 -7196.0 0.0 NULL NULL 0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.031 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -7 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -7.0 NULL 0.001413979988882123 7 -7196.0 0.0 NULL NULL -3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.134 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -48 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -48.0 NULL 6.522017819364598E-4 48 15601.0 0.0 NULL NULL -0.5475 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.263 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 17 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 17.0 NULL 0.0 -17 -200.0 0.0 NULL NULL 1.5458823529411765 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.282 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 56 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 56.0 NULL 0.0 -56 -200.0 0.0 NULL NULL 0.4692857142857143 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.406 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -58 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -58.0 NULL 6.522017819364598E-4 58 15601.0 0.0 NULL NULL -0.4531034482758621 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.493 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -27.0 NULL 0.001413979988882123 27 -7196.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.511 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -55 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -55.0 NULL 6.522017819364598E-4 55 15601.0 0.0 NULL NULL -0.47781818181818186 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.616 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 39 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 39.0 NULL 6.522017819364598E-4 -39 15601.0 0.0 NULL NULL 0.6738461538461539 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.666 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 44 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 44.0 NULL 0.0 -44 -200.0 0.0 NULL NULL 0.5972727272727273 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.859 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -58 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -58.0 NULL 0.001413979988882123 58 -7196.0 0.0 NULL NULL -0.4531034482758621 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.921 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 52 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 52.0 NULL 0.0 -52 -200.0 0.0 NULL NULL 0.5053846153846154 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:47.975 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -17 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -17.0 NULL 6.522017819364598E-4 17 15601.0 0.0 NULL NULL -1.5458823529411765 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.022 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 35 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 35.0 NULL 0.001413979988882123 -35 -7196.0 0.0 NULL NULL 0.7508571428571429 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.052 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 15 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 15.0 NULL 6.522017819364598E-4 -15 15601.0 0.0 NULL NULL 1.752 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.12 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 8 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 8.0 NULL 0.001413979988882123 -8 -7196.0 0.0 NULL NULL 3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.133 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -16.0 NULL 0.0 16 -200.0 0.0 NULL NULL -1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.152 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -31 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -31.0 NULL 0.0 31 -200.0 0.0 NULL NULL -0.847741935483871 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.299 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -60 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -60.0 NULL 6.522017819364598E-4 60 15601.0 0.0 NULL NULL -0.438 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.341 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 16.0 NULL 0.0 -16 -200.0 0.0 NULL NULL 1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.429 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -23 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -23.0 NULL 6.522017819364598E-4 23 15601.0 0.0 NULL NULL -1.142608695652174 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.462 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -16.0 NULL 0.001413979988882123 16 -7196.0 0.0 NULL NULL -1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.473 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 34 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 34.0 NULL 0.0 -34 -200.0 0.0 NULL NULL 0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.499 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 26 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 26.0 NULL 0.001413979988882123 -26 -7196.0 0.0 NULL NULL 1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.552 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -42 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -42.0 NULL 6.522017819364598E-4 42 15601.0 0.0 NULL NULL -0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.622 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 19 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 19.0 NULL 0.001413979988882123 -19 -7196.0 0.0 NULL NULL 1.3831578947368421 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.663 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 26 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 26.0 NULL 0.0 -26 -200.0 0.0 NULL NULL 1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.678 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -59 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -59.0 NULL 0.0 59 -200.0 0.0 NULL NULL -0.44542372881355935 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.679 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -60 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -60.0 NULL 6.522017819364598E-4 60 15601.0 0.0 NULL NULL -0.438 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.703 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -13 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -13.0 NULL 0.001413979988882123 13 -7196.0 0.0 NULL NULL -2.0215384615384617 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.734 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 62 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 62.0 NULL 0.001413979988882123 -62 -7196.0 0.0 NULL NULL 0.4238709677419355 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.779 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -34 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -34.0 NULL 0.001413979988882123 34 -7196.0 0.0 NULL NULL -0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.929 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -12 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -12.0 NULL 0.001413979988882123 12 -7196.0 0.0 NULL NULL -2.19 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:48.943 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 11 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 11.0 NULL 6.522017819364598E-4 -11 15601.0 0.0 NULL NULL 2.389090909090909 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.021 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 2 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 2.0 NULL 0.001413979988882123 -2 -7196.0 0.0 NULL NULL 13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.051 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 15 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 15.0 NULL 0.001413979988882123 -15 -7196.0 0.0 NULL NULL 1.752 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.053 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 62 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 62.0 NULL 0.0 -62 -200.0 0.0 NULL NULL 0.4238709677419355 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.062 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 41 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 41.0 NULL 0.0 -41 -200.0 0.0 NULL NULL 0.6409756097560976 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.198 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -9.0 NULL 0.0 9 -200.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.23 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 40 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 40.0 NULL 0.001413979988882123 -40 -7196.0 0.0 NULL NULL 0.657 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.314 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -46 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -46.0 NULL 0.001413979988882123 46 -7196.0 0.0 NULL NULL -0.571304347826087 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.326 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 39 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 39.0 NULL 0.001413979988882123 -39 -7196.0 0.0 NULL NULL 0.6738461538461539 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.331 NULL NULL NULL NULL 5067.0 NULL NULL 3 -3 NULL -52 NULL NULL 8.3223867E7 NULL NULL NULL 1323.5555555555557 0.0020080915729228342 NULL 1985.3333333333335 NULL NULL -23.333333333333332 NULL 0.002008091572922567 52 -200.0 5.5482578E7 NULL NULL -0.5053846153846154 36.38070306571267 NULL NULL 3 3 NULL +1969-12-31 15:59:49.383 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -43 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -43.0 NULL 0.0 43 -200.0 0.0 NULL NULL -0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.567 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 38 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 38.0 NULL 0.0 -38 -200.0 0.0 NULL NULL 0.6915789473684211 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.762 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -43 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -43.0 NULL 0.0 43 -200.0 0.0 NULL NULL -0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:49.896 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -22 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -22.0 NULL 6.522017819364598E-4 22 15601.0 0.0 NULL NULL -1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.046 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 27.0 NULL 0.001413979988882123 -27 -7196.0 0.0 NULL NULL 0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.074 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -40 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -40.0 NULL 0.0 40 -200.0 0.0 NULL NULL -0.657 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.093 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -2 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -2.0 NULL 0.001413979988882123 2 -7196.0 0.0 NULL NULL -13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.345 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -37 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -37.0 NULL 6.522017819364598E-4 37 15601.0 0.0 NULL NULL -0.7102702702702703 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.404 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 16.0 NULL 0.001413979988882123 -16 -7196.0 0.0 NULL NULL 1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.54 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -51 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -51.0 NULL 0.001413979988882123 51 -7196.0 0.0 NULL NULL -0.5152941176470588 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.573 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -26 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -26.0 NULL 0.0 26 -200.0 0.0 NULL NULL -1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.66 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 62 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 62.0 NULL 6.522017819364598E-4 -62 15601.0 0.0 NULL NULL 0.4238709677419355 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.675 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 51 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 51.0 NULL 0.0 -51 -200.0 0.0 NULL NULL 0.5152941176470588 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.843 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -44 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -44.0 NULL 0.001413979988882123 44 -7196.0 0.0 NULL NULL -0.5972727272727273 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:50.893 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 43 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 43.0 NULL 0.0 -43 -200.0 0.0 NULL NULL 0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.009 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -49 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -49.0 NULL 0.001413979988882123 49 -7196.0 0.0 NULL NULL -0.5363265306122449 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.024 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 55 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 55.0 NULL 0.0 -55 -200.0 0.0 NULL NULL 0.47781818181818186 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.104 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 34 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 34.0 NULL 6.522017819364598E-4 -34 15601.0 0.0 NULL NULL 0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.208 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -33 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -33.0 NULL 0.001413979988882123 33 -7196.0 0.0 NULL NULL -0.7963636363636364 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.232 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 10 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 10.0 NULL 0.001413979988882123 -10 -7196.0 0.0 NULL NULL 2.628 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.265 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 59 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 59.0 NULL 6.522017819364598E-4 -59 15601.0 0.0 NULL NULL 0.44542372881355935 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.413 NULL NULL NULL NULL 7700.5 NULL NULL 2 -2 NULL -61 NULL NULL 1.248358005E8 NULL NULL NULL 90.25 0.0013213427699500034 NULL 180.5 NULL NULL -51.5 NULL 6.606713849747906E-4 61 -200.0 6.241790025E7 NULL NULL -0.4308196721311476 9.5 NULL NULL 2 2 NULL +1969-12-31 15:59:51.417 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -17 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -17.0 NULL 0.0 17 -200.0 0.0 NULL NULL -1.5458823529411765 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.555 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 49 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 49.0 NULL 0.0 -49 -200.0 0.0 NULL NULL 0.5363265306122449 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.561 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -35 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -35.0 NULL 0.001413979988882123 35 -7196.0 0.0 NULL NULL -0.7508571428571429 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.596 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -30 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -30.0 NULL 6.522017819364598E-4 30 15601.0 0.0 NULL NULL -0.876 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.637 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -8 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -8.0 NULL 6.522017819364598E-4 8 15601.0 0.0 NULL NULL -3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.719 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -47 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -47.0 NULL 0.0 47 -200.0 0.0 NULL NULL -0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.725 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 57 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 57.0 NULL 0.001413979988882123 -57 -7196.0 0.0 NULL NULL 0.4610526315789474 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.803 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 42 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 42.0 NULL 0.001413979988882123 -42 -7196.0 0.0 NULL NULL 0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.845 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -27.0 NULL 0.0 27 -200.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:51.884 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 55 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 55.0 NULL 0.0 -55 -200.0 0.0 NULL NULL 0.47781818181818186 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.052 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -49 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -49.0 NULL 0.001413979988882123 49 -7196.0 0.0 NULL NULL -0.5363265306122449 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.076 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 15 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 15.0 NULL 6.522017819364598E-4 -15 15601.0 0.0 NULL NULL 1.752 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.118 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 47 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 47.0 NULL 0.0 -47 -200.0 0.0 NULL NULL 0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.311 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 43 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 43.0 NULL 6.522017819364598E-4 -43 15601.0 0.0 NULL NULL 0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.326 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 2 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 2.0 NULL 6.522017819364598E-4 -2 15601.0 0.0 NULL NULL 13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.343 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -16.0 NULL 0.0 16 -200.0 0.0 NULL NULL -1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.357 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 55 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 55.0 NULL 6.522017819364598E-4 -55 15601.0 0.0 NULL NULL 0.47781818181818186 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.408 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -60 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -60.0 NULL 0.001413979988882123 60 -7196.0 0.0 NULL NULL -0.438 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.411 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 45 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 45.0 NULL 0.001413979988882123 -45 -7196.0 0.0 NULL NULL 0.5840000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.587 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -33 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -33.0 NULL 6.522017819364598E-4 33 15601.0 0.0 NULL NULL -0.7963636363636364 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.815 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -52 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -52.0 NULL 0.0 52 -200.0 0.0 NULL NULL -0.5053846153846154 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:52.969 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -27.0 NULL 0.001413979988882123 27 -7196.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.038 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 8 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 8.0 NULL 6.522017819364598E-4 -8 15601.0 0.0 NULL NULL 3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.06 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 34 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 34.0 NULL 0.0 -34 -200.0 0.0 NULL NULL 0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.246 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -8 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -8.0 NULL 0.0 8 -200.0 0.0 NULL NULL -3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.458 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 29 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 29.0 NULL 0.001413979988882123 -29 -7196.0 0.0 NULL NULL 0.9062068965517242 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.546 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -27.0 NULL 0.0 27 -200.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.583 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -59 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -59.0 NULL 6.522017819364598E-4 59 15601.0 0.0 NULL NULL -0.44542372881355935 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.584 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -29 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -29.0 NULL 6.522017819364598E-4 29 15601.0 0.0 NULL NULL -0.9062068965517242 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.635 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 47 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 47.0 NULL 6.522017819364598E-4 -47 15601.0 0.0 NULL NULL 0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:53.876 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 37 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 37.0 NULL 0.001413979988882123 -37 -7196.0 0.0 NULL NULL 0.7102702702702703 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.024 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 13 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 13.0 NULL 6.522017819364598E-4 -13 15601.0 0.0 NULL NULL 2.0215384615384617 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.072 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 25 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 25.0 NULL 0.0 -25 -200.0 0.0 NULL NULL 1.0512000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.116 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 62 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 62.0 NULL 6.522017819364598E-4 -62 15601.0 0.0 NULL NULL 0.4238709677419355 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.131 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -9.0 NULL 0.0 9 -200.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.179 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -18 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -18.0 NULL 0.001413979988882123 18 -7196.0 0.0 NULL NULL -1.46 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.256 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 62 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 62.0 NULL 0.001413979988882123 -62 -7196.0 0.0 NULL NULL 0.4238709677419355 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.307 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -47 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -47.0 NULL 0.001413979988882123 47 -7196.0 0.0 NULL NULL -0.5591489361702128 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.334 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 46 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 46.0 NULL 6.522017819364598E-4 -46 15601.0 0.0 NULL NULL 0.571304347826087 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.342 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 26 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 26.0 NULL 6.522017819364598E-4 -26 15601.0 0.0 NULL NULL 1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.454 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 6 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 6.0 NULL 6.522017819364598E-4 -6 15601.0 0.0 NULL NULL 4.38 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.503 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 18 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 18.0 NULL 0.001413979988882123 -18 -7196.0 0.0 NULL NULL 1.46 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.583 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -31 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -31.0 NULL 6.522017819364598E-4 31 15601.0 0.0 NULL NULL -0.847741935483871 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.63 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -29 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -29.0 NULL 0.001413979988882123 29 -7196.0 0.0 NULL NULL -0.9062068965517242 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.742 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -49 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -49.0 NULL 0.001413979988882123 49 -7196.0 0.0 NULL NULL -0.5363265306122449 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.853 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 42 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 42.0 NULL 0.001413979988882123 -42 -7196.0 0.0 NULL NULL 0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.929 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 43 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 43.0 NULL 0.0 -43 -200.0 0.0 NULL NULL 0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.934 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -33 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -33.0 NULL 0.001413979988882123 33 -7196.0 0.0 NULL NULL -0.7963636363636364 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:54.994 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -1 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -1.0 NULL 6.522017819364598E-4 1 15601.0 0.0 NULL NULL -26.28 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.043 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -16.0 NULL 0.0 16 -200.0 0.0 NULL NULL -1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.143 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -53 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -53.0 NULL 0.001413979988882123 53 -7196.0 0.0 NULL NULL -0.4958490566037736 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.204 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 30 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 30.0 NULL 0.0 -30 -200.0 0.0 NULL NULL 0.876 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.411 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -43 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -43.0 NULL 6.522017819364598E-4 43 15601.0 0.0 NULL NULL -0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.492 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 14 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 14.0 NULL 0.001413979988882123 -14 -7196.0 0.0 NULL NULL 1.8771428571428572 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.508 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 31 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 31.0 NULL 0.0 -31 -200.0 0.0 NULL NULL 0.847741935483871 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.755 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -33 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -33.0 NULL 0.0 33 -200.0 0.0 NULL NULL -0.7963636363636364 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.829 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 0 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 0.0 NULL 0.0 0 -200.0 0.0 NULL NULL -Infinity 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.847 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -9.0 NULL 6.522017819364598E-4 9 15601.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.9 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -21 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -21.0 NULL 0.001413979988882123 21 -7196.0 0.0 NULL NULL -1.2514285714285716 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.971 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 8 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 8.0 NULL 0.001413979988882123 -8 -7196.0 0.0 NULL NULL 3.285 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.989 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -6 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -6.0 NULL 6.522017819364598E-4 6 15601.0 0.0 NULL NULL -4.38 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:55.998 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -40 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -40.0 NULL 6.522017819364598E-4 40 15601.0 0.0 NULL NULL -0.657 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.068 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 46 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 46.0 NULL 6.522017819364598E-4 -46 15601.0 0.0 NULL NULL 0.571304347826087 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.109 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -21 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -21.0 NULL 0.0 21 -200.0 0.0 NULL NULL -1.2514285714285716 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.218 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -4 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -4.0 NULL 0.0 4 -200.0 0.0 NULL NULL -6.57 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.31 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 27.0 NULL 0.001413979988882123 -27 -7196.0 0.0 NULL NULL 0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.319 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -5 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -5.0 NULL 0.0 5 -200.0 0.0 NULL NULL -5.256 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.338 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -44 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -44.0 NULL 6.522017819364598E-4 44 15601.0 0.0 NULL NULL -0.5972727272727273 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.399 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 2 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 2.0 NULL 0.0 -2 -200.0 0.0 NULL NULL 13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.426 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 5 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 5.0 NULL 0.001413979988882123 -5 -7196.0 0.0 NULL NULL 5.256 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.568 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 55 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 55.0 NULL 0.001413979988882123 -55 -7196.0 0.0 NULL NULL 0.47781818181818186 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.762 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 1 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 1.0 NULL 0.0 -1 -200.0 0.0 NULL NULL 26.28 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.806 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 42 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 42.0 NULL 6.522017819364598E-4 -42 15601.0 0.0 NULL NULL 0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.858 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 38 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 38.0 NULL 6.522017819364598E-4 -38 15601.0 0.0 NULL NULL 0.6915789473684211 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.913 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 53 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 53.0 NULL 6.522017819364598E-4 -53 15601.0 0.0 NULL NULL 0.4958490566037736 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.928 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -42 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -42.0 NULL 0.001413979988882123 42 -7196.0 0.0 NULL NULL -0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:56.97 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -2 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -2.0 NULL 6.522017819364598E-4 2 15601.0 0.0 NULL NULL -13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.215 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 16 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 16.0 NULL 6.522017819364598E-4 -16 15601.0 0.0 NULL NULL 1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.245 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 16 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 16.0 NULL 0.0 -16 -200.0 0.0 NULL NULL 1.6425 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.261 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 19 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 19.0 NULL 6.522017819364598E-4 -19 15601.0 0.0 NULL NULL 1.3831578947368421 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.269 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -4 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -4.0 NULL 0.0 4 -200.0 0.0 NULL NULL -6.57 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.28 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 42 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 42.0 NULL 6.522017819364598E-4 -42 15601.0 0.0 NULL NULL 0.6257142857142858 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.386 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 1 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 1.0 NULL 6.522017819364598E-4 -1 15601.0 0.0 NULL NULL 26.28 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.447 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 53 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 53.0 NULL 0.001413979988882123 -53 -7196.0 0.0 NULL NULL 0.4958490566037736 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.524 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -61 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -61.0 NULL 6.522017819364598E-4 61 15601.0 0.0 NULL NULL -0.4308196721311476 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.604 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -41 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -41.0 NULL 0.0 41 -200.0 0.0 NULL NULL -0.6409756097560976 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.678 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -56 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -56.0 NULL 6.522017819364598E-4 56 15601.0 0.0 NULL NULL -0.4692857142857143 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.729 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 30 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 30.0 NULL 6.522017819364598E-4 -30 15601.0 0.0 NULL NULL 0.876 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.765 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -3 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -3.0 NULL 0.001413979988882123 3 -7196.0 0.0 NULL NULL -8.76 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.847 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 50 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 50.0 NULL 0.0 -50 -200.0 0.0 NULL NULL 0.5256000000000001 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.887 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -10 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -10.0 NULL 0.001413979988882123 10 -7196.0 0.0 NULL NULL -2.628 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.916 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 4 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 4.0 NULL 0.001413979988882123 -4 -7196.0 0.0 NULL NULL 6.57 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.92 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -6 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -6.0 NULL 0.001413979988882123 6 -7196.0 0.0 NULL NULL -4.38 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.932 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -43 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -43.0 NULL 6.522017819364598E-4 43 15601.0 0.0 NULL NULL -0.6111627906976744 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:57.951 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 26 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 26.0 NULL 0.0 -26 -200.0 0.0 NULL NULL 1.0107692307692309 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.061 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -9.0 NULL 0.001413979988882123 9 -7196.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.134 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -24 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -24.0 NULL 6.522017819364598E-4 24 15601.0 0.0 NULL NULL -1.095 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.158 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -53 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -53.0 NULL 0.0 53 -200.0 0.0 NULL NULL -0.4958490566037736 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.171 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -27.0 NULL 0.0 27 -200.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.214 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 22 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 22.0 NULL 0.001413979988882123 -22 -7196.0 0.0 NULL NULL 1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.272 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 7 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 7.0 NULL 0.0 -7 -200.0 0.0 NULL NULL 3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.279 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -58 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -58.0 NULL 6.522017819364598E-4 58 15601.0 0.0 NULL NULL -0.4531034482758621 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.298 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 32.0 NULL 0.0 -32 -200.0 0.0 NULL NULL 0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.343 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL -34 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL -34.0 NULL 6.522017819364598E-4 34 15601.0 0.0 NULL NULL -0.7729411764705882 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.382 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -56 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -56.0 NULL 0.001413979988882123 56 -7196.0 0.0 NULL NULL -0.4692857142857143 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.463 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -7 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -7.0 NULL 0.001413979988882123 7 -7196.0 0.0 NULL NULL -3.7542857142857144 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.561 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -17 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -17.0 NULL 0.0 17 -200.0 0.0 NULL NULL -1.5458823529411765 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.578 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -41 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -41.0 NULL 0.001413979988882123 41 -7196.0 0.0 NULL NULL -0.6409756097560976 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.752 NULL NULL NULL NULL 15601.0 NULL NULL 1 -1 NULL 36 NULL NULL 0.0 NULL NULL NULL 0.0 6.522017819370554E-4 NULL 0.0 NULL NULL 36.0 NULL 6.522017819364598E-4 -36 15601.0 0.0 NULL NULL 0.73 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.825 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL -9 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL -9.0 NULL 0.001413979988882123 9 -7196.0 0.0 NULL NULL -2.92 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.892 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -10 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -10.0 NULL 0.0 10 -200.0 0.0 NULL NULL -2.628 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.897 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -27 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -27.0 NULL 0.0 27 -200.0 0.0 NULL NULL -0.9733333333333334 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.923 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -22 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -22.0 NULL 0.0 22 -200.0 0.0 NULL NULL -1.1945454545454546 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.93 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 2 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 2.0 NULL 0.0 -2 -200.0 0.0 NULL NULL 13.14 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.957 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL 49 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL 49.0 NULL 0.0 -49 -200.0 0.0 NULL NULL 0.5363265306122449 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.962 NULL NULL NULL NULL -7196.0 NULL NULL 1 -1 NULL 32 NULL NULL 0.0 NULL NULL NULL 0.0 -0.0014139799888827128 NULL 0.0 NULL NULL 32.0 NULL 0.001413979988882123 -32 -7196.0 0.0 NULL NULL 0.82125 0.0 NULL NULL 1 1 NULL +1969-12-31 15:59:58.989 NULL NULL NULL NULL -200.0 NULL NULL 1 -1 NULL -10 NULL NULL 0.0 NULL NULL NULL 0.0 -0.050875000000000004 NULL 0.0 NULL NULL -10.0 NULL 0.0 10 -200.0 0.0 NULL NULL -2.628 0.0 NULL NULL 1 1 NULL +1969-12-31 16:00:02.351 NULL 3.430705936548119E8 3.4907432904377117E9 -3.430705936548119E8 NULL -3.430705936548119E8 -3.430706199348119E8 8 -8 1.17697441246560272E17 11 -9.4157952997248218E17 -3.4907432904377117E9 NULL NULL 3.430705936548119E8 -2.3318815858783212E-8 0.0 NULL 4.4783048325E8 0.0 NULL 3.4907432904377117E9 11.0 NULL NULL -11 NULL NULL -1.17697441246560272E17 -8.654811918735504 2.389090909090909 0.0 3582643866 NULL 8 8 NULL +1969-12-31 16:00:08.451 NULL 2.650627591471319E8 2.6970135743220673E9 -2.650627591471319E8 NULL -2.650627591471319E8 -2.650627854271319E8 9 -9 7.025827325253976E16 -51 -6.3232445927285786E17 -2.6970135743220673E9 NULL NULL 2.650627591471319E8 -3.395422287521066E-8 0.0 NULL 6.486577994444444E8 0.0 NULL 2.6970135743220673E9 -51.0 NULL NULL 51 NULL NULL -7.025827325253976E16 -0.14713189005851746 -0.5152941176470588 0.0 5837920195 NULL 9 9 NULL +1969-12-31 16:00:08.451 ss 8.6150685E7 8.765832198750001E8 -8.6150685E7 NULL -8.6150685E7 -8.615071128E7 2 -2 7.421942790009227E15 -51 -1.4843885580018454E16 -8.765832198750001E8 NULL NULL 8.6150685E7 -2.3215137523282605E-8 0.0 NULL -5.48990416E8 0.0 NULL 8.765832198750001E8 -51.0 NULL NULL 51 NULL NULL -7.421942790009227E15 -6.0 -0.5152941176470588 0.0 -1097980832 NULL 2 2 NULL +1969-12-31 16:00:15.892 NULL 3.552743011247774E8 3.61491601394461E9 -3.552743011247774E8 NULL -3.552743011247774E8 -3.5527432740477735E8 10 -10 1.26219838376307616E17 8 -1.2621983837630761E18 -3.61491601394461E9 NULL NULL 3.552743011247774E8 -2.8147265277394375E-8 0.0 NULL 6.585487822E8 0.0 NULL 3.61491601394461E9 8.0 NULL NULL -8 NULL NULL -1.26219838376307616E17 -5.124777376651764 3.285 0.0 6585487822 NULL 10 10 NULL +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: -- TargetTypeClasses: Double, Long, String, Timestamp, Bool +-- Functions: Max, Sum, Var, Avg, Min, VarP, StDev, StDevP +-- ArithmeticOps: Divide, Subtract, Remainder, Add, Multiply +-- FilterOps: GreaterThan, LessThanOrEqual, Equal, LessThan, GreaterThanOrEqual, NotEqual, Like +-- GroupBy: GroupBy +EXPLAIN SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1 +PREHOOK: type: QUERY +POSTHOOK: query: -- TargetTypeClasses: Double, Long, String, Timestamp, Bool +-- Functions: Max, Sum, Var, Avg, Min, VarP, StDev, StDevP +-- ArithmeticOps: Divide, Subtract, Remainder, Add, Multiply +-- FilterOps: GreaterThan, LessThanOrEqual, Equal, LessThan, GreaterThanOrEqual, NotEqual, Like +-- GroupBy: GroupBy +EXPLAIN SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1 +POSTHOOK: type: QUERY +ABSTRACT SYNTAX TREE: + (TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME alltypesorc))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL cboolean1)) (TOK_SELEXPR (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat))) (TOK_SELEXPR (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (/ (- 26.28) (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cbigint)) 10.175)) (TOK_SELEXPR (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (% (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint)) (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat)))) (TOK_SELEXPR (+ 10.175 (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat))))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cdouble))) (TOK_SELEXPR (+ (- (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cbigint)) 10.175) (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))) (TOK_SELEXPR (- (+ 10.175 (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat)))))) (TOK_SELEXPR (/ 79.553 (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (% (TOK_FUNCTION VAR_SAMP (TOK_TABLE_OR_COL cint)) (/ 79.553 (TOK_FUNCTION VAR_POP (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (- (+ 10.175 (- (TOK_FUNCTION MAX (TOK_TABLE_OR_COL cfloat)))))) (TOK_SELEXPR (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_SAMP (TOK_TABLE_OR_COL ctinyint))) (TOK_SELEXPR (* (- 1.389) (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cbigint)))) (TOK_SELEXPR (- (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cint)) (* (- 1.389) (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cbigint))))) (TOK_SELEXPR (TOK_FUNCTION STDDEV_POP (TOK_TABLE_OR_COL csmallint))) (TOK_SELEXPR (- (- (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cint)) (* (- 1.389) (TOK_FUNCTION MIN (TOK_TABLE_OR_COL cbigint)))))) (TOK_SELEXPR (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint))) (TOK_SELEXPR (- (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)))) (TOK_SELEXPR (* (TOK_FUNCTION AVG (TOK_TABLE_OR_COL cint)) (TOK_FUNCTION SUM (TOK_TABLE_OR_COL cint))))) (TOK_WHERE (AND (TOK_FUNCTION TOK_ISNOTNULL (TOK_TABLE_OR_COL cboolean1)) (OR (OR (OR (AND (< (TOK_TABLE_OR_COL cdouble) (TOK_TABLE_OR_COL csmallint)) (AND (= (TOK_TABLE_OR_COL cboolean2) (TOK_TABLE_OR_COL cboolean1)) (<= (TOK_TABLE_OR_COL cbigint) (- 863.257)))) (AND (>= (TOK_TABLE_OR_COL cint) (- 257)) (AND (TOK_FUNCTION TOK_ISNOTNULL (TOK_TABLE_OR_COL cstring1)) (>= (TOK_TABLE_OR_COL cboolean1) 1)))) (LIKE (TOK_TABLE_OR_COL cstring2) 'b')) (AND (>= (TOK_TABLE_OR_COL csmallint) (TOK_TABLE_OR_COL ctinyint)) (TOK_FUNCTION TOK_ISNULL (TOK_TABLE_OR_COL ctimestamp2)))))) (TOK_GROUPBY (TOK_TABLE_OR_COL cboolean1)) (TOK_ORDERBY (TOK_TABSORTCOLNAMEASC (TOK_TABLE_OR_COL cboolean1))))) + +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 is a root stage + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Alias -> Map Operator Tree: + alltypesorc + TableScan + alias: alltypesorc + Filter Operator + predicate: + expr: (cboolean1 is not null and (((((cdouble < csmallint) and ((cboolean2 = cboolean1) and (cbigint <= (- 863.257)))) or ((cint >= (- 257)) and (cstring1 is not null and (cboolean1 >= 1)))) or (cstring2 like 'b')) or ((csmallint >= ctinyint) and ctimestamp2 is null))) + type: boolean + Vectorized execution: true + Select Operator + expressions: + expr: cboolean1 + type: boolean + expr: cfloat + type: float + expr: cbigint + type: bigint + expr: cint + type: int + expr: cdouble + type: double + expr: ctinyint + type: tinyint + expr: csmallint + type: smallint + outputColumnNames: cboolean1, cfloat, cbigint, cint, cdouble, ctinyint, csmallint + Vectorized execution: true + Group By Operator + aggregations: + expr: max(cfloat) + expr: sum(cbigint) + expr: var_samp(cint) + expr: avg(cdouble) + expr: min(cbigint) + expr: var_pop(cbigint) + expr: sum(cint) + expr: stddev_samp(ctinyint) + expr: stddev_pop(csmallint) + expr: avg(cint) + bucketGroup: false + keys: + expr: cboolean1 + type: boolean + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Vectorized execution: true + Reduce Output Operator + key expressions: + expr: _col0 + type: boolean + sort order: + + Map-reduce partition columns: + expr: _col0 + type: boolean + tag: -1 + value expressions: + expr: _col1 + type: float + expr: _col2 + type: bigint + expr: _col3 + type: struct + expr: _col4 + type: struct + expr: _col5 + type: bigint + expr: _col6 + type: struct + expr: _col7 + type: bigint + expr: _col8 + type: struct + expr: _col9 + type: struct + expr: _col10 + type: struct + Reduce Operator Tree: + Group By Operator + aggregations: + expr: max(VALUE._col0) + expr: sum(VALUE._col1) + expr: var_samp(VALUE._col2) + expr: avg(VALUE._col3) + expr: min(VALUE._col4) + expr: var_pop(VALUE._col5) + expr: sum(VALUE._col6) + expr: stddev_samp(VALUE._col7) + expr: stddev_pop(VALUE._col8) + expr: avg(VALUE._col9) + bucketGroup: false + keys: + expr: KEY._col0 + type: boolean + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Select Operator + expressions: + expr: _col0 + type: boolean + expr: _col1 + type: float + expr: (- _col1) + type: float + expr: ((- 26.28) / _col1) + type: double + expr: _col2 + type: bigint + expr: (_col2 - 10.175) + type: double + expr: _col3 + type: double + expr: (_col3 % _col1) + type: double + expr: (10.175 + (- _col1)) + type: double + expr: _col4 + type: double + expr: ((_col2 - 10.175) + _col3) + type: double + expr: _col5 + type: bigint + expr: _col6 + type: double + expr: (- (10.175 + (- _col1))) + type: double + expr: (79.553 / _col6) + type: double + expr: (_col3 % (79.553 / _col6)) + type: double + expr: (- (10.175 + (- _col1))) + type: double + expr: _col7 + type: bigint + expr: _col8 + type: double + expr: ((- 1.389) * _col5) + type: double + expr: (_col7 - ((- 1.389) * _col5)) + type: double + expr: _col9 + type: double + expr: (- (_col7 - ((- 1.389) * _col5))) + type: double + expr: _col10 + type: double + expr: (- _col10) + type: double + expr: (_col10 * _col7) + type: double + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22, _col23, _col24, _col25 + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + + Stage: Stage-2 + Map Reduce + Alias -> Map Operator Tree: +#### A masked pattern was here #### + TableScan + Reduce Output Operator + key expressions: + expr: _col0 + type: boolean + sort order: + + tag: -1 + value expressions: + expr: _col0 + type: boolean + expr: _col1 + type: float + expr: _col2 + type: float + expr: _col3 + type: double + expr: _col4 + type: bigint + expr: _col5 + type: double + expr: _col6 + type: double + expr: _col7 + type: double + expr: _col8 + type: double + expr: _col9 + type: double + expr: _col10 + type: double + expr: _col11 + type: bigint + expr: _col12 + type: double + expr: _col13 + type: double + expr: _col14 + type: double + expr: _col15 + type: double + expr: _col16 + type: double + expr: _col17 + type: bigint + expr: _col18 + type: double + expr: _col19 + type: double + expr: _col20 + type: double + expr: _col21 + type: double + expr: _col22 + type: double + expr: _col23 + type: double + expr: _col24 + type: double + expr: _col25 + type: double + Reduce Operator Tree: + Extract + File Output Operator + compressed: false + GlobalTableId: 0 + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + + Stage: Stage-0 + Fetch Operator + limit: -1 + + +WARNING: Comparing a bigint and a double may result in a loss of precision. +PREHOOK: query: SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1 +PREHOOK: type: QUERY +PREHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +POSTHOOK: query: SELECT cboolean1, + MAX(cfloat), + (-(MAX(cfloat))), + (-26.28 / MAX(cfloat)), + SUM(cbigint), + (SUM(cbigint) - 10.175), + VAR_SAMP(cint), + (VAR_SAMP(cint) % MAX(cfloat)), + (10.175 + (-(MAX(cfloat)))), + AVG(cdouble), + ((SUM(cbigint) - 10.175) + VAR_SAMP(cint)), + MIN(cbigint), + VAR_POP(cbigint), + (-((10.175 + (-(MAX(cfloat)))))), + (79.553 / VAR_POP(cbigint)), + (VAR_SAMP(cint) % (79.553 / VAR_POP(cbigint))), + (-((10.175 + (-(MAX(cfloat)))))), + SUM(cint), + STDDEV_SAMP(ctinyint), + (-1.389 * MIN(cbigint)), + (SUM(cint) - (-1.389 * MIN(cbigint))), + STDDEV_POP(csmallint), + (-((SUM(cint) - (-1.389 * MIN(cbigint))))), + AVG(cint), + (-(AVG(cint))), + (AVG(cint) * SUM(cint)) +FROM alltypesorc +WHERE (((cboolean1 IS NOT NULL)) + AND (((cdouble < csmallint) + AND ((cboolean2 = cboolean1) + AND (cbigint <= -863.257))) + OR ((cint >= -257) + AND ((cstring1 IS NOT NULL) + AND (cboolean1 >= 1))) + OR (cstring2 LIKE 'b') + OR ((csmallint >= ctinyint) + AND (ctimestamp2 IS NULL)))) +GROUP BY cboolean1 +ORDER BY cboolean1 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@alltypesorc +#### A masked pattern was here #### +false 11.0 -11.0 -2.389090909090909 -6414854016 -6.414854026175E9 1.72852155777257088E17 0.0 -0.8249999999999993 -2454.8879999999995 1.72852149362403072E17 -1887561756 7.6613856013296576E17 0.8249999999999993 1.0383630865178398E-16 9.920923341934203E-17 0.8249999999999993 483940596 43.840620433565945 2.621823279084E9 -2.137882683084E9 85.79562278396777 2.137882683084E9 9.67881192E7 -9.67881192E7 4.6839700091367048E16 +true 79.553 -79.553 -0.33034580136836733 -410715229238 -4.10715229248175E11 4.9646543309484224E16 38.162330627441406 -69.3780014038086 4856.6352637899645 4.9646132594254976E16 -2130544867 2.3549376245421737E18 69.3780014038086 3.378136183775398E-17 1.7557333480922412E-17 69.3780014038086 2253537466262 34.86827631850126 2.959326820263E9 2.250578139441737E12 9461.197516216069 -2.250578139441737E12 4.8777867235108227E8 -4.8777867235108227E8 1.0992275133867002E21 diff --git ql/src/test/results/clientpositive/vectorized_rcfile_columnar.q.out ql/src/test/results/clientpositive/vectorized_rcfile_columnar.q.out new file mode 100644 index 0000000..d293770 --- /dev/null +++ ql/src/test/results/clientpositive/vectorized_rcfile_columnar.q.out @@ -0,0 +1,61 @@ +PREHOOK: query: --This query must pass even when vectorized reader is not available for +--RC files. The query must fall back to the non-vector mode and run successfully. + +CREATE table columnTable (key STRING, value STRING) +ROW FORMAT SERDE + 'org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe' +STORED AS + INPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileInputFormat' + OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileOutputFormat' +PREHOOK: type: CREATETABLE +POSTHOOK: query: --This query must pass even when vectorized reader is not available for +--RC files. The query must fall back to the non-vector mode and run successfully. + +CREATE table columnTable (key STRING, value STRING) +ROW FORMAT SERDE + 'org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe' +STORED AS + INPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileInputFormat' + OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.RCFileOutputFormat' +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: default@columnTable +PREHOOK: query: FROM src +INSERT OVERWRITE TABLE columnTable SELECT src.key, src.value LIMIT 10 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: default@columntable +POSTHOOK: query: FROM src +INSERT OVERWRITE TABLE columnTable SELECT src.key, src.value LIMIT 10 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: default@columntable +POSTHOOK: Lineage: columntable.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: columntable.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +PREHOOK: query: describe columnTable +PREHOOK: type: DESCTABLE +POSTHOOK: query: describe columnTable +POSTHOOK: type: DESCTABLE +POSTHOOK: Lineage: columntable.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: columntable.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +key string None +value string None +PREHOOK: query: SELECT key, value FROM columnTable +PREHOOK: type: QUERY +PREHOOK: Input: default@columntable +#### A masked pattern was here #### +POSTHOOK: query: SELECT key, value FROM columnTable +POSTHOOK: type: QUERY +POSTHOOK: Input: default@columntable +#### A masked pattern was here #### +POSTHOOK: Lineage: columntable.key SIMPLE [(src)src.FieldSchema(name:key, type:string, comment:default), ] +POSTHOOK: Lineage: columntable.value SIMPLE [(src)src.FieldSchema(name:value, type:string, comment:default), ] +238 val_238 +86 val_86 +311 val_311 +27 val_27 +165 val_165 +409 val_409 +255 val_255 +278 val_278 +98 val_98 +484 val_484 diff --git serde/src/java/org/apache/hadoop/hive/serde2/columnar/ColumnarSerDe.java serde/src/java/org/apache/hadoop/hive/serde2/columnar/ColumnarSerDe.java index 70bc7e8..5870884 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/columnar/ColumnarSerDe.java +++ serde/src/java/org/apache/hadoop/hive/serde2/columnar/ColumnarSerDe.java @@ -71,7 +71,7 @@ public String toString() { public ColumnarSerDe() throws SerDeException { } - SerDeParameters serdeParams = null; + protected SerDeParameters serdeParams = null; /** * Initialize the SerDe given the parameters. diff --git serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyUtils.java serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyUtils.java index ec91717..214a3e7 100644 --- serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyUtils.java +++ serde/src/java/org/apache/hadoop/hive/serde2/lazy/LazyUtils.java @@ -34,12 +34,12 @@ import org.apache.hadoop.hive.serde2.io.HiveVarcharWritable; import org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe.SerDeParameters; import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.primitive.HiveDecimalObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.BinaryObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.BooleanObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.ByteObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.DoubleObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.FloatObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.HiveDecimalObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.HiveVarcharObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.IntObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.LongObjectInspector; @@ -130,8 +130,8 @@ public static String convertToString(byte[] bytes, int start, int length) { } } - private static byte[] trueBytes = {(byte) 't', 'r', 'u', 'e'}; - private static byte[] falseBytes = {(byte) 'f', 'a', 'l', 's', 'e'}; + public static byte[] trueBytes = {(byte) 't', 'r', 'u', 'e'}; + public static byte[] falseBytes = {(byte) 'f', 'a', 'l', 's', 'e'}; /** * Write the bytes with special characters escaped. @@ -144,7 +144,7 @@ public static String convertToString(byte[] bytes, int start, int length) { * if escaped, whether a specific character needs escaping. This * array should have size of 128. */ - private static void writeEscaped(OutputStream out, byte[] bytes, int start, + public static void writeEscaped(OutputStream out, byte[] bytes, int start, int len, boolean escaped, byte escapeChar, boolean[] needsEscape) throws IOException { if (escaped) {