http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/executor/infos/SortInfo.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/executor/infos/SortInfo.java b/core/src/main/java/org/carbondata/scan/executor/infos/SortInfo.java new file mode 100644 index 0000000..53584f5 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/executor/infos/SortInfo.java @@ -0,0 +1,125 @@ +/* + * 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.carbondata.scan.executor.infos; + +import java.util.List; + +import org.carbondata.scan.model.QueryDimension; + +/** + * Below class holds the order by information about the query + */ +public class SortInfo { + + /** + * sorting order of a dimension + */ + private byte[] dimensionSortOrder; + + /** + * byte range of each dimension present in the order by + */ + private int[][] maskedByteRangeForSorting; + + /** + * dimension indexes which is used in order bye + */ + private byte[] sortDimensionIndex; + + /** + * mask key of each dimension + * this will be used to sort the dimension + */ + private byte[][] dimensionMaskKeyForSorting; + + /** + * sortDimension + */ + private List<QueryDimension> sortDimension; + + /** + * @return the dimensionSortOrder + */ + public byte[] getDimensionSortOrder() { + return dimensionSortOrder; + } + + /** + * @param dimensionSortOrder the dimensionSortOrder to set + */ + public void setDimensionSortOrder(byte[] dimensionSortOrder) { + this.dimensionSortOrder = dimensionSortOrder; + } + + /** + * @return the maskedByteRangeForSorting + */ + public int[][] getMaskedByteRangeForSorting() { + return maskedByteRangeForSorting; + } + + /** + * @param maskedByteRangeForSorting the maskedByteRangeForSorting to set + */ + public void setMaskedByteRangeForSorting(int[][] maskedByteRangeForSorting) { + this.maskedByteRangeForSorting = maskedByteRangeForSorting; + } + + /** + * @return the sortDimensionIndex + */ + public byte[] getSortDimensionIndex() { + return sortDimensionIndex; + } + + /** + * @param sortDimensionIndex the sortDimensionIndex to set + */ + public void setSortDimensionIndex(byte[] sortDimensionIndex) { + this.sortDimensionIndex = sortDimensionIndex; + } + + /** + * @return the dimensionMaskKeyForSorting + */ + public byte[][] getDimensionMaskKeyForSorting() { + return dimensionMaskKeyForSorting; + } + + /** + * @param dimensionMaskKeyForSorting the dimensionMaskKeyForSorting to set + */ + public void setDimensionMaskKeyForSorting(byte[][] dimensionMaskKeyForSorting) { + this.dimensionMaskKeyForSorting = dimensionMaskKeyForSorting; + } + + /** + * @return the sortDimension + */ + public List<QueryDimension> getSortDimension() { + return sortDimension; + } + + /** + * @param sortDimension the sortDimension to set + */ + public void setSortDimension(List<QueryDimension> sortDimension) { + this.sortDimension = sortDimension; + } +}
http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/executor/util/QueryUtil.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/executor/util/QueryUtil.java b/core/src/main/java/org/carbondata/scan/executor/util/QueryUtil.java new file mode 100644 index 0000000..a7d98a3 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/executor/util/QueryUtil.java @@ -0,0 +1,718 @@ +/* + * 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.carbondata.scan.executor.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.TreeSet; + +import org.carbondata.core.cache.Cache; +import org.carbondata.core.cache.CacheProvider; +import org.carbondata.core.cache.CacheType; +import org.carbondata.core.cache.dictionary.Dictionary; +import org.carbondata.core.cache.dictionary.DictionaryColumnUniqueIdentifier; +import org.carbondata.core.carbon.AbsoluteTableIdentifier; +import org.carbondata.core.carbon.CarbonTableIdentifier; +import org.carbondata.core.carbon.datastore.block.SegmentProperties; +import org.carbondata.core.carbon.metadata.CarbonMetadata; +import org.carbondata.core.carbon.metadata.encoder.Encoding; +import org.carbondata.core.carbon.metadata.schema.table.CarbonTable; +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonDimension; +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonMeasure; +import org.carbondata.core.constants.CarbonCommonConstants; +import org.carbondata.core.keygenerator.KeyGenException; +import org.carbondata.core.keygenerator.KeyGenerator; +import org.carbondata.core.util.CarbonUtil; +import org.carbondata.core.util.CarbonUtilException; +import org.carbondata.scan.executor.exception.QueryExecutionException; +import org.carbondata.scan.executor.infos.KeyStructureInfo; +import org.carbondata.scan.model.QueryDimension; +import org.carbondata.scan.model.QueryMeasure; +import org.carbondata.scan.model.QueryModel; + +import org.apache.commons.lang3.ArrayUtils; + +/** + * Utility class for query execution + */ +public class QueryUtil { + + /** + * Below method will be used to get the masked byte range based on the query + * dimension. It will give the range in the mdkey. This will be used to get + * the actual key array from masked mdkey + * + * @param queryDimensions query dimension selected in query + * @param keyGenerator key generator + * @return masked key + */ + public static int[] getMaskedByteRange(List<QueryDimension> queryDimensions, + KeyGenerator keyGenerator) { + Set<Integer> byteRangeSet = new TreeSet<Integer>(); + int[] byteRange = null; + for (int i = 0; i < queryDimensions.size(); i++) { + + // as no dictionary column and complex type columns + // are not selected in the mdkey + // so we will not select the those dimension for calculating the + // range + if (queryDimensions.get(i).getDimension().getKeyOrdinal() == -1) { + continue; + } + // get the offset of the dimension in the mdkey + byteRange = + keyGenerator.getKeyByteOffsets(queryDimensions.get(i).getDimension().getKeyOrdinal()); + for (int j = byteRange[0]; j <= byteRange[1]; j++) { + byteRangeSet.add(j); + } + } + int[] maksedByteRange = new int[byteRangeSet.size()]; + int index = 0; + Iterator<Integer> iterator = byteRangeSet.iterator(); + // add the masked byte range + while (iterator.hasNext()) { + maksedByteRange[index++] = iterator.next(); + } + return maksedByteRange; + } + + public static int[] getMaskedByteRangeBasedOrdinal(List<Integer> ordinals, + KeyGenerator keyGenerator) { + Set<Integer> byteRangeSet = new TreeSet<Integer>(); + int[] byteRange = null; + for (int i = 0; i < ordinals.size(); i++) { + + // get the offset of the dimension in the mdkey + byteRange = keyGenerator.getKeyByteOffsets(ordinals.get(i)); + for (int j = byteRange[0]; j <= byteRange[1]; j++) { + byteRangeSet.add(j); + } + } + int[] maksedByteRange = new int[byteRangeSet.size()]; + int index = 0; + Iterator<Integer> iterator = byteRangeSet.iterator(); + // add the masked byte range + while (iterator.hasNext()) { + maksedByteRange[index++] = iterator.next(); + } + return maksedByteRange; + } + + /** + * Below method will return the max key based on the dimension ordinal + * + * @param keyOrdinalList + * @param generator + * @return + * @throws KeyGenException + */ + public static byte[] getMaxKeyBasedOnOrinal(List<Integer> keyOrdinalList, KeyGenerator generator) + throws KeyGenException { + long[] max = new long[generator.getDimCount()]; + Arrays.fill(max, 0L); + + for (int i = 0; i < keyOrdinalList.size(); i++) { + // adding for dimension which is selected in query + max[keyOrdinalList.get(i)] = Long.MAX_VALUE; + } + return generator.generateKey(max); + } + + /** + * To get the max key based on dimensions. i.e. all other dimensions will be + * set to 0 bits and the required query dimension will be masked with all + * LONG.MAX so that we can mask key and then compare while aggregating This + * can be useful during filter query when only few dimensions were selected + * out of row group + * + * @param queryDimensions dimension selected in query + * @param generator key generator + * @return max key for dimension + * @throws KeyGenException if any problem while generating the key + */ + public static byte[] getMaxKeyBasedOnDimensions(List<QueryDimension> queryDimensions, + KeyGenerator generator) throws KeyGenException { + long[] max = new long[generator.getDimCount()]; + Arrays.fill(max, 0L); + + for (int i = 0; i < queryDimensions.size(); i++) { + // as no dictionary column and complex type columns + // are not selected in the mdkey + // so we will not select the those dimension for calculating the + // range + if (queryDimensions.get(i).getDimension().getKeyOrdinal() == -1) { + continue; + } + // adding for dimension which is selected in query + max[queryDimensions.get(i).getDimension().getKeyOrdinal()] = Long.MAX_VALUE; + } + + return generator.generateKey(max); + } + + /** + * Below method will be used to get the masked key for query + * + * @param keySize size of the masked key + * @param maskedKeyRanges masked byte range + * @return masked bytes + */ + public static int[] getMaskedByte(int keySize, int[] maskedKeyRanges) { + int[] maskedKey = new int[keySize]; + // all the non selected dimension will be filled with -1 + Arrays.fill(maskedKey, -1); + for (int i = 0; i < maskedKeyRanges.length; i++) { + maskedKey[maskedKeyRanges[i]] = i; + } + return maskedKey; + } + + /** + * Below method will be used to get the dimension block index in file based + * on query dimension + * + * @param queryDimensions query dimension + * @param dimensionOrdinalToBlockMapping mapping of dimension block in file to query dimension + * @return block index of file + */ + public static int[] getDimensionsBlockIndexes(List<QueryDimension> queryDimensions, + Map<Integer, Integer> dimensionOrdinalToBlockMapping, + List<CarbonDimension> customAggregationDimension) { + // using set as in row group columns will point to same block + Set<Integer> dimensionBlockIndex = new HashSet<Integer>(); + for (int i = 0; i < queryDimensions.size(); i++) { + dimensionBlockIndex.add( + dimensionOrdinalToBlockMapping.get(queryDimensions.get(i).getDimension().getOrdinal())); + } + for (int i = 0; i < customAggregationDimension.size(); i++) { + dimensionBlockIndex + .add(dimensionOrdinalToBlockMapping.get(customAggregationDimension.get(i).getOrdinal())); + } + return ArrayUtils + .toPrimitive(dimensionBlockIndex.toArray(new Integer[dimensionBlockIndex.size()])); + } + + /** + * Below method will be used to get the dictionary mapping for all the + * dictionary encoded dimension present in the query + * + * @param queryDimensions query dimension present in the query this will be used to + * convert the result from surrogate key to actual data + * @param absoluteTableIdentifier absolute table identifier + * @return dimension unique id to its dictionary map + * @throws QueryExecutionException + */ + public static Map<String, Dictionary> getDimensionDictionaryDetail( + List<QueryDimension> queryDimensions, + AbsoluteTableIdentifier absoluteTableIdentifier) throws QueryExecutionException { + // to store dimension unique column id list, this is required as + // dimension can be present in + // query dimension, as well as some aggregation function will be applied + // in the same dimension + // so we need to get only one instance of dictionary + // direct dictionary skip is done only for the dictionary lookup + Set<String> dictionaryDimensionFromQuery = new HashSet<String>(); + for (int i = 0; i < queryDimensions.size(); i++) { + List<Encoding> encodingList = queryDimensions.get(i).getDimension().getEncoder(); + if (CarbonUtil.hasEncoding(encodingList, Encoding.DICTIONARY) && !CarbonUtil + .hasEncoding(encodingList, Encoding.DIRECT_DICTIONARY)) { + dictionaryDimensionFromQuery.add(queryDimensions.get(i).getDimension().getColumnId()); + } + } + // converting to list as api exposed needed list which i think + // is not correct + List<String> dictionaryColumnIdList = + new ArrayList<String>(dictionaryDimensionFromQuery.size()); + dictionaryColumnIdList.addAll(dictionaryDimensionFromQuery); + return getDictionaryMap(dictionaryColumnIdList, absoluteTableIdentifier); + } + + /** + * Below method will be used to get the column id to its dictionary mapping + * + * @param dictionaryColumnIdList dictionary column list + * @param absoluteTableIdentifier absolute table identifier + * @return dictionary mapping + * @throws QueryExecutionException + */ + private static Map<String, Dictionary> getDictionaryMap(List<String> dictionaryColumnIdList, + AbsoluteTableIdentifier absoluteTableIdentifier) throws QueryExecutionException { + // this for dictionary unique identifier + List<DictionaryColumnUniqueIdentifier> dictionaryColumnUniqueIdentifiers = + getDictionaryColumnUniqueIdentifierList(dictionaryColumnIdList, + absoluteTableIdentifier.getCarbonTableIdentifier()); + CacheProvider cacheProvider = CacheProvider.getInstance(); + Cache forwardDictionaryCache = cacheProvider + .createCache(CacheType.FORWARD_DICTIONARY, absoluteTableIdentifier.getStorePath()); + List<Dictionary> columnDictionaryList = null; + try { + columnDictionaryList = forwardDictionaryCache.getAll(dictionaryColumnUniqueIdentifiers); + } catch (CarbonUtilException e) { + throw new QueryExecutionException(e); + } + Map<String, Dictionary> columnDictionaryMap = new HashMap<>(columnDictionaryList.size()); + for (int i = 0; i < dictionaryColumnUniqueIdentifiers.size(); i++) { + // TODO: null check for column dictionary, if cache size is less it + // might return null here, in that case throw exception + columnDictionaryMap.put(dictionaryColumnIdList.get(i), columnDictionaryList.get(i)); + } + return columnDictionaryMap; + } + + /** + * Below method will be used to get the dictionary column unique identifier + * + * @param dictionaryColumnIdList dictionary + * @param carbonTableIdentifier + * @return + */ + private static List<DictionaryColumnUniqueIdentifier> getDictionaryColumnUniqueIdentifierList( + List<String> dictionaryColumnIdList, CarbonTableIdentifier carbonTableIdentifier) { + CarbonTable carbonTable = + CarbonMetadata.getInstance().getCarbonTable(carbonTableIdentifier.getTableUniqueName()); + List<DictionaryColumnUniqueIdentifier> dictionaryColumnUniqueIdentifiers = + new ArrayList<>(dictionaryColumnIdList.size()); + for (String columnIdentifier : dictionaryColumnIdList) { + CarbonDimension dimension = CarbonMetadata.getInstance() + .getCarbonDimensionBasedOnColIdentifier(carbonTable, columnIdentifier); + DictionaryColumnUniqueIdentifier dictionaryColumnUniqueIdentifier = + new DictionaryColumnUniqueIdentifier(carbonTableIdentifier, columnIdentifier, + dimension.getDataType()); + dictionaryColumnUniqueIdentifiers.add(dictionaryColumnUniqueIdentifier); + } + return dictionaryColumnUniqueIdentifiers; + } + + /** + * Below method will used to get the method will be used to get the measure + * block indexes to be read from the file + * + * @param queryMeasures query measure + * @param expressionMeasure measure present in the expression + * @param ordinalToBlockIndexMapping measure ordinal to block mapping + * @return block indexes + */ + public static int[] getMeasureBlockIndexes(List<QueryMeasure> queryMeasures, + List<CarbonMeasure> expressionMeasure, Map<Integer, Integer> ordinalToBlockIndexMapping) { + Set<Integer> measureBlockIndex = new HashSet<Integer>(); + for (int i = 0; i < queryMeasures.size(); i++) { + measureBlockIndex + .add(ordinalToBlockIndexMapping.get(queryMeasures.get(i).getMeasure().getOrdinal())); + } + for (int i = 0; i < expressionMeasure.size(); i++) { + measureBlockIndex.add(ordinalToBlockIndexMapping.get(expressionMeasure.get(i).getOrdinal())); + } + return ArrayUtils.toPrimitive(measureBlockIndex.toArray(new Integer[measureBlockIndex.size()])); + } + + /** + * Below method will be used to get the masked byte range for dimension + * which is present in order by + * + * @param orderByDimensions order by dimension + * @param generator key generator + * @param maskedRanges masked byte range for dimension + * @return range of masked byte for order by dimension + */ + public static int[][] getMaskedByteRangeForSorting(List<QueryDimension> orderByDimensions, + KeyGenerator generator, int[] maskedRanges) { + int[][] dimensionCompareIndex = new int[orderByDimensions.size()][]; + int index = 0; + for (int i = 0; i < dimensionCompareIndex.length; i++) { + Set<Integer> integers = new TreeSet<Integer>(); + if (!orderByDimensions.get(i).getDimension().getEncoder().contains(Encoding.DICTIONARY) + || orderByDimensions.get(i).getDimension().numberOfChild() > 0) { + continue; + } + int[] range = + generator.getKeyByteOffsets(orderByDimensions.get(i).getDimension().getKeyOrdinal()); + for (int j = range[0]; j <= range[1]; j++) { + integers.add(j); + } + dimensionCompareIndex[index] = new int[integers.size()]; + int j = 0; + for (Iterator<Integer> iterator = integers.iterator(); iterator.hasNext(); ) { + Integer integer = (Integer) iterator.next(); + dimensionCompareIndex[index][j++] = integer.intValue(); + } + index++; + } + for (int i = 0; i < dimensionCompareIndex.length; i++) { + if (null == dimensionCompareIndex[i]) { + continue; + } + int[] range = dimensionCompareIndex[i]; + if (null != range) { + for (int j = 0; j < range.length; j++) { + for (int k = 0; k < maskedRanges.length; k++) { + if (range[j] == maskedRanges[k]) { + range[j] = k; + break; + } + } + } + } + + } + return dimensionCompareIndex; + } + + /** + * Below method will be used to get the masked key for sorting + * + * @param orderDimensions query dimension + * @param generator key generator + * @param maskedByteRangeForSorting masked byte range for sorting + * @param maskedRanges masked range + * @return masked byte range + * @throws QueryExecutionException + */ + public static byte[][] getMaksedKeyForSorting(List<QueryDimension> orderDimensions, + KeyGenerator generator, int[][] maskedByteRangeForSorting, int[] maskedRanges) + throws QueryExecutionException { + byte[][] maskedKey = new byte[orderDimensions.size()][]; + byte[] mdKey = null; + long[] key = null; + byte[] maskedMdKey = null; + try { + if (null != maskedByteRangeForSorting) { + for (int i = 0; i < maskedByteRangeForSorting.length; i++) { + if (null == maskedByteRangeForSorting[i]) { + continue; + } + key = new long[generator.getDimCount()]; + maskedKey[i] = new byte[maskedByteRangeForSorting[i].length]; + key[orderDimensions.get(i).getDimension().getKeyOrdinal()] = Long.MAX_VALUE; + mdKey = generator.generateKey(key); + maskedMdKey = new byte[maskedRanges.length]; + for (int k = 0; k < maskedMdKey.length; k++) { // CHECKSTYLE:OFF + // Approval + // No:Approval-V1R2C10_001 + maskedMdKey[k] = mdKey[maskedRanges[k]]; + } + for (int j = 0; j < maskedByteRangeForSorting[i].length; j++) { + maskedKey[i][j] = maskedMdKey[maskedByteRangeForSorting[i][j]]; + }// CHECKSTYLE:ON + + } + } + } catch (KeyGenException e) { + throw new QueryExecutionException(e); + } + return maskedKey; + } + + /** + * Below method will be used to get mapping whether dimension is present in + * order by or not + * + * @param sortedDimensions sort dimension present in order by query + * @param queryDimensions query dimension + * @return sort dimension indexes + */ + public static byte[] getSortDimensionIndexes(List<QueryDimension> sortedDimensions, + List<QueryDimension> queryDimensions) { + byte[] sortedDims = new byte[queryDimensions.size()]; + int indexOf = 0; + for (int i = 0; i < sortedDims.length; i++) { + indexOf = sortedDimensions.indexOf(queryDimensions.get(i)); + if (indexOf > -1) { + sortedDims[i] = 1; + } + } + return sortedDims; + } + + /** + * Below method will be used to get the mapping of block index and its + * restructuring info + * + * @param queryDimensions query dimension from query model + * @param segmentProperties segment properties + * @return map of block index to its restructuring info + * @throws KeyGenException if problem while key generation + */ + public static Map<Integer, KeyStructureInfo> getColumnGroupKeyStructureInfo( + List<QueryDimension> queryDimensions, SegmentProperties segmentProperties) + throws KeyGenException { + Map<Integer, KeyStructureInfo> rowGroupToItsRSInfo = new HashMap<Integer, KeyStructureInfo>(); + // get column group id and its ordinal mapping of column group + Map<Integer, List<Integer>> columnGroupAndItsOrdinalMappingForQuery = + getColumnGroupAndItsOrdinalMapping(queryDimensions); + KeyGenerator keyGenerator = segmentProperties.getDimensionKeyGenerator(); + + Iterator<Entry<Integer, List<Integer>>> iterator = + columnGroupAndItsOrdinalMappingForQuery.entrySet().iterator(); + KeyStructureInfo restructureInfos = null; + while (iterator.hasNext()) { + Entry<Integer, List<Integer>> next = iterator.next(); + restructureInfos = new KeyStructureInfo(); + // sort the ordinal + List<Integer> ordinal = next.getValue(); + Collections.sort(ordinal); + // get the masked byte range for column group + int[] maskByteRanges = getMaskedByteRangeBasedOrdinal(ordinal, keyGenerator); + // max key for column group + byte[] maxKey = getMaxKeyBasedOnOrinal(ordinal, keyGenerator); + // get masked key for column group + int[] maksedByte = getMaskedByte(keyGenerator.getKeySizeInBytes(), maskByteRanges); + restructureInfos.setKeyGenerator(keyGenerator); + restructureInfos.setMaskByteRanges(maskByteRanges); + restructureInfos.setMaxKey(maxKey); + restructureInfos.setMaskedBytes(maksedByte); + restructureInfos + .setBlockMdKeyStartOffset(getBlockMdKeyStartOffset(segmentProperties, ordinal)); + rowGroupToItsRSInfo + .put(segmentProperties.getDimensionOrdinalToBlockMapping().get(ordinal.get(0)), + restructureInfos); + } + return rowGroupToItsRSInfo; + } + + /** + * It return mdkey start index of given column group + * @param segmentProperties + * @param ordinal : column group ordinal + * @return + */ + public static int getBlockMdKeyStartOffset(SegmentProperties segmentProperties, + List<Integer> ordinal) { + int[][] colGroups = segmentProperties.getColumnGroups(); + int blockMdkeyStartOffset = 0; + for (int i = 0; i < colGroups.length; i++) { + if (QueryUtil.searchInArray(colGroups[i], ordinal.get(0))) { + break; + } + blockMdkeyStartOffset += segmentProperties.getDimensionColumnsValueSize()[i]; + } + return blockMdkeyStartOffset; + } + + /** + * return true if given key is found in array + * + * @param data + * @param key + * @return + */ + public static boolean searchInArray(int[] data, int key) { + for (int i = 0; i < data.length; i++) { + if (key == data[i]) { + return true; + } + } + return false; + } + + /** + * Below method will be used to create a mapping of column group columns + * this mapping will have column group id to all the dimension ordinal + * present in the column group This mapping will be used during query + * execution, to create a mask key for the column group dimension which will + * be used in aggregation and filter query as column group dimension will be + * stored in bit level + */ + private static Map<Integer, List<Integer>> getColumnGroupAndItsOrdinalMapping( + List<QueryDimension> origdimensions) { + + List<QueryDimension> dimensions = new ArrayList<QueryDimension>(origdimensions.size()); + dimensions.addAll(origdimensions); + /** + * sort based on column group id + */ + Collections.sort(dimensions, new Comparator<QueryDimension>() { + + @Override public int compare(QueryDimension o1, QueryDimension o2) { + return Integer + .compare(o1.getDimension().columnGroupId(), o2.getDimension().columnGroupId()); + } + }); + // list of row groups this will store all the row group column + Map<Integer, List<Integer>> columnGroupAndItsOrdinalsMapping = + new HashMap<Integer, List<Integer>>(); + // to store a column group + List<Integer> currentColumnGroup = null; + // current index + int index = 0; + // previous column group to check all the column of row id has bee + // selected + int prvColumnGroupId = -1; + while (index < dimensions.size()) { + // if dimension group id is not zero and it is same as the previous + // column group id + // then we need to add ordinal of that column as it belongs to same + // column group + if (!dimensions.get(index).getDimension().isColumnar() + && dimensions.get(index).getDimension().columnGroupId() == prvColumnGroupId) { + currentColumnGroup.add(dimensions.get(index).getDimension().getOrdinal()); + } + + // if dimension is not a columnar then it is column group column + else if (!dimensions.get(index).getDimension().isColumnar()) { + currentColumnGroup = new ArrayList<Integer>(); + columnGroupAndItsOrdinalsMapping + .put(dimensions.get(index).getDimension().columnGroupId(), currentColumnGroup); + currentColumnGroup.add(dimensions.get(index).getDimension().getOrdinal()); + } + // update the row id every time,this is required to group the + // columns + // of the same row group + prvColumnGroupId = dimensions.get(index).getDimension().columnGroupId(); + index++; + } + return columnGroupAndItsOrdinalsMapping; + } + + /** + * Below method will be used to get masked byte + * + * @param data actual data + * @param maxKey max key + * @param maskByteRanges mask byte range + * @param byteCount + * @return masked byte + */ + public static byte[] getMaskedKey(byte[] data, byte[] maxKey, int[] maskByteRanges, + int byteCount) { + byte[] maskedKey = new byte[byteCount]; + int counter = 0; + int byteRange = 0; + for (int i = 0; i < byteCount; i++) { + byteRange = maskByteRanges[i]; + if (byteRange != -1) { + maskedKey[counter++] = (byte) (data[byteRange] & maxKey[byteRange]); + } + } + return maskedKey; + } + + /** + * Below method will be used to fill block indexes of the query dimension + * which will be used in creating a output row Here is method we are passing + * two list which store the indexes one for dictionary column other for not + * dictionary column. This is done for specific purpose so that in one + * iteration we will be able to fill both type dimension block indexes + * + * @param queryDimensions dimension present in the query + * @param columnOrdinalToBlockIndexMapping column ordinal to block index mapping + * @param dictionaryDimensionBlockIndex list to store dictionary column block indexes + * @param noDictionaryDimensionBlockIndex list to store no dictionary block indexes + */ + public static void fillQueryDimensionsBlockIndexes(List<QueryDimension> queryDimensions, + Map<Integer, Integer> columnOrdinalToBlockIndexMapping, + Set<Integer> dictionaryDimensionBlockIndex, List<Integer> noDictionaryDimensionBlockIndex) { + for (QueryDimension queryDimension : queryDimensions) { + if (CarbonUtil.hasEncoding(queryDimension.getDimension().getEncoder(), Encoding.DICTIONARY)) { + dictionaryDimensionBlockIndex + .add(columnOrdinalToBlockIndexMapping.get(queryDimension.getDimension().getOrdinal())); + } else { + noDictionaryDimensionBlockIndex + .add(columnOrdinalToBlockIndexMapping.get(queryDimension.getDimension().getOrdinal())); + } + } + } + + /** + * Below method will be used to resolve the query model + * resolve will be setting the actual dimension and measure object + * as from driver only column name will be passes to avoid the heavy object + * serialization + * + * @param queryModel query model + */ + public static void resolveQueryModel(QueryModel queryModel) { + CarbonMetadata.getInstance().addCarbonTable(queryModel.getTable()); + // TODO need to load the table from table identifier + CarbonTable carbonTable = queryModel.getTable(); + String tableName = + queryModel.getAbsoluteTableIdentifier().getCarbonTableIdentifier().getTableName(); + // resolve query dimension + for (QueryDimension queryDimension : queryModel.getQueryDimension()) { + queryDimension + .setDimension(carbonTable.getDimensionByName(tableName, queryDimension.getColumnName())); + } + // resolve sort dimension + for (QueryDimension sortDimension : queryModel.getSortDimension()) { + sortDimension + .setDimension(carbonTable.getDimensionByName(tableName, sortDimension.getColumnName())); + } + // resolve query measure + for (QueryMeasure queryMeasure : queryModel.getQueryMeasures()) { + // in case of count start column name will be count * so + // for count start add first measure if measure is not present + // than add first dimension as a measure + if (queryMeasure.getColumnName().equals("count(*)")) { + if (carbonTable.getMeasureByTableName(tableName).size() > 0) { + queryMeasure.setMeasure(carbonTable.getMeasureByTableName(tableName).get(0)); + } else { + CarbonMeasure dummyMeasure = new CarbonMeasure( + carbonTable.getDimensionByTableName(tableName).get(0).getColumnSchema(), 0); + queryMeasure.setMeasure(dummyMeasure); + } + } else { + queryMeasure + .setMeasure(carbonTable.getMeasureByName(tableName, queryMeasure.getColumnName())); + } + } + //TODO need to handle expression + } + + /** + * Below method will be used to get the index of number type aggregator + * + * @param aggType + * @return index in aggregator + */ + public static int[] getNumberTypeIndex(List<String> aggType) { + List<Integer> indexList = new ArrayList<Integer>(); + for (int i = 0; i < aggType.size(); i++) { + if (CarbonCommonConstants.SUM.equals(aggType.get(i)) || CarbonCommonConstants.AVERAGE + .equals(aggType.get(i))) { + indexList.add(i); + } + } + return ArrayUtils.toPrimitive(indexList.toArray(new Integer[indexList.size()])); + } + + /** + * below method will be used to get the actual type aggregator + * + * @param aggType + * @return index in aggrgetor + */ + public static int[] getActualTypeIndex(List<String> aggType) { + List<Integer> indexList = new ArrayList<Integer>(); + for (int i = 0; i < aggType.size(); i++) { + if (!CarbonCommonConstants.SUM.equals(aggType.get(i)) && !CarbonCommonConstants.AVERAGE + .equals(aggType.get(i))) { + indexList.add(i); + } + } + return ArrayUtils.toPrimitive(indexList.toArray(new Integer[indexList.size()])); + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/executor/util/RestructureUtil.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/executor/util/RestructureUtil.java b/core/src/main/java/org/carbondata/scan/executor/util/RestructureUtil.java new file mode 100644 index 0000000..92b469c --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/executor/util/RestructureUtil.java @@ -0,0 +1,128 @@ +/* + * 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.carbondata.scan.executor.util; + +import java.util.ArrayList; +import java.util.List; + +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonDimension; +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonMeasure; +import org.carbondata.core.constants.CarbonCommonConstants; +import org.carbondata.scan.executor.infos.AggregatorInfo; +import org.carbondata.scan.model.QueryDimension; +import org.carbondata.scan.model.QueryMeasure; + +/** + * Utility class for restructuring + */ +public class RestructureUtil { + + /** + * Below method will be used to get the updated query dimension updation + * means, after restructuring some dimension will be not present in older + * table blocks in that case we need to select only those dimension out of + * query dimension which is present in the current table block + * + * @param queryDimensions + * @param tableBlockDimensions + * @return list of query dimension which is present in the table block + */ + public static List<QueryDimension> getUpdatedQueryDimension( + List<QueryDimension> queryDimensions, List<CarbonDimension> tableBlockDimensions) { + List<QueryDimension> presentDimension = + new ArrayList<QueryDimension>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE); + // selecting only those dimension which is present in the query + for (QueryDimension queryDimimension : queryDimensions) { + for (CarbonDimension tableDimension : tableBlockDimensions) { + if (tableDimension.equals(queryDimimension.getDimension())) { + presentDimension.add(queryDimimension); + } + } + } + return presentDimension; + } + + /** + * Below method is to add dimension children for complex type dimension as + * internally we are creating dimension column for each each complex + * dimension so when complex query dimension request will come in the query, + * we need to add its children as it is hidden from the user For example if + * complex dimension is of Array of String[2] so we are storing 3 dimension + * and when user will query for complex type i.e. array type we need to add + * its children and then we will read respective block and create a tuple + * based on all three dimension + * + * @param queryDimensions current query dimensions + * @param tableBlockDimensions dimensions which is present in the table block + * @return updated dimension(after adding complex type children) + */ + public static List<CarbonDimension> addChildrenForComplexTypeDimension( + List<CarbonDimension> queryDimensions, List<CarbonDimension> tableBlockDimensions) { + List<CarbonDimension> updatedQueryDimension = new ArrayList<CarbonDimension>(); + int numberOfChildren = 0; + for (CarbonDimension queryDimension : queryDimensions) { + // if number of child is zero, then it is not a complex dimension + // so directly add it query dimension + if (queryDimension.numberOfChild() == 0) { + updatedQueryDimension.add(queryDimension); + } + // if number of child is more than 1 then add all its children + numberOfChildren = queryDimension.getOrdinal() + queryDimension.numberOfChild(); + for (int j = queryDimension.getOrdinal(); j < numberOfChildren; j++) { + updatedQueryDimension.add(tableBlockDimensions.get(j)); + } + } + return updatedQueryDimension; + } + + /** + * Below method will be used to get the aggregator info object + * in this method some of the properties which will be extracted + * from query measure and current block measures will be set + * + * @param queryMeasures measures present in query + * @param currentBlockMeasures current block measures + * @return aggregator info + */ + public static AggregatorInfo getAggregatorInfos(List<QueryMeasure> queryMeasures, + List<CarbonMeasure> currentBlockMeasures) { + AggregatorInfo aggregatorInfos = new AggregatorInfo(); + int numberOfMeasureInQuery = queryMeasures.size(); + int[] measureOrdinals = new int[numberOfMeasureInQuery]; + Object[] defaultValues = new Object[numberOfMeasureInQuery]; + boolean[] measureExistsInCurrentBlock = new boolean[numberOfMeasureInQuery]; + int index = 0; + for (QueryMeasure queryMeasure : queryMeasures) { + measureOrdinals[index] = queryMeasure.getMeasure().getOrdinal(); + // if query measure exists in current dimension measures + // then setting measure exists is true + // otherwise adding a default value of a measure + if (currentBlockMeasures.contains(queryMeasure.getMeasure())) { + measureExistsInCurrentBlock[index] = true; + } else { + defaultValues[index] = queryMeasure.getMeasure().getDefaultValue(); + } + index++; + } + aggregatorInfos.setDefaultValues(defaultValues); + aggregatorInfos.setMeasureOrdinals(measureOrdinals); + aggregatorInfos.setMeasureExists(measureExistsInCurrentBlock); + return aggregatorInfos; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/BinaryExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/BinaryExpression.java b/core/src/main/java/org/carbondata/scan/expression/BinaryExpression.java new file mode 100644 index 0000000..1ad334e --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/BinaryExpression.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.carbondata.scan.expression; + +public abstract class BinaryExpression extends Expression { + + /** + * + */ + private static final long serialVersionUID = 1L; + /** + * + */ + + protected Expression left; + protected Expression right; + protected boolean isRangeExpression; + + public BinaryExpression(Expression left, Expression right) { + this.left = left; + this.right = right; + children.add(left); + children.add(right); + } + + public Expression getLeft() { + return left; + } + + public Expression getRight() { + return right; + } + + public boolean isRangeExpression() { + return isRangeExpression; + } + + public void setRangeExpression(boolean isRangeExpression) { + this.isRangeExpression = isRangeExpression; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/ColumnExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/ColumnExpression.java b/core/src/main/java/org/carbondata/scan/expression/ColumnExpression.java new file mode 100644 index 0000000..922e706 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/ColumnExpression.java @@ -0,0 +1,112 @@ +/* + * 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.carbondata.scan.expression; + +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonColumn; +import org.carbondata.core.carbon.metadata.schema.table.column.CarbonDimension; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class ColumnExpression extends LeafExpression { + + private static final long serialVersionUID = 1L; + + private String columnName; + + private boolean isDimension; + + private int colIndex = -1; + + private DataType dataType; + + private CarbonDimension dimension; + + private CarbonColumn carbonColumn; + + public ColumnExpression(String columnName, DataType dataType) { + this.columnName = columnName; + this.dataType = dataType; + + } + + public CarbonDimension getDimension() { + return dimension; + } + + public void setDimension(CarbonDimension dimension) { + this.dimension = dimension; + } + + public String getColumnName() { + return columnName; + } + + public void setColumnName(String columnName) { + this.columnName = columnName; + } + + public boolean isDimension() { + return isDimension; + } + + public void setDimension(boolean isDimension) { + this.isDimension = isDimension; + } + + public int getColIndex() { + return colIndex; + } + + public void setColIndex(int colIndex) { + this.colIndex = colIndex; + } + + public DataType getDataType() { + return dataType; + } + + public void setDataType(DataType dataType) { + this.dataType = dataType; + } + + @Override public ExpressionResult evaluate(RowIntf value) { + ExpressionResult expressionResult = new ExpressionResult(dataType, value.getVal(colIndex)); + return expressionResult; + } + + @Override public ExpressionType getFilterExpressionType() { + // TODO Auto-generated method stub + return null; + } + + @Override public String getString() { + // TODO Auto-generated method stub + return "ColumnExpression(" + columnName + ')'; + } + + public CarbonColumn getCarbonColumn() { + return carbonColumn; + } + + public void setCarbonColumn(CarbonColumn carbonColumn) { + this.carbonColumn = carbonColumn; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/DataType.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/DataType.java b/core/src/main/java/org/carbondata/scan/expression/DataType.java new file mode 100644 index 0000000..fc9d0bf --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/DataType.java @@ -0,0 +1,34 @@ +/* + * 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.carbondata.scan.expression; + +public enum DataType { + StringType(0), DateType(1), TimestampType(2), BooleanType(1), IntegerType(3), FloatType( + 4), LongType(5), DoubleType(6), NullType(7), DecimalType(8), ArrayType(9), StructType(10); + private int presedenceOrder; + + private DataType(int value) { + this.presedenceOrder = value; + } + + public int getPresedenceOrder() { + return presedenceOrder; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/Expression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/Expression.java b/core/src/main/java/org/carbondata/scan/expression/Expression.java new file mode 100644 index 0000000..01b4fee --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/Expression.java @@ -0,0 +1,48 @@ +/* + * 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.carbondata.scan.expression; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import org.carbondata.core.constants.CarbonCommonConstants; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public abstract class Expression implements Serializable { + + private static final long serialVersionUID = -7568676723039530713L; + protected List<Expression> children = + new ArrayList<Expression>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE); + + public abstract ExpressionResult evaluate(RowIntf value) throws FilterUnsupportedException; + + public abstract ExpressionType getFilterExpressionType(); + + public List<Expression> getChildren() { + return children; + } + + public abstract String getString(); + + // public abstract void accept(ExpressionVisitor visitor); +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/ExpressionResult.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/ExpressionResult.java b/core/src/main/java/org/carbondata/scan/expression/ExpressionResult.java new file mode 100644 index 0000000..decbdc0 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/ExpressionResult.java @@ -0,0 +1,413 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additiona l 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.carbondata.scan.expression; + +import java.math.BigDecimal; +import java.sql.Timestamp; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + +import org.carbondata.core.constants.CarbonCommonConstants; +import org.carbondata.core.util.CarbonProperties; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; + +public class ExpressionResult implements Comparable<ExpressionResult> { + + private static final long serialVersionUID = 1L; + protected DataType dataType; + + protected Object value; + + private List<ExpressionResult> expressionResults; + + public ExpressionResult(DataType dataType, Object value) { + this.dataType = dataType; + this.value = value; + } + + public ExpressionResult(List<ExpressionResult> expressionResults) { + this.expressionResults = expressionResults; + } + + public void set(DataType dataType, Object value) { + this.dataType = dataType; + this.value = value; + this.expressionResults = null; + } + + public DataType getDataType() { + return dataType; + } + + //CHECKSTYLE:OFF Approval No:Approval-V1R2C10_009 + public Integer getInt() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + try { + return Integer.parseInt(value.toString()); + } catch (NumberFormatException e) { + throw new FilterUnsupportedException(e); + } + + case IntegerType: + case DoubleType: + + if (value instanceof Double) { + return ((Double) value).intValue(); + } + return (Integer) value; + + case TimestampType: + + if (value instanceof Timestamp) { + return (int) (((Timestamp) value).getTime() % 1000); + } else { + return (Integer) value; + } + + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to integer type value"); + } + + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Integer type value"); + } + } + + public String getString() { + if (value == null) { + return null; + } + switch (this.getDataType()) { + case TimestampType: + SimpleDateFormat parser = new SimpleDateFormat(CarbonProperties.getInstance() + .getProperty(CarbonCommonConstants.CARBON_TIMESTAMP_FORMAT, + CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT)); + if (value instanceof Timestamp) { + return parser.format((Timestamp) value); + } else { + return parser.format(new Timestamp((long) value / 1000)); + } + + default: + return value.toString(); + } + } + + public Double getDouble() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + try { + return Double.parseDouble(value.toString()); + } catch (NumberFormatException e) { + throw new FilterUnsupportedException(e); + } + + case IntegerType: + return ((Integer) value).doubleValue(); + case LongType: + return ((Long) value).doubleValue(); + case DoubleType: + return (Double) value; + case TimestampType: + if (value instanceof Timestamp) { + return (double) ((Timestamp) value).getTime() * 1000; + } else { + return (Double) (value); + } + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to double type value"); + } + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Double type value"); + } + } + //CHECKSTYLE:ON + + public Long getLong() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + try { + return Long.parseLong(value.toString()); + } catch (NumberFormatException e) { + throw new FilterUnsupportedException(e); + } + + case IntegerType: + return (Long) value; + case LongType: + return (Long) value; + case DoubleType: + return (Long) value; + case TimestampType: + if (value instanceof Timestamp) { + return 1000 * ((Timestamp) value).getTime(); + } else { + return (Long) value; + } + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Long type value"); + } + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Long type value"); + } + + } + + //Add to judge for BigDecimal + public BigDecimal getDecimal() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + try { + return new BigDecimal(value.toString()); + } catch (NumberFormatException e) { + throw new FilterUnsupportedException(e); + } + + case IntegerType: + return new BigDecimal((int) value); + case LongType: + return new BigDecimal((long) value); + case DoubleType: + return new BigDecimal((double) value); + case DecimalType: + return new BigDecimal(value.toString()); + case TimestampType: + if (value instanceof Timestamp) { + return new BigDecimal(1000 * ((Timestamp) value).getTime()); + } else { + return new BigDecimal((long) value); + } + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Long type value"); + } + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Long type value"); + } + + } + + public Long getTime() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + SimpleDateFormat parser = new SimpleDateFormat(CarbonProperties.getInstance() + .getProperty(CarbonCommonConstants.CARBON_TIMESTAMP_FORMAT, + CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT)); + Date dateToStr; + try { + dateToStr = parser.parse(value.toString()); + return dateToStr.getTime() * 1000; + } catch (ParseException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Time/Long type value"); + } + case IntegerType: + case LongType: + return (Long) value; + case DoubleType: + return (Long) value; + case TimestampType: + if (value instanceof Timestamp) { + return ((Timestamp) value).getTime() * 1000; + } else { + return (Long) value; + } + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Time/Long type value"); + } + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Time/Long type value"); + } + + } + + public Boolean getBoolean() throws FilterUnsupportedException { + if (value == null) { + return null; + } + try { + switch (this.getDataType()) { + case StringType: + try { + return Boolean.parseBoolean(value.toString()); + } catch (NumberFormatException e) { + throw new FilterUnsupportedException(e); + } + + case BooleanType: + return Boolean.parseBoolean(value.toString()); + + default: + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to boolean type value"); + } + } catch (ClassCastException e) { + throw new FilterUnsupportedException( + "Cannot convert" + this.getDataType().name() + " to Boolean type value"); + } + } + + public List<ExpressionResult> getList() { + if (null == expressionResults) { + List<ExpressionResult> a = new ArrayList<ExpressionResult>(20); + a.add(new ExpressionResult(dataType, value)); + return a; + } else { + return expressionResults; + } + } + + public List<String> getListAsString() { + List<String> evaluateResultListFinal = new ArrayList<String>(20); + List<ExpressionResult> evaluateResultList = getList(); + for (ExpressionResult result : evaluateResultList) { + if (result.getString() == null) { + evaluateResultListFinal.add(CarbonCommonConstants.MEMBER_DEFAULT_VAL); + continue; + } + evaluateResultListFinal.add(result.getString()); + } + return evaluateResultListFinal; + } + + @Override public int hashCode() { + final int prime = 31; + int result = 1; + if (null != expressionResults) { + result = prime * result + expressionResults.hashCode(); + } else if (null != value) { + result = prime * result + value.toString().hashCode(); + } else { + result = prime * result + "".hashCode(); + } + + return result; + } + + @Override public boolean equals(Object obj) { + if (!(obj instanceof ExpressionResult)) { + return false; + } + if (this == obj) { + return true; + } + if (getClass() != obj.getClass()) { + return false; + } + ExpressionResult objToCompare = (ExpressionResult) obj; + boolean result = false; + if (this.value == objToCompare.value) { + return true; + } + try { + switch (this.getDataType()) { + case StringType: + result = this.getString().equals(objToCompare.getString()); + break; + case IntegerType: + result = this.getInt().equals(objToCompare.getInt()); + break; + + case DoubleType: + result = this.getDouble().equals(objToCompare.getDouble()); + break; + case TimestampType: + result = this.getLong().equals(objToCompare.getLong()); + break; + default: + break; + } + } catch (FilterUnsupportedException ex) { + return false; + } + + return result; + } + + public boolean isNull() { + return value == null; + } + + @Override public int compareTo(ExpressionResult o) { + try { + switch (o.dataType) { + case IntegerType: + case LongType: + case DoubleType: + + Double d1 = this.getDouble(); + Double d2 = o.getDouble(); + return d1.compareTo(d2); + case DecimalType: + java.math.BigDecimal val1 = this.getDecimal(); + java.math.BigDecimal val2 = o.getDecimal(); + return val1.compareTo(val2); + case TimestampType: + SimpleDateFormat parser = new SimpleDateFormat(CarbonProperties.getInstance() + .getProperty(CarbonCommonConstants.CARBON_TIMESTAMP_FORMAT, + CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT)); + Date date1 = null; + Date date2 = null; + date1 = parser.parse(this.getString()); + date2 = parser.parse(o.getString()); + return date1.compareTo(date2); + case StringType: + default: + return this.getString().compareTo(o.getString()); + } + } catch (Exception e) { + return -1; + } + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/LeafExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/LeafExpression.java b/core/src/main/java/org/carbondata/scan/expression/LeafExpression.java new file mode 100644 index 0000000..2392910 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/LeafExpression.java @@ -0,0 +1,24 @@ +/* + * 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.carbondata.scan.expression; + +public abstract class LeafExpression extends Expression { + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/LiteralExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/LiteralExpression.java b/core/src/main/java/org/carbondata/scan/expression/LiteralExpression.java new file mode 100644 index 0000000..edbaf44 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/LiteralExpression.java @@ -0,0 +1,68 @@ +/* + * 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.carbondata.scan.expression; + +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class LiteralExpression extends LeafExpression { + + /** + * + */ + private static final long serialVersionUID = 1L; + private Object value; + private DataType dataType; + + public LiteralExpression(Object value, DataType dataType) { + this.value = value; + this.dataType = dataType; + } + + @Override public ExpressionResult evaluate(RowIntf value) { + ExpressionResult expressionResult = new ExpressionResult(dataType, this.value); + return expressionResult; + } + + public ExpressionResult getExpressionResult() { + ExpressionResult expressionResult = new ExpressionResult(dataType, this.value); + return expressionResult; + } + + @Override public ExpressionType getFilterExpressionType() { + // TODO Auto-generated method stub + return ExpressionType.LITERAL; + } + + @Override public String getString() { + // TODO Auto-generated method stub + return "LiteralExpression(" + value + ')'; + } + + /** + * getLiteralExpDataType. + * + * @return + */ + public DataType getLiteralExpDataType() { + return dataType; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/UnaryExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/UnaryExpression.java b/core/src/main/java/org/carbondata/scan/expression/UnaryExpression.java new file mode 100644 index 0000000..0449b66 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/UnaryExpression.java @@ -0,0 +1,33 @@ +/* + * 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.carbondata.scan.expression; + +public abstract class UnaryExpression extends Expression { + + private static final long serialVersionUID = 1L; + protected Expression child; + + public UnaryExpression(Expression child) { + this.child = child; + children.add(child); + + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/UnknownExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/UnknownExpression.java b/core/src/main/java/org/carbondata/scan/expression/UnknownExpression.java new file mode 100644 index 0000000..3f24e1c --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/UnknownExpression.java @@ -0,0 +1,9 @@ +package org.carbondata.scan.expression; + +import java.util.List; + +public abstract class UnknownExpression extends Expression { + + public abstract List<ColumnExpression> getAllColumnList(); + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/arithmetic/AddExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/arithmetic/AddExpression.java b/core/src/main/java/org/carbondata/scan/expression/arithmetic/AddExpression.java new file mode 100644 index 0000000..e7ce159 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/arithmetic/AddExpression.java @@ -0,0 +1,81 @@ +/* + * 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.carbondata.scan.expression.arithmetic; + +import org.carbondata.scan.expression.DataType; +import org.carbondata.scan.expression.Expression; +import org.carbondata.scan.expression.ExpressionResult; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class AddExpression extends BinaryArithmeticExpression { + private static final long serialVersionUID = 7999436055420911612L; + + public AddExpression(Expression left, Expression right) { + super(left, right); + } + + @Override public ExpressionResult evaluate(RowIntf value) throws FilterUnsupportedException { + ExpressionResult addExprLeftRes = left.evaluate(value); + ExpressionResult addExprRightRes = right.evaluate(value); + ExpressionResult val1 = addExprLeftRes; + ExpressionResult val2 = addExprRightRes; + if (addExprLeftRes.isNull() || addExprRightRes.isNull()) { + addExprLeftRes.set(addExprLeftRes.getDataType(), null); + return addExprLeftRes; + } + + if (addExprLeftRes.getDataType() != addExprRightRes.getDataType()) { + if (addExprLeftRes.getDataType().getPresedenceOrder() < addExprRightRes.getDataType() + .getPresedenceOrder()) { + val2 = addExprLeftRes; + val1 = addExprRightRes; + } + } + switch (val1.getDataType()) { + case StringType: + case DoubleType: + addExprRightRes.set(DataType.DoubleType, val1.getDouble() + val2.getDouble()); + break; + case IntegerType: + addExprRightRes.set(DataType.IntegerType, val1.getInt() + val2.getInt()); + break; + case LongType: + addExprRightRes.set(DataType.LongType, val1.getLong() + val2.getLong()); + break; + case DecimalType: + addExprRightRes.set(DataType.DecimalType, val1.getDecimal().add(val2.getDecimal())); + break; + default: + throw new FilterUnsupportedException( + "Incompatible datatype for applying Add Expression Filter " + val1.getDataType()); + } + return addExprRightRes; + } + + @Override public ExpressionType getFilterExpressionType() { + return ExpressionType.ADD; + } + + @Override public String getString() { + return "Add(" + left.getString() + ',' + right.getString() + ','; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/arithmetic/BinaryArithmeticExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/arithmetic/BinaryArithmeticExpression.java b/core/src/main/java/org/carbondata/scan/expression/arithmetic/BinaryArithmeticExpression.java new file mode 100644 index 0000000..9c109f7 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/arithmetic/BinaryArithmeticExpression.java @@ -0,0 +1,34 @@ +/* + * 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.carbondata.scan.expression.arithmetic; + +import org.carbondata.scan.expression.BinaryExpression; +import org.carbondata.scan.expression.Expression; + +public abstract class BinaryArithmeticExpression extends BinaryExpression { + + private static final long serialVersionUID = 1L; + + public BinaryArithmeticExpression(Expression left, Expression right) { + super(left, right); + // TODO Auto-generated constructor stub + } + +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/arithmetic/DivideExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/arithmetic/DivideExpression.java b/core/src/main/java/org/carbondata/scan/expression/arithmetic/DivideExpression.java new file mode 100644 index 0000000..f4df604 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/arithmetic/DivideExpression.java @@ -0,0 +1,81 @@ +/* + * 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.carbondata.scan.expression.arithmetic; + +import org.carbondata.scan.expression.DataType; +import org.carbondata.scan.expression.Expression; +import org.carbondata.scan.expression.ExpressionResult; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class DivideExpression extends BinaryArithmeticExpression { + private static final long serialVersionUID = -7269266926782365612L; + + public DivideExpression(Expression left, Expression right) { + super(left, right); + } + + @Override public ExpressionResult evaluate(RowIntf value) throws FilterUnsupportedException { + ExpressionResult divideExprLeftRes = left.evaluate(value); + ExpressionResult divideExprRightRes = right.evaluate(value); + ExpressionResult val1 = divideExprLeftRes; + ExpressionResult val2 = divideExprRightRes; + if (divideExprLeftRes.isNull() || divideExprRightRes.isNull()) { + divideExprLeftRes.set(divideExprLeftRes.getDataType(), null); + return divideExprLeftRes; + } + if (divideExprLeftRes.getDataType() != divideExprRightRes.getDataType()) { + if (divideExprLeftRes.getDataType().getPresedenceOrder() < divideExprRightRes.getDataType() + .getPresedenceOrder()) { + val2 = divideExprLeftRes; + val1 = divideExprRightRes; + } + } + switch (val1.getDataType()) { + case StringType: + case DoubleType: + divideExprRightRes.set(DataType.DoubleType, val1.getDouble() / val2.getDouble()); + break; + case IntegerType: + divideExprRightRes.set(DataType.IntegerType, val1.getInt() / val2.getInt()); + break; + case LongType: + divideExprRightRes.set(DataType.LongType, val1.getLong() / val2.getLong()); + break; + case DecimalType: + divideExprRightRes.set(DataType.DecimalType, val1.getDecimal().divide(val2.getDecimal())); + break; + default: + throw new FilterUnsupportedException( + "Incompatible datatype for applying Add Expression Filter " + divideExprLeftRes + .getDataType()); + } + return divideExprRightRes; + } + + @Override public ExpressionType getFilterExpressionType() { + return ExpressionType.DIVIDE; + } + + @Override public String getString() { + return "Divide(" + left.getString() + ',' + right.getString() + ')'; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/arithmetic/MultiplyExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/arithmetic/MultiplyExpression.java b/core/src/main/java/org/carbondata/scan/expression/arithmetic/MultiplyExpression.java new file mode 100644 index 0000000..3347250 --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/arithmetic/MultiplyExpression.java @@ -0,0 +1,83 @@ +/* + * 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.carbondata.scan.expression.arithmetic; + +import org.carbondata.scan.expression.DataType; +import org.carbondata.scan.expression.Expression; +import org.carbondata.scan.expression.ExpressionResult; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class MultiplyExpression extends BinaryArithmeticExpression { + private static final long serialVersionUID = 1L; + + public MultiplyExpression(Expression left, Expression right) { + super(left, right); + } + + @Override public ExpressionResult evaluate(RowIntf value) throws FilterUnsupportedException { + ExpressionResult multiplyExprLeftRes = left.evaluate(value); + ExpressionResult multiplyExprRightRes = right.evaluate(value); + ExpressionResult val1 = multiplyExprLeftRes; + ExpressionResult val2 = multiplyExprRightRes; + if (multiplyExprLeftRes.isNull() || multiplyExprRightRes.isNull()) { + multiplyExprLeftRes.set(multiplyExprLeftRes.getDataType(), null); + return multiplyExprLeftRes; + } + + if (multiplyExprLeftRes.getDataType() != multiplyExprRightRes.getDataType()) { + if (multiplyExprLeftRes.getDataType().getPresedenceOrder() < multiplyExprRightRes + .getDataType().getPresedenceOrder()) { + val2 = multiplyExprLeftRes; + val1 = multiplyExprRightRes; + } + } + switch (val1.getDataType()) { + case StringType: + case DoubleType: + multiplyExprRightRes.set(DataType.DoubleType, val1.getDouble() * val2.getDouble()); + break; + case IntegerType: + multiplyExprRightRes.set(DataType.IntegerType, val1.getInt() * val2.getInt()); + break; + case LongType: + multiplyExprRightRes.set(DataType.LongType, val1.getLong() * val2.getLong()); + break; + case DecimalType: + multiplyExprRightRes + .set(DataType.DecimalType, val1.getDecimal().multiply(val2.getDecimal())); + break; + default: + throw new FilterUnsupportedException( + "Incompatible datatype for applying Add Expression Filter " + multiplyExprLeftRes + .getDataType()); + } + return multiplyExprRightRes; + } + + @Override public ExpressionType getFilterExpressionType() { + return ExpressionType.MULTIPLY; + } + + @Override public String getString() { + return "Substract(" + left.getString() + ',' + right.getString() + ')'; + } +} http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/1c725f5b/core/src/main/java/org/carbondata/scan/expression/arithmetic/SubstractExpression.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/carbondata/scan/expression/arithmetic/SubstractExpression.java b/core/src/main/java/org/carbondata/scan/expression/arithmetic/SubstractExpression.java new file mode 100644 index 0000000..35fec1c --- /dev/null +++ b/core/src/main/java/org/carbondata/scan/expression/arithmetic/SubstractExpression.java @@ -0,0 +1,83 @@ +/* + * 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.carbondata.scan.expression.arithmetic; + +import org.carbondata.scan.expression.DataType; +import org.carbondata.scan.expression.Expression; +import org.carbondata.scan.expression.ExpressionResult; +import org.carbondata.scan.expression.exception.FilterUnsupportedException; +import org.carbondata.scan.filter.intf.ExpressionType; +import org.carbondata.scan.filter.intf.RowIntf; + +public class SubstractExpression extends BinaryArithmeticExpression { + + private static final long serialVersionUID = -8304726440185363102L; + + public SubstractExpression(Expression left, Expression right) { + super(left, right); + } + + @Override public ExpressionResult evaluate(RowIntf value) throws FilterUnsupportedException { + ExpressionResult subtractExprLeftRes = left.evaluate(value); + ExpressionResult subtractExprRightRes = right.evaluate(value); + ExpressionResult val1 = subtractExprLeftRes; + ExpressionResult val2 = subtractExprRightRes; + if (subtractExprLeftRes.isNull() || subtractExprRightRes.isNull()) { + subtractExprLeftRes.set(subtractExprLeftRes.getDataType(), null); + return subtractExprLeftRes; + } + if (subtractExprLeftRes.getDataType() != subtractExprRightRes.getDataType()) { + if (subtractExprLeftRes.getDataType().getPresedenceOrder() < subtractExprRightRes + .getDataType().getPresedenceOrder()) { + val2 = subtractExprLeftRes; + val1 = subtractExprRightRes; + } + } + switch (val1.getDataType()) { + case StringType: + case DoubleType: + subtractExprRightRes.set(DataType.DoubleType, val1.getDouble() - val2.getDouble()); + break; + case IntegerType: + subtractExprRightRes.set(DataType.IntegerType, val1.getInt() - val2.getInt()); + break; + case LongType: + subtractExprRightRes.set(DataType.LongType, val1.getLong() - val2.getLong()); + break; + case DecimalType: + subtractExprRightRes + .set(DataType.DecimalType, val1.getDecimal().subtract(val2.getDecimal())); + break; + default: + throw new FilterUnsupportedException( + "Incompatible datatype for applying Add Expression Filter " + subtractExprLeftRes + .getDataType()); + } + return subtractExprRightRes; + } + + @Override public ExpressionType getFilterExpressionType() { + return ExpressionType.SUBSTRACT; + } + + @Override public String getString() { + return "Substract(" + left.getString() + ',' + right.getString() + ')'; + } +}
