http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/metadata/converter/ThriftWrapperSchemaConverterImplTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/metadata/converter/ThriftWrapperSchemaConverterImplTest.java b/core/src/test/java/org/apache/carbondata/core/metadata/converter/ThriftWrapperSchemaConverterImplTest.java new file mode 100644 index 0000000..7709042 --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/metadata/converter/ThriftWrapperSchemaConverterImplTest.java @@ -0,0 +1,1846 @@ +/* + * 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.carbondata.core.metadata.converter; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.encoder.Encoding; +import org.apache.carbondata.core.metadata.schema.SchemaEvolution; +import org.apache.carbondata.core.metadata.schema.SchemaEvolutionEntry; +import org.apache.carbondata.core.metadata.schema.table.TableInfo; +import org.apache.carbondata.core.metadata.schema.table.TableSchema; +import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema; + +import mockit.Mock; +import mockit.MockUp; +import org.junit.BeforeClass; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; + +public class ThriftWrapperSchemaConverterImplTest { + + private static ThriftWrapperSchemaConverterImpl thriftWrapperSchemaConverter = null; + private static org.apache.carbondata.format.SchemaEvolutionEntry schemaEvolEntry = null; + private static org.apache.carbondata.format.ColumnSchema thriftColumnSchema = null; + private static List<ColumnSchema> columnSchemas = null; + private static List<SchemaEvolutionEntry> schemaEvolutionEntries = null; + private static List<org.apache.carbondata.format.ColumnSchema> thriftColumnSchemas = null; + private static List<org.apache.carbondata.format.SchemaEvolutionEntry> + thriftSchemaEvolutionEntries = null; + private static org.apache.carbondata.format.SchemaEvolution schemaEvol = null; + private static List<org.apache.carbondata.format.Encoding> encoders = null; + private static List<Encoding> encodings = null; + private static Map columnPropertyMap = null; + private static org.apache.carbondata.format.TableSchema tabSchema = null; + + @BeforeClass public static void setUp() { + + thriftWrapperSchemaConverter = new ThriftWrapperSchemaConverterImpl(); + schemaEvolEntry = new org.apache.carbondata.format.SchemaEvolutionEntry(); + schemaEvolutionEntries = new ArrayList(); + schemaEvolutionEntries.add(new SchemaEvolutionEntry()); + columnSchemas = new ArrayList(); + columnSchemas.add(new ColumnSchema()); + encodings = new ArrayList<>(); + encodings.add(Encoding.INVERTED_INDEX); + encodings.add(Encoding.DELTA); + encodings.add(Encoding.BIT_PACKED); + encodings.add(Encoding.DICTIONARY); + encodings.add(Encoding.RLE); + encodings.add(Encoding.DIRECT_DICTIONARY); + encoders = new ArrayList<org.apache.carbondata.format.Encoding>(); + encoders.add(org.apache.carbondata.format.Encoding.INVERTED_INDEX); + encoders.add(org.apache.carbondata.format.Encoding.DELTA); + encoders.add(org.apache.carbondata.format.Encoding.BIT_PACKED); + encoders.add(org.apache.carbondata.format.Encoding.DICTIONARY); + encoders.add(org.apache.carbondata.format.Encoding.RLE); + encoders.add(org.apache.carbondata.format.Encoding.DIRECT_DICTIONARY); + + columnPropertyMap = new HashMap<String, String>(); + columnPropertyMap.put("property", "value"); + thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRING, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + thriftColumnSchemas = new ArrayList<org.apache.carbondata.format.ColumnSchema>(); + thriftColumnSchemas.add(thriftColumnSchema); + thriftSchemaEvolutionEntries = new ArrayList<>(); + thriftSchemaEvolutionEntries.add(schemaEvolEntry); + schemaEvol = new org.apache.carbondata.format.SchemaEvolution(thriftSchemaEvolutionEntries); + + new MockUp<SchemaEvolution>() { + @Mock public List<SchemaEvolutionEntry> getSchemaEvolutionEntryList() { + return schemaEvolutionEntries; + } + }; + + new MockUp<org.apache.carbondata.format.SchemaEvolutionEntry>() { + @Mock public org.apache.carbondata.format.SchemaEvolutionEntry setAdded( + List<org.apache.carbondata.format.ColumnSchema> added) { + return schemaEvolEntry; + } + + @Mock public org.apache.carbondata.format.SchemaEvolutionEntry setRemoved( + List<org.apache.carbondata.format.ColumnSchema> removed) { + return schemaEvolEntry; + } + + @Mock public long getTime_stamp() { + long time = 1112745600000L; + return time; + } + + @Mock public List<org.apache.carbondata.format.ColumnSchema> getAdded() { + return thriftColumnSchemas; + } + + @Mock public List<org.apache.carbondata.format.ColumnSchema> getRemoved() { + return thriftColumnSchemas; + } + + }; + + new MockUp<org.apache.carbondata.format.ColumnSchema>() { + @Mock + public org.apache.carbondata.format.ColumnSchema setColumn_group_id(int column_group_id) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setScale(int scale) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setPrecision(int precision) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setNum_child(int num_child) { + return thriftColumnSchema; + } + + @Mock + public org.apache.carbondata.format.ColumnSchema setDefault_value(byte[] default_value) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setColumnProperties( + Map<String, String> columnProperties) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setInvisible(boolean invisible) { + return thriftColumnSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setColumnReferenceId( + String columnReferenceId) { + return thriftColumnSchema; + } + + @Mock public String getColumn_id() { + return "1"; + } + + @Mock public String getColumn_name() { + return "columnName"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimension() { + return true; + } + + @Mock public List<org.apache.carbondata.format.Encoding> getEncoders() { + return encoders; + } + + @Mock public int getNum_child() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getColumn_group_id() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public byte[] getDefault_value() { + return new byte[] { 1, 2 }; + } + + @Mock public String getAggregate_function() { + return ""; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + + }; + + final Map mapTableProperties = new HashMap<String, String>(); + tabSchema = new org.apache.carbondata.format.TableSchema(); + + new MockUp<org.apache.carbondata.format.TableSchema>() { + @Mock public org.apache.carbondata.format.TableSchema setTableProperties( + Map<String, String> tableProperties) { + return tabSchema; + } + + @Mock public String getTable_id() { + return "1"; + } + + @Mock public Map<String, String> getTableProperties() { + return mapTableProperties; + } + + @Mock public List<org.apache.carbondata.format.ColumnSchema> getTable_columns() { + return thriftColumnSchemas; + } + + @Mock public org.apache.carbondata.format.SchemaEvolution getSchema_evolution() { + return schemaEvol; + } + }; + new MockUp<org.apache.carbondata.format.SchemaEvolution>() { + @Mock + public List<org.apache.carbondata.format.SchemaEvolutionEntry> getSchema_evolution_history() { + return thriftSchemaEvolutionEntries; + } + }; + } + + @Test public void testFromWrapperToExternalSchemaEvolutionEntry() { + final SchemaEvolutionEntry schemaEvolutionEntry = new SchemaEvolutionEntry(); + + new MockUp<SchemaEvolutionEntry>() { + @Mock public List<ColumnSchema> getAdded() { + return columnSchemas; + } + + @Mock public List<ColumnSchema> getRemoved() { + return columnSchemas; + } + }; + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + }; + + org.apache.carbondata.format.SchemaEvolutionEntry actualResult = thriftWrapperSchemaConverter + .fromWrapperToExternalSchemaEvolutionEntry(schemaEvolutionEntry); + assertEquals(schemaEvolEntry, actualResult); + } + + @Test public void testFromWrapperToExternalSchemaEvolution() { + SchemaEvolution schemaEvolution = new SchemaEvolution(); + + new MockUp<SchemaEvolutionEntry>() { + @Mock public List<ColumnSchema> getAdded() { + return columnSchemas; + } + + @Mock public List<ColumnSchema> getRemoved() { + return columnSchemas; + } + }; + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + List<org.apache.carbondata.format.SchemaEvolutionEntry> thriftSchemaEvolutionEntries = + new ArrayList<>(); + thriftSchemaEvolutionEntries.add(schemaEvolEntry); + + org.apache.carbondata.format.SchemaEvolution actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalSchemaEvolution(schemaEvolution); + + org.apache.carbondata.format.SchemaEvolution expectedResult = + new org.apache.carbondata.format.SchemaEvolution(thriftSchemaEvolutionEntries); + assertEquals(expectedResult, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchema() { + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForStringDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRING, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.STRING; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForIntDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.INT, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.INT; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForShortDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.SHORT, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.SHORT; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForLongDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.LONG, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.LONG; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForDoubleDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.DOUBLE, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.DOUBLE; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForDecimalDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.DECIMAL, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.DECIMAL; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForTimestampDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema( + org.apache.carbondata.format.DataType.TIMESTAMP, "columnName", "1", true, encoders, + true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.TIMESTAMP; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForArrayDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.ARRAY, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.ARRAY; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForStructDatatype() { + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRUCT, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.STRUCT; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaForDatatypeNullCase() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(null, "columnName", "1", true, encoders, + true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return null; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalColumnSchemaWhenEncoderIsNull() { + + final List<Encoding> encoding = new ArrayList<>(); + encoding.add(Encoding.INVERTED_INDEX); + encoding.add(null); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encoding; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + List<Encoding> encodings = null; + encodings = new ArrayList<>(); + encodings.add(Encoding.INVERTED_INDEX); + encodings.add(null); + List<org.apache.carbondata.format.Encoding> encoders = null; + encoders = new ArrayList<org.apache.carbondata.format.Encoding>(); + encoders.add(org.apache.carbondata.format.Encoding.INVERTED_INDEX); + encoders.add(null); + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = null; + thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRING, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + org.apache.carbondata.format.ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchema); + assertEquals(thriftColumnSchema, actualResult); + } + + @Test public void testFromWrapperToExternalTableSchema() { + TableSchema wrapperTableSchema = new TableSchema(); + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + new MockUp<SchemaEvolutionEntry>() { + @Mock public List<ColumnSchema> getAdded() { + return columnSchemas; + } + + @Mock public List<ColumnSchema> getRemoved() { + return columnSchemas; + } + }; + + final SchemaEvolution schemaEvolution = new SchemaEvolution(); + final Map mapTableProperties = new HashMap<String, String>(); + + new MockUp<TableSchema>() { + @Mock public List<ColumnSchema> getListOfColumns() { + return columnSchemas; + } + + @Mock public SchemaEvolution getSchemaEvalution() { + return schemaEvolution; + } + + @Mock public String getTableId() { + return "tableId"; + } + + @Mock public Map<String, String> getTableProperties() { + return mapTableProperties; + } + + }; + org.apache.carbondata.format.TableSchema expectedResult = + new org.apache.carbondata.format.TableSchema("tableId", thriftColumnSchemas, schemaEvol); + org.apache.carbondata.format.TableSchema actualResult = + thriftWrapperSchemaConverter.fromWrapperToExternalTableSchema(wrapperTableSchema); + assertEquals(expectedResult, actualResult); + } + + @Test public void testFromWrapperToExternalTableInfo() { + TableInfo wrapperTableInfo = new TableInfo(); + String dbName = "dbName"; + String tableName = "TableName"; + final TableSchema wrapperTableSchema = new TableSchema(); + final List<TableSchema> tableSchemas = new ArrayList<>(); + tableSchemas.add(wrapperTableSchema); + + new MockUp<SchemaEvolutionEntry>() { + @Mock public List<ColumnSchema> getAdded() { + return columnSchemas; + } + + @Mock public List<ColumnSchema> getRemoved() { + return columnSchemas; + } + }; + + new MockUp<ColumnSchema>() { + @Mock public List<Encoding> getEncodingList() { + return encodings; + } + + @Mock public int getSchemaOrdinal() { + return 1; + } + + @Mock public DataType getDataType() { + return DataType.BOOLEAN; + } + + @Mock public String getColumnName() { + return "columnName"; + } + + @Mock public String getColumnUniqueId() { + return "1"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimensionColumn() { + return true; + } + + @Mock public int getColumnGroupId() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getNumberOfChild() { + return 1; + } + + @Mock public byte[] getDefaultValue() { + return new byte[] { 1, 2 }; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + }; + + new MockUp<TableInfo>() { + @Mock public TableSchema getFactTable() { + return wrapperTableSchema; + } + + @Mock public List<TableSchema> getAggregateTableList() { + return tableSchemas; + } + }; + + new MockUp<TableSchema>() { + @Mock public List<ColumnSchema> getListOfColumns() { + return columnSchemas; + } + + final SchemaEvolution schemaEvolution = new SchemaEvolution(); + final Map mapTableProperties = new HashMap<String, String>(); + + @Mock public SchemaEvolution getSchemaEvalution() { + return schemaEvolution; + } + + @Mock public String getTableId() { + return "tableId"; + } + + @Mock public Map<String, String> getTableProperties() { + return mapTableProperties; + } + + }; + org.apache.carbondata.format.TableSchema thriftFactTable = + new org.apache.carbondata.format.TableSchema("tableId", thriftColumnSchemas, schemaEvol); + List<org.apache.carbondata.format.TableSchema> thriftAggTables = new ArrayList<>(); + thriftAggTables.add(thriftFactTable); + org.apache.carbondata.format.TableInfo actualResult = thriftWrapperSchemaConverter + .fromWrapperToExternalTableInfo(wrapperTableInfo, dbName, tableName); + org.apache.carbondata.format.TableInfo expectedResult = + new org.apache.carbondata.format.TableInfo(thriftFactTable, thriftAggTables); + assertEquals(expectedResult, actualResult); + } + + @Test public void testFromExternalToWrapperSchemaEvolutionEntry() { +long time =1112745600000L; + ColumnSchema wrapperColumnSchema = new ColumnSchema(); + wrapperColumnSchema.setColumnUniqueId("1"); + wrapperColumnSchema.setColumnName("columnName"); + wrapperColumnSchema.setColumnar(true); + wrapperColumnSchema.setDataType(DataType.STRING); + wrapperColumnSchema.setDimensionColumn(true); + wrapperColumnSchema.setEncodingList(encodings); + wrapperColumnSchema.setNumberOfChild(1); + wrapperColumnSchema.setPrecision(1); + wrapperColumnSchema.setColumnGroup(1); + wrapperColumnSchema.setScale(1); + wrapperColumnSchema.setDefaultValue(new byte[] { 1, 2 }); + wrapperColumnSchema.setColumnProperties(columnPropertyMap); + wrapperColumnSchema.setInvisible(true); + wrapperColumnSchema.setColumnReferenceId("1"); + List<ColumnSchema> wrapperAddedColumns = new ArrayList<ColumnSchema>(); + wrapperAddedColumns.add(wrapperColumnSchema); + SchemaEvolutionEntry wrapperSchemaEvolutionEntry = new SchemaEvolutionEntry(); + + List<ColumnSchema> wrapperRemovedColumns = new ArrayList<ColumnSchema>(); + wrapperRemovedColumns.add(wrapperColumnSchema); + + wrapperSchemaEvolutionEntry.setTimeStamp(time); + wrapperSchemaEvolutionEntry.setAdded(wrapperAddedColumns); + wrapperSchemaEvolutionEntry.setRemoved(wrapperRemovedColumns); + SchemaEvolutionEntry actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperSchemaEvolutionEntry(schemaEvolEntry); + assertEquals(wrapperSchemaEvolutionEntry.getAdded().get(0), actualResult.getAdded().get(0)); + } + + @Test public void testFromExternalToWrapperSchemaEvolution() { + + new MockUp<SchemaEvolutionEntry>() { + @Mock public List<ColumnSchema> getAdded() { + return columnSchemas; + } + + @Mock public List<ColumnSchema> getRemoved() { + return columnSchemas; + } + }; + + SchemaEvolution actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperSchemaEvolution(schemaEvol); + assertEquals(columnSchemas, actualResult.getSchemaEvolutionEntryList().get(0).getAdded()); + } + + @Test public void testFromExternalToWrapperColumnSchema() { + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForIntDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.INT, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForShortDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.SHORT, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForLongDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.LONG, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForDoubleDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.DOUBLE, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForDecimalDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.DECIMAL, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForTimestampDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema( + org.apache.carbondata.format.DataType.TIMESTAMP, "columnName", "1", true, encoders, + true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForArrayDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.ARRAY, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForStructDatatype() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRUCT, + "columnName", "1", true, encoders, true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaForDatatypeNullCase() { + + org.apache.carbondata.format.ColumnSchema thriftColumnSchema = + new org.apache.carbondata.format.ColumnSchema(null, "columnName", "1", true, encoders, + true); + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColumnSchema); + Boolean expectedResult = true; + assertEquals(expectedResult, actualResult.hasEncoding(encodings.get(0))); + } + + @Test public void testFromExternalToWrapperColumnSchemaEncodingNullCase() { + + final List<org.apache.carbondata.format.Encoding> encoders = + new ArrayList<org.apache.carbondata.format.Encoding>(); + encoders.add(org.apache.carbondata.format.Encoding.INVERTED_INDEX); + encoders.add(null); + + List<Encoding> encodings = new ArrayList<>(); + encodings.add(Encoding.INVERTED_INDEX); + encodings.add(null); + + final org.apache.carbondata.format.ColumnSchema thriftColSchema = + new org.apache.carbondata.format.ColumnSchema(org.apache.carbondata.format.DataType.STRING, + "columnName", "1", true, encoders, true); + thriftColumnSchema.setSchemaOrdinal(1); + + new MockUp<org.apache.carbondata.format.ColumnSchema>() { + @Mock + public org.apache.carbondata.format.ColumnSchema setColumn_group_id(int column_group_id) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setScale(int scale) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setPrecision(int precision) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setNum_child(int num_child) { + return thriftColSchema; + } + + @Mock + public org.apache.carbondata.format.ColumnSchema setDefault_value(byte[] default_value) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setColumnProperties( + Map<String, String> columnProperties) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setInvisible(boolean invisible) { + return thriftColSchema; + } + + @Mock public org.apache.carbondata.format.ColumnSchema setColumnReferenceId( + String columnReferenceId) { + return thriftColSchema; + } + + @Mock public String getColumn_id() { + return "1"; + } + + @Mock public String getColumn_name() { + return "columnName"; + } + + @Mock public boolean isColumnar() { + return true; + } + + @Mock public boolean isDimension() { + return true; + } + + @Mock public List<org.apache.carbondata.format.Encoding> getEncoders() { + return encoders; + } + + @Mock public int getNum_child() { + return 1; + } + + @Mock public int getPrecision() { + return 1; + } + + @Mock public int getColumn_group_id() { + return 1; + } + + @Mock public int getScale() { + return 1; + } + + @Mock public byte[] getDefault_value() { + return new byte[] { 1, 2 }; + } + + @Mock public String getAggregate_function() { + return ""; + } + + @Mock public Map<String, String> getColumnProperties() { + return columnPropertyMap; + } + + @Mock public boolean isInvisible() { + return true; + } + + @Mock public String getColumnReferenceId() { + return "1"; + } + + }; + + ColumnSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperColumnSchema(thriftColSchema); + assertEquals("columnName", actualResult.getColumnName()); + } + + @Test public void testFromExternalToWrapperTableSchema() { + String tableId = "1"; + String tableName = "tableName"; + TableSchema actualResult = + thriftWrapperSchemaConverter.fromExternalToWrapperTableSchema(tabSchema, "tableName"); + assertEquals(tableId, actualResult.getTableId()); + assertEquals(tableName, actualResult.getTableName()); + } + + @Test public void testFromExternalToWrapperTableInfo() { + final List<org.apache.carbondata.format.TableSchema> tableSchemas = new ArrayList(); + long time = 1112745600000L; + tableSchemas.add(tabSchema); + new MockUp<org.apache.carbondata.format.TableInfo>() { + @Mock public org.apache.carbondata.format.TableSchema getFact_table() { + return tabSchema; + } + + @Mock public List<org.apache.carbondata.format.TableSchema> getAggregate_table_list() { + return tableSchemas; + } + }; + org.apache.carbondata.format.TableInfo externalTableInfo = + new org.apache.carbondata.format.TableInfo(); + TableInfo actualResult = thriftWrapperSchemaConverter + .fromExternalToWrapperTableInfo(externalTableInfo, "dbName", "tableName", "/path"); + assertEquals(time, actualResult.getLastUpdatedTime()); + assertEquals("dbName_tableName", actualResult.getTableUniqueName()); + } + +} \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableTest.java b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableTest.java new file mode 100644 index 0000000..1dbb1bc --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableTest.java @@ -0,0 +1,118 @@ +/* + * 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.carbondata.core.metadata.schema.table; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.encoder.Encoding; +import org.apache.carbondata.core.metadata.schema.table.column.CarbonDimension; +import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema; +import org.apache.carbondata.core.constants.CarbonCommonConstants; + +import junit.framework.TestCase; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +public class CarbonTableTest extends TestCase { + + private CarbonTable carbonTable; + + @BeforeClass public void setUp() { + carbonTable = new CarbonTable(); + carbonTable.loadCarbonTable(getTableInfo(1000L)); + } + + @AfterClass public void tearDown() { + carbonTable = null; + } + + @Test public void testNumberOfDimensionReturnsProperCount() { + assertEquals(1, carbonTable.getNumberOfDimensions("carbonTestTable")); + } + + @Test public void testNumberOfMeasureReturnsProperCount() { + assertEquals(1, carbonTable.getNumberOfMeasures("carbonTestTable")); + } + + @Test public void testGetDatabaseNameResturnsDatabaseName() { + assertEquals("carbonTestDatabase", carbonTable.getDatabaseName()); + } + + @Test public void testFactTableNameReturnsProperFactTableName() { + assertEquals("carbonTestTable", carbonTable.getFactTableName()); + } + + @Test public void testTableUniqueNameIsProper() { + assertEquals("carbonTestDatabase_carbonTestTable", carbonTable.getTableUniqueName()); + } + + @Test public void testDimensionPresentInTableIsProper() { + CarbonDimension dimension = new CarbonDimension(getColumnarDimensionColumn(), 0, -1, -1,-1); + assertTrue(carbonTable.getDimensionByName("carbonTestTable", "IMEI").equals(dimension)); + } + + private ColumnSchema getColumnarDimensionColumn() { + ColumnSchema dimColumn = new ColumnSchema(); + dimColumn.setColumnar(true); + dimColumn.setColumnName("IMEI"); + dimColumn.setColumnUniqueId(UUID.randomUUID().toString()); + dimColumn.setDataType(DataType.STRING); + dimColumn.setDimensionColumn(true); + List<Encoding> encodeList = + new ArrayList<Encoding>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE); + encodeList.add(Encoding.DICTIONARY); + dimColumn.setEncodingList(encodeList); + dimColumn.setNumberOfChild(0); + return dimColumn; + } + + private ColumnSchema getColumnarMeasureColumn() { + ColumnSchema dimColumn = new ColumnSchema(); + dimColumn.setColumnName("IMEI_COUNT"); + dimColumn.setColumnUniqueId(UUID.randomUUID().toString()); + dimColumn.setDataType(DataType.STRING); + return dimColumn; + } + + private TableSchema getTableSchema() { + TableSchema tableSchema = new TableSchema(); + List<ColumnSchema> columnSchemaList = new ArrayList<ColumnSchema>(); + columnSchemaList.add(getColumnarDimensionColumn()); + columnSchemaList.add(getColumnarMeasureColumn()); + tableSchema.setListOfColumns(columnSchemaList); + tableSchema.setTableId(UUID.randomUUID().toString()); + tableSchema.setTableName("carbonTestTable"); + return tableSchema; + } + + private TableInfo getTableInfo(long timeStamp) { + TableInfo info = new TableInfo(); + info.setDatabaseName("carbonTestDatabase"); + info.setLastUpdatedTime(timeStamp); + info.setTableUniqueName("carbonTestDatabase_carbonTestTable"); + info.setFactTable(getTableSchema()); + info.setStorePath("testore"); + return info; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableWithComplexTypesTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableWithComplexTypesTest.java b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableWithComplexTypesTest.java new file mode 100644 index 0000000..efc1b06 --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/CarbonTableWithComplexTypesTest.java @@ -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.carbondata.core.metadata.schema.table; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import org.apache.carbondata.core.metadata.datatype.DataType; +import org.apache.carbondata.core.metadata.encoder.Encoding; +import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema; +import org.apache.carbondata.core.constants.CarbonCommonConstants; + +import junit.framework.TestCase; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +public class CarbonTableWithComplexTypesTest extends TestCase { + + private CarbonTable carbonTable; + + @BeforeClass public void setUp() { + carbonTable = new CarbonTable(); + carbonTable.loadCarbonTable(getTableInfo(1000L)); + } + + @AfterClass public void tearDown() { + carbonTable = null; + } + + @Test public void testNumberOfDimensionReturnsProperCount() { + assertEquals(2, carbonTable.getNumberOfDimensions("carbonTestTable")); + } + + @Test public void testNumberOfMeasureReturnsProperCount() { + assertEquals(1, carbonTable.getNumberOfMeasures("carbonTestTable")); + } + + @Test public void testGetDatabaseNameResturnsDatabaseName() { + assertEquals("carbonTestDatabase", carbonTable.getDatabaseName()); + } + + @Test public void testFactTableNameReturnsProperFactTableName() { + assertEquals("carbonTestTable", carbonTable.getFactTableName()); + } + + @Test public void testTableUniqueNameIsProper() { + assertEquals("carbonTestDatabase_carbonTestTable", carbonTable.getTableUniqueName()); + } + + private List<ColumnSchema> getColumnarDimensionColumn() { + + List<ColumnSchema> cols = new ArrayList<ColumnSchema>(); + + ColumnSchema dimColumn = new ColumnSchema(); + dimColumn.setColumnar(true); + dimColumn.setColumnName("IMEI"); + dimColumn.setColumnUniqueId(UUID.randomUUID().toString()); + dimColumn.setDataType(DataType.STRING); + dimColumn.setDimensionColumn(true); + List<Encoding> encodeList = + new ArrayList<Encoding>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE); + encodeList.add(Encoding.DICTIONARY); + dimColumn.setEncodingList(encodeList); + dimColumn.setNumberOfChild(0); + cols.add(dimColumn); + + ColumnSchema structColumn = new ColumnSchema(); + structColumn.setColumnar(true); + structColumn.setColumnName("mobile"); + structColumn.setColumnUniqueId(UUID.randomUUID().toString()); + structColumn.setDataType(DataType.STRUCT); + structColumn.setDimensionColumn(true); + structColumn.setEncodingList(encodeList); + structColumn.setNumberOfChild(2); + cols.add(structColumn); + + ColumnSchema primitiveColumn = new ColumnSchema(); + primitiveColumn.setColumnar(true); + primitiveColumn.setColumnName("mobile.stdcode"); + primitiveColumn.setColumnUniqueId(UUID.randomUUID().toString()); + primitiveColumn.setDataType(DataType.STRING); + primitiveColumn.setDimensionColumn(true); + primitiveColumn.setEncodingList(encodeList); + primitiveColumn.setNumberOfChild(0); + cols.add(primitiveColumn); + + ColumnSchema arrayColumn = new ColumnSchema(); + arrayColumn.setColumnar(true); + arrayColumn.setColumnName("mobile.val"); + arrayColumn.setColumnUniqueId(UUID.randomUUID().toString()); + arrayColumn.setDataType(DataType.ARRAY); + arrayColumn.setDimensionColumn(true); + arrayColumn.setEncodingList(encodeList); + arrayColumn.setNumberOfChild(1); + cols.add(arrayColumn); + + ColumnSchema primitiveColumn1 = new ColumnSchema(); + primitiveColumn1.setColumnar(true); + primitiveColumn1.setColumnName("mobile.val.phoneno"); + primitiveColumn1.setColumnUniqueId(UUID.randomUUID().toString()); + primitiveColumn1.setDataType(DataType.STRING); + primitiveColumn1.setDimensionColumn(true); + primitiveColumn1.setEncodingList(encodeList); + primitiveColumn1.setNumberOfChild(0); + cols.add(primitiveColumn1); + + return cols; + } + + private ColumnSchema getColumnarMeasureColumn() { + ColumnSchema dimColumn = new ColumnSchema(); + dimColumn.setColumnName("IMEI_COUNT"); + dimColumn.setColumnUniqueId(UUID.randomUUID().toString()); + dimColumn.setDataType(DataType.STRING); + dimColumn.setDimensionColumn(false); + return dimColumn; + } + + private TableSchema getTableSchema() { + TableSchema tableSchema = new TableSchema(); + List<ColumnSchema> columnSchemaList = new ArrayList<ColumnSchema>(); + columnSchemaList.addAll(getColumnarDimensionColumn()); + columnSchemaList.add(getColumnarMeasureColumn()); + tableSchema.setListOfColumns(columnSchemaList); + tableSchema.setTableId(UUID.randomUUID().toString()); + tableSchema.setTableName("carbonTestTable"); + return tableSchema; + } + + private TableInfo getTableInfo(long timeStamp) { + TableInfo info = new TableInfo(); + info.setDatabaseName("carbonTestDatabase"); + info.setLastUpdatedTime(timeStamp); + info.setTableUniqueName("carbonTestDatabase_carbonTestTable"); + info.setFactTable(getTableSchema()); + info.setStorePath("testStore"); + return info; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableInfoTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableInfoTest.java b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableInfoTest.java new file mode 100644 index 0000000..dcd3ea1 --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableInfoTest.java @@ -0,0 +1,52 @@ +/* + * 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.carbondata.core.metadata.schema.table; + +import junit.framework.TestCase; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +public class TableInfoTest extends TestCase { + + private TableInfo tableInfo; + + @BeforeClass public void setUp() { + tableInfo = getTableInfo("tableInfoTestDatabase_equalsTableInfoTestTable"); + } + + @AfterClass public void tearDown() { + tableInfo = null; + } + + @Test public void testTableInfoEquals() { + TableInfo cmpEqualsTableInfo = getTableInfo("tableInfoTestDatabase_equalsTableInfoTestTable"); + TableInfo cmpNotEqualsTableInfo = getTableInfo("tableInfoTestDatabase_notEqualsTableInfoTestTable"); + assertTrue(tableInfo.equals(cmpEqualsTableInfo)); + assertTrue(!(tableInfo.equals(cmpNotEqualsTableInfo))); + } + + private TableInfo getTableInfo(String tableUniqueName) { + TableInfo info = new TableInfo(); + info.setDatabaseName("tableInfoTestDatabase"); + info.setLastUpdatedTime(1000L); + info.setTableUniqueName(tableUniqueName); + return info; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableSchemaTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableSchemaTest.java b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableSchemaTest.java new file mode 100644 index 0000000..d1d6a8b --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/metadata/schema/table/TableSchemaTest.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.carbondata.core.metadata.schema.table; + +import junit.framework.TestCase; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +public class TableSchemaTest extends TestCase { + + private TableSchema tableSchema; + + @BeforeClass public void setUp() { + tableSchema = getTableSchema("1000", "tableSchemaTestTable"); + } + + @AfterClass public void tearDown() { + tableSchema = null; + } + + @Test public void testTableInfoEquals() { + TableSchema cmpEqualsTableSchema = getTableSchema("1000", "tableSchemaTestTable"); + TableSchema cmpNotEqualsTableSchema = getTableSchema("1000", "tableSchemaTestTable2"); + assertTrue(tableSchema.equals(cmpEqualsTableSchema)); + assertTrue(!(tableSchema.equals(cmpNotEqualsTableSchema))); + } + + private TableSchema getTableSchema(String tableId, String tableName) { + TableSchema tableSchema = new TableSchema(); + tableSchema.setTableId(tableId); + tableSchema.setTableName(tableName); + return tableSchema; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatDirectoryStructureTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatDirectoryStructureTest.java b/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatDirectoryStructureTest.java deleted file mode 100644 index a085b9a..0000000 --- a/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatDirectoryStructureTest.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * 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.carbondata.core.path; - -import java.io.IOException; -import java.util.UUID; - -import org.apache.carbondata.core.carbon.CarbonTableIdentifier; -import org.apache.carbondata.core.carbon.path.CarbonStorePath; -import org.apache.carbondata.core.carbon.path.CarbonTablePath; -import org.junit.Test; - -import static junit.framework.TestCase.assertTrue; - -/** - * Test carbon directory structure - */ -public class CarbonFormatDirectoryStructureTest { - - private final String CARBON_STORE = "/opt/carbonstore"; - - /** - * test table path methods - */ - @Test public void testTablePathStructure() throws IOException { - CarbonTableIdentifier tableIdentifier = new CarbonTableIdentifier("d1", "t1", UUID.randomUUID().toString()); - CarbonStorePath carbonStorePath = new CarbonStorePath(CARBON_STORE); - CarbonTablePath carbonTablePath = carbonStorePath.getCarbonTablePath(tableIdentifier); - assertTrue(carbonTablePath.getPath().replace("\\", "/").equals(CARBON_STORE + "/d1/t1")); - assertTrue(carbonTablePath.getSchemaFilePath().replace("\\", "/").equals(CARBON_STORE + "/d1/t1/Metadata/schema")); - assertTrue(carbonTablePath.getTableStatusFilePath().replace("\\", "/") - .equals(CARBON_STORE + "/d1/t1/Metadata/tablestatus")); - assertTrue(carbonTablePath.getDictionaryFilePath("t1_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/t1/Metadata/t1_c1.dict")); - assertTrue(carbonTablePath.getDictionaryMetaFilePath("t1_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/t1/Metadata/t1_c1.dictmeta")); - assertTrue(carbonTablePath.getSortIndexFilePath("t1_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/t1/Metadata/t1_c1.sortindex")); - assertTrue(carbonTablePath.getCarbonDataFilePath("1", "2", 3, 4, 0, "999").replace("\\", "/") - .equals(CARBON_STORE + "/d1/t1/Fact/Part1/Segment_2/part-3-4-0-999.carbondata")); - } - - /** - * test data file name - */ - @Test public void testDataFileName() throws IOException { - assertTrue(CarbonTablePath.DataFileUtil.getPartNo("part-3-4-999.carbondata").equals("3")); - assertTrue(CarbonTablePath.DataFileUtil.getTaskNo("part-3-4-999.carbondata").equals("4")); - assertTrue( - CarbonTablePath.DataFileUtil.getTimeStampFromFileName("part-3-4-999.carbondata").equals("999")); - assertTrue(CarbonTablePath.DataFileUtil.getPartNo("/opt/apache-carbon/part-3-4-999.carbondata").equals("3")); - assertTrue(CarbonTablePath.DataFileUtil.getTaskNo("/opt/apache-carbon/part-3-4-999.carbondata").equals("4")); - assertTrue( - CarbonTablePath.DataFileUtil.getTimeStampFromFileName("/opt/apache-carbon/part-3-4-999.carbondata").equals("999")); - } -} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatSharedDictionaryTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatSharedDictionaryTest.java b/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatSharedDictionaryTest.java deleted file mode 100644 index 631393b..0000000 --- a/core/src/test/java/org/apache/carbondata/core/path/CarbonFormatSharedDictionaryTest.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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.carbondata.core.path; - -import java.io.IOException; - -import org.apache.carbondata.core.carbon.path.CarbonSharedDictionaryPath; - -import org.junit.Test; - -import static junit.framework.TestCase.assertTrue; - -/** - * test shared dictionary paths - */ -public class CarbonFormatSharedDictionaryTest { - - private final String CARBON_STORE = "/opt/carbonstore"; - - /** - * test shared dictionary location - */ - @Test public void testSharedDimentionLocation() throws IOException { - assertTrue(CarbonSharedDictionaryPath.getDictionaryFilePath(CARBON_STORE, "d1", "shared_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/SharedDictionary/shared_c1.dict")); - assertTrue(CarbonSharedDictionaryPath.getDictionaryMetaFilePath(CARBON_STORE, "d1", "shared_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/SharedDictionary/shared_c1.dictmeta")); - assertTrue(CarbonSharedDictionaryPath.getSortIndexFilePath(CARBON_STORE, "d1", "shared_c1").replace("\\", "/") - .equals(CARBON_STORE + "/d1/SharedDictionary/shared_c1.sortindex")); - } -} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/reader/CarbonDictionaryReaderImplTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/reader/CarbonDictionaryReaderImplTest.java b/core/src/test/java/org/apache/carbondata/core/reader/CarbonDictionaryReaderImplTest.java index 452e0d1..5432ad6 100644 --- a/core/src/test/java/org/apache/carbondata/core/reader/CarbonDictionaryReaderImplTest.java +++ b/core/src/test/java/org/apache/carbondata/core/reader/CarbonDictionaryReaderImplTest.java @@ -25,14 +25,10 @@ import java.util.ArrayList; import java.util.List; import java.util.UUID; -import org.apache.carbondata.common.ext.PathFactory; -import org.apache.carbondata.common.factory.CarbonCommonFactory; -import org.apache.carbondata.core.carbon.CarbonTableIdentifier; -import org.apache.carbondata.core.carbon.ColumnIdentifier; -import org.apache.carbondata.core.reader.CarbonDictionaryColumnMetaChunk; -import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReaderImpl; -import org.apache.carbondata.core.reader.CarbonDictionaryReaderImpl; -import org.apache.carbondata.core.reader.ThriftReader; +import org.apache.carbondata.core.service.impl.PathFactory; +import org.apache.carbondata.core.service.CarbonCommonFactory; +import org.apache.carbondata.core.metadata.CarbonTableIdentifier; +import org.apache.carbondata.core.metadata.ColumnIdentifier; import org.apache.carbondata.core.service.PathService; import mockit.Mock; http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImplTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImplTest.java b/core/src/test/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImplTest.java index 700edc4..585f33b 100644 --- a/core/src/test/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImplTest.java +++ b/core/src/test/java/org/apache/carbondata/core/reader/sortindex/CarbonDictionarySortIndexReaderImplTest.java @@ -24,10 +24,10 @@ import java.util.Arrays; import java.util.List; import java.util.UUID; -import org.apache.carbondata.core.carbon.CarbonTableIdentifier; -import org.apache.carbondata.core.carbon.ColumnIdentifier; -import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFile; -import org.apache.carbondata.core.datastorage.store.impl.FileFactory; +import org.apache.carbondata.core.metadata.CarbonTableIdentifier; +import org.apache.carbondata.core.metadata.ColumnIdentifier; +import org.apache.carbondata.core.datastore.filesystem.CarbonFile; +import org.apache.carbondata.core.datastore.impl.FileFactory; import org.apache.carbondata.core.util.CarbonUtil; import org.apache.carbondata.core.writer.CarbonDictionaryWriter; import org.apache.carbondata.core.writer.CarbonDictionaryWriterImpl; http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/ce09aaaf/core/src/test/java/org/apache/carbondata/core/scan/collector/impl/DictionaryBasedResultCollectorTest.java ---------------------------------------------------------------------- diff --git a/core/src/test/java/org/apache/carbondata/core/scan/collector/impl/DictionaryBasedResultCollectorTest.java b/core/src/test/java/org/apache/carbondata/core/scan/collector/impl/DictionaryBasedResultCollectorTest.java new file mode 100644 index 0000000..1b2f533 --- /dev/null +++ b/core/src/test/java/org/apache/carbondata/core/scan/collector/impl/DictionaryBasedResultCollectorTest.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.carbondata.core.scan.collector.impl; + + +public class DictionaryBasedResultCollectorTest { + +// private static DictionaryBasedResultCollector dictionaryBasedResultCollector; +// private static BlockExecutionInfo blockExecutionInfo; +// +// @BeforeClass public static void setUp() { +// blockExecutionInfo = new BlockExecutionInfo(); +// KeyStructureInfo keyStructureInfo = new KeyStructureInfo(); +// blockExecutionInfo.setKeyStructureInfo(keyStructureInfo); +// AggregatorInfo aggregatorInfo = new AggregatorInfo(); +// aggregatorInfo.setMeasureOrdinals(new int[] { 10, 20, 30, 40 }); +// aggregatorInfo.setMeasureExists(new boolean[] { true, false, false, false }); +// aggregatorInfo.setDefaultValues(new Object[] { 1, 2, 3, 4 }); +// aggregatorInfo.setMeasureDataTypes( +// new DataType[] { DataType.INT, DataType.TIMESTAMP, DataType.INT, DataType.INT }); +// blockExecutionInfo.setAggregatorInfo(aggregatorInfo); +// QueryDimension queryDimension1 = new QueryDimension("QDCol1"); +// queryDimension1.setQueryOrder(1); +// ColumnSchema columnSchema = new ColumnSchema(); +// queryDimension1.setDimension(new CarbonDimension(columnSchema, 0, 0, 0, 0)); +// QueryDimension queryDimension2 = new QueryDimension("QDCol2"); +// queryDimension2.setQueryOrder(2); +// queryDimension2.setDimension(new CarbonDimension(columnSchema, 1, 1, 1, 1)); +// QueryDimension queryDimension3 = new QueryDimension("QDCol3"); +// queryDimension3.setQueryOrder(3); +// queryDimension3.setDimension(new CarbonDimension(columnSchema, 2, 0, 0, 0)); +// QueryDimension queryDimension4 = new QueryDimension("QDCol4"); +// queryDimension4.setQueryOrder(4); +// queryDimension4.setDimension(new CarbonDimension(columnSchema, 3, 0, 0, 0)); +// blockExecutionInfo.setQueryDimensions( +// new QueryDimension[] { queryDimension1, queryDimension2, queryDimension3, +// queryDimension4 }); +// QueryMeasure queryMeasure1 = new QueryMeasure("QMCol1"); +// queryMeasure1.setQueryOrder(1); +// QueryMeasure queryMeasure2 = new QueryMeasure("QMCol2"); +// queryMeasure1.setQueryOrder(2); +// QueryMeasure queryMeasure3 = new QueryMeasure("QMCol3"); +// queryMeasure1.setQueryOrder(3); +// QueryMeasure queryMeasure4 = new QueryMeasure("QMCol4"); +// queryMeasure1.setQueryOrder(4); +// blockExecutionInfo.setQueryMeasures( +// new QueryMeasure[] { queryMeasure1, queryMeasure2, queryMeasure3, queryMeasure4 }); +// Map<Integer, GenericQueryType> complexDimensionInfoMap = new HashMap<>(); +// complexDimensionInfoMap.put(1, new ArrayQueryType("name1", "parent1", 1)); +// complexDimensionInfoMap.put(2, new ArrayQueryType("name2", "parent2", 2)); +// complexDimensionInfoMap.put(3, new ArrayQueryType("name3", "parent3", 3)); +// complexDimensionInfoMap.put(4, new ArrayQueryType("name4", "parent4", 4)); +// blockExecutionInfo.setComplexDimensionInfoMap(complexDimensionInfoMap); +// dictionaryBasedResultCollector = new DictionaryBasedResultCollector(blockExecutionInfo); +// } +// +// @Test public void testToCollectData() { +// new MockUp<CarbonUtil>() { +// @SuppressWarnings("unused") @Mock boolean[] getDictionaryEncodingArray( +// QueryDimension[] queryDimensions) { +// return new boolean[] { true, false, true, true }; +// } +// +// @SuppressWarnings("unused") @Mock boolean[] getDirectDictionaryEncodingArray( +// QueryDimension[] queryDimensions) { +// return new boolean[] { true, true, false, false }; +// } +// +// @SuppressWarnings("unused") @Mock boolean[] getComplexDataTypeArray( +// QueryDimension[] queryDimensions) { +// return new boolean[] { false, false, true, false }; +// } +// }; +// new MockUp<DataTypeUtil>() { +// @SuppressWarnings("unused") @Mock Object getDataBasedOnDataType(String data, +// DataType actualDataType) { +// return 1; +// } +// }; +// +// new MockUp<NonFilterQueryScannedResult>() { +// @SuppressWarnings("unused") @Mock int[] getDictionaryKeyIntegerArray() { +// this.getMockInstance().incrementCounter(); +// System.out.println("Mocked"); +// return new int[] { 1, 2 }; +// } +// +// @SuppressWarnings("unused") @Mock String[] getNoDictionaryKeyStringArray() { +// return new String[] { "1", "2" }; +// } +// +// @SuppressWarnings("unused") @Mock byte[][] getComplexTypeKeyArray() { +// return new byte[][] { { 1, 2 }, { 1, 2 } }; +// } +// +// @SuppressWarnings("unused") @Mock public MeasureColumnDataChunk getMeasureChunk(int ordinal) { +// MeasureColumnDataChunk measureColumnDataChunk = new MeasureColumnDataChunk(); +// PresenceMeta presenceMeta = new PresenceMeta(); +// BitSet bitSet = new BitSet(); +// bitSet.set(1); +// presenceMeta.setBitSet(bitSet); +// measureColumnDataChunk.setNullValueIndexHolder(presenceMeta); +// CarbonReadDataHolder carbonReadDataHolder = new CarbonReadDataHolder(); +// carbonReadDataHolder.setReadableLongValues(new long[] { 1 }); +// measureColumnDataChunk.setMeasureDataHolder(carbonReadDataHolder); +// return measureColumnDataChunk; +// } +// }; +// +// new MockUp<DirectDictionaryKeyGeneratorFactory>() { +// @SuppressWarnings("unused") @Mock DirectDictionaryGenerator getDirectDictionaryGenerator( +// DataType dataType) { +// if (dataType == DataType.TIMESTAMP) return new TimeStampDirectDictionaryGenerator( +// CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT); +// else return null; +// } +// }; +// new MockUp<TimeStampDirectDictionaryGenerator>() { +// @SuppressWarnings("unused") @Mock Object getValueFromSurrogate(int key) { +// return 100L; +// } +// }; +// +// new MockUp<ArrayQueryType>() { +// @SuppressWarnings("unused") @Mock Object getDataBasedOnDataTypeFromSurrogates( +// ByteBuffer surrogateData) { +// return ByteBuffer.wrap("1".getBytes()); +// } +// }; +// +// AbstractScannedResult abstractScannedResult = +// new NonFilterQueryScannedResult(blockExecutionInfo); +// abstractScannedResult.setNumberOfRows(2); +// List<Object[]> result = dictionaryBasedResultCollector.collectData(abstractScannedResult, 2); +// int expectedResult = 2; +// assertThat(result.size(), is(equalTo(expectedResult))); +// } +} \ No newline at end of file
