10226

Build # 10226

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/2e781c3a4b59d489365557da7e24312fe8fc1b8e">2e781c3a4<a href="https://github.com/apache/carbondata/commit/2e781c3a4b59d489365557da7e24312fe8fc1b8e">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/1ee487334418067d56eb6f2cb20caeec4b0f2667">1ee487334</a>">1ee487334</a><a href="https://github.com/apache/carbondata/commit/2e781c3a4b59d489365557da7e24312fe8fc1b8e"> into ca32374a4">ca32374a4</a>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

61508 of 77866 relevant lines covered (78.99%)

1.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.88

/store/sdk/src/main/java/org/apache/carbondata/sdk/file/Field.java

/*
 * 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.sdk.file;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.apache.carbondata.common.annotations.InterfaceAudience;
import org.apache.carbondata.common.annotations.InterfaceStability;
import org.apache.carbondata.core.metadata.datatype.ArrayType;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.metadata.datatype.MapType;
import org.apache.carbondata.core.metadata.datatype.StructField;
import org.apache.carbondata.core.metadata.datatype.StructType;
import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;

/**
 * A field represent one column
 */
@InterfaceAudience.User
@InterfaceStability.Unstable
public class Field {

  private String name;
  private DataType type;
  private List<StructField> children;
  private String parent;
  private String storeType = "columnar";
  private int schemaOrdinal = -1;
  private int precision = 0;
  private int scale = 0;
  private String rawSchema = "";
  private String columnComment = "";

  /**
   * Field Constructor
   * @param name name of the field
   * @param type datatype of field, specified in strings.
   */
  public Field(String name, String type) {
    this.name = name.toLowerCase().trim();
    if (type.equalsIgnoreCase("string")) {
      this.type = DataTypes.STRING;
    } else if (type.equalsIgnoreCase("varchar")) {
      this.type = DataTypes.VARCHAR;
    } else if (type.equalsIgnoreCase("date")) {
      this.type = DataTypes.DATE;
    } else if (type.equalsIgnoreCase("timestamp")) {
      this.type = DataTypes.TIMESTAMP;
    } else if (type.equalsIgnoreCase("boolean")) {
      this.type = DataTypes.BOOLEAN;
    } else if (type.equalsIgnoreCase("byte")) {
      this.type = DataTypes.BYTE;
    } else if (type.equalsIgnoreCase("short")) {
      this.type = DataTypes.SHORT;
    } else if (type.equalsIgnoreCase("int")) {
      this.type = DataTypes.INT;
    } else if (type.equalsIgnoreCase("long")) {
      this.type = DataTypes.LONG;
    } else if (type.equalsIgnoreCase("float")) {
      this.type = DataTypes.FLOAT;
    } else if (type.equalsIgnoreCase("double")) {
      this.type = DataTypes.DOUBLE;
    } else if (type.equalsIgnoreCase("array")) {
      this.type = DataTypes.createDefaultArrayType();
    } else if (type.equalsIgnoreCase("struct")) {
      this.type = DataTypes.createDefaultStructType();
    } else if (type.equalsIgnoreCase("map")) {
      this.type = DataTypes.createDefaultMapType();
    } else {
      throw new IllegalArgumentException("unsupported data type: " + type);
    }
  }

  public Field(String name, String type, List<StructField> fields) {
    this.name = name.toLowerCase().trim();
    this.children = fields;
    if (type.equalsIgnoreCase("string")) {
      this.type = DataTypes.STRING;
    } else if (type.equalsIgnoreCase("varchar")) {
      this.type = DataTypes.VARCHAR;
    } else if (type.equalsIgnoreCase("date")) {
      this.type = DataTypes.DATE;
    } else if (type.equalsIgnoreCase("timestamp")) {
      this.type = DataTypes.TIMESTAMP;
    } else if (type.equalsIgnoreCase("boolean")) {
      this.type = DataTypes.BOOLEAN;
    } else if (type.equalsIgnoreCase("byte")) {
      this.type = DataTypes.BYTE;
    } else if (type.equalsIgnoreCase("short")) {
      this.type = DataTypes.SHORT;
    } else if (type.equalsIgnoreCase("int")) {
      this.type = DataTypes.INT;
    } else if (type.equalsIgnoreCase("long")) {
      this.type = DataTypes.LONG;
    } else if (type.equalsIgnoreCase("float")) {
      this.type = DataTypes.FLOAT;
    } else if (type.equalsIgnoreCase("double")) {
      this.type = DataTypes.DOUBLE;
    } else if (type.equalsIgnoreCase("array")) {
      this.type = DataTypes.createArrayType(fields.get(0).getDataType());
    } else if (type.equalsIgnoreCase("struct")) {
      this.type = DataTypes.createStructType(fields);
    } else {
      throw new IllegalArgumentException("unsupported data type: " + type);
    }
  }



  public Field(String name, DataType type, List<StructField> fields) {
    this.name = name.toLowerCase().trim();
    this.type = type;
    this.children = fields;
  }

  public Field(String name, DataType type) {
    this.name = name.toLowerCase().trim();
    this.type = type;
    initComplexTypeChildren();
  }

  /**
   * Construct Field from ColumnSchema
   *
   * @param columnSchema ColumnSchema, Store the information about the column meta data
   */
  public Field(ColumnSchema columnSchema) {
    this.name = columnSchema.getColumnName().toLowerCase().trim();
    this.type = columnSchema.getDataType();
    children = new LinkedList<>();
    schemaOrdinal = columnSchema.getSchemaOrdinal();
    precision = columnSchema.getPrecision();
    scale = columnSchema.getScale();
  }

  public String getFieldName() {
    return name;
  }

  public DataType getDataType() {
    return type;
  }

  public List<StructField> getChildren() {
    return children;
  }

  public void setChildren(List<StructField> children) {
    this.children = children;
  }

  public String getParent() {
    return parent;
  }

  public void setParent(String parent) {
    this.parent = parent;
  }

  public String getStoreType() {
    return storeType;
  }

  public int getSchemaOrdinal() {
    return schemaOrdinal;
  }

  public void setSchemaOrdinal(int schemaOrdinal) {
    this.schemaOrdinal = schemaOrdinal;
  }

  public int getPrecision() {
    return precision;
  }

  public void setPrecision(int precision) {
    this.precision = precision;
  }

  public int getScale() {
    return scale;
  }

  public void setScale(int scale) {
    this.scale = scale;
  }

  public String getRawSchema() {
    return rawSchema;
  }

  public void setRawSchema(String rawSchema) {
    this.rawSchema = rawSchema;
  }

  public String getColumnComment() {
    return columnComment;
  }

  public void setColumnComment(String columnComment) {
    this.columnComment = columnComment;
  }

  /* for SDK, change string type to varchar by default for parent columns */
  public void updateDataTypeToVarchar() {
    this.type = DataTypes.VARCHAR;
  }

  private void initComplexTypeChildren() {
    if (getDataType().isComplexType()) {
      StructField subFields = prepareSubFields(getFieldName(), getDataType());
      if (DataTypes.isArrayType(getDataType()) || DataTypes.isMapType(getDataType())) {
        children = subFields.getChildren();
      } else if (DataTypes.isStructType(getDataType())) {
        children = ((StructType) subFields.getDataType()).getFields();
      }
    }
  }

  @Override
  public String toString() {
    return "Field{" +
        "name='" + name + '\'' +
        ", type=" + type +
        ", schemaOrdinal=" + schemaOrdinal +
        '}';
  }

  /**
   * prepare sub fields for complex types
   *
   * @param fieldName column name
   * @param dataType data type of column or it's children
   * @return
   */
  private StructField prepareSubFields(String fieldName, DataType dataType) {
    if (DataTypes.isArrayType(dataType)) {
      List<StructField> arrayFields = new ArrayList<>();
      StructField arrayField = prepareSubFields(fieldName, ((ArrayType) dataType).getElementType());
      arrayFields.add(arrayField);
      return new StructField(fieldName, DataTypes.createArrayType(arrayField.getDataType()),
          arrayFields);
    } else if (DataTypes.isStructType(dataType)) {
      List<StructField> structFields = new ArrayList<>();
      List<StructField> fields = ((StructType) dataType).getFields();
      for (StructField field : fields) {
        structFields.add(prepareSubFields(field.getFieldName(), field.getDataType()));
      }
      return new StructField(fieldName, DataTypes.createStructType(structFields), structFields);
    } else if (DataTypes.isMapType(dataType)) {
      // Internally Map<key, value> is stored as Array<struct<key, value>>. So the below method
      // will convert a map type into similar field structure. The columnSchema will be formed
      // as Map<Struct<key,value>>
      List<StructField> mapFields = new ArrayList<>();
      MapType mapType = (MapType) dataType;
      // key is primitive type so type can be fetched directly
      StructField keyField = new StructField(fieldName + ".key", mapType.getKeyType());
      StructField valueField = prepareSubFields(fieldName + ".value", mapType.getValueType());
      mapFields.add(keyField);
      mapFields.add(valueField);
      StructField field =
          new StructField(fieldName + ".val", DataTypes.createStructType(mapFields));
      MapType mapDataType = DataTypes.createMapType(keyField.getDataType(), field.getDataType());
      List<StructField> mapStructField = new ArrayList<>();
      mapStructField.add(field);
      return new StructField(fieldName, mapDataType, mapStructField);
    } else {
      return new StructField(fieldName, dataType);
    }
  }

  @Override
  public int hashCode() {
    return super.hashCode();
  }

  @Override
  public boolean equals(Object obj) {
    if (obj instanceof Field) {
      Field field = (Field) obj;
      if ((!this.getDataType().equals(field.getDataType()))
          || (!this.getFieldName().equals(field.getFieldName()))
          || (!(this.getSchemaOrdinal() == (field.getSchemaOrdinal())))
          ) {
        return false;
      }
    } else {
      return false;
    }
    return true;
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.carbondata.sdk.file;
19
20	import java.util.ArrayList;
21	import java.util.LinkedList;
22	import java.util.List;
23
24	import org.apache.carbondata.common.annotations.InterfaceAudience;
25	import org.apache.carbondata.common.annotations.InterfaceStability;
26	import org.apache.carbondata.core.metadata.datatype.ArrayType;
27	import org.apache.carbondata.core.metadata.datatype.DataType;
28	import org.apache.carbondata.core.metadata.datatype.DataTypes;
29	import org.apache.carbondata.core.metadata.datatype.MapType;
30	import org.apache.carbondata.core.metadata.datatype.StructField;
31	import org.apache.carbondata.core.metadata.datatype.StructType;
32	import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
33
34	/**
35	* A field represent one column
36	*/
37	@InterfaceAudience.User
38	@InterfaceStability.Unstable
39	public class Field {
40
41	private String name;
42	private DataType type;
43	private List<StructField> children;
44	private String parent;
45	private String storeType = "columnar";	2✔
46	private int schemaOrdinal = -1;	2✔
47	private int precision = 0;	2✔
48	private int scale = 0;	2✔
49	private String rawSchema = "";	2✔
50	private String columnComment = "";	2✔
51
52	/**
53	* Field Constructor
54	* @param name name of the field
55	* @param type datatype of field, specified in strings.
56	*/
57	public Field(String name, String type) {	2✔
58	this.name = name.toLowerCase().trim();	2✔
59	if (type.equalsIgnoreCase("string")) {	2✔
60	this.type = DataTypes.STRING;	2✔
61	} else if (type.equalsIgnoreCase("varchar")) {	2✔
62	this.type = DataTypes.VARCHAR;	×
63	} else if (type.equalsIgnoreCase("date")) {	2✔
64	this.type = DataTypes.DATE;	×
65	} else if (type.equalsIgnoreCase("timestamp")) {	2✔
66	this.type = DataTypes.TIMESTAMP;	×
67	} else if (type.equalsIgnoreCase("boolean")) {	2✔
68	this.type = DataTypes.BOOLEAN;	×
69	} else if (type.equalsIgnoreCase("byte")) {	2✔
70	this.type = DataTypes.BYTE;	×
71	} else if (type.equalsIgnoreCase("short")) {	2✔
72	this.type = DataTypes.SHORT;	×
73	} else if (type.equalsIgnoreCase("int")) {	2✔
74	this.type = DataTypes.INT;	2✔
75	} else if (type.equalsIgnoreCase("long")) {	2✔
76	this.type = DataTypes.LONG;	×
77	} else if (type.equalsIgnoreCase("float")) {	2✔
78	this.type = DataTypes.FLOAT;	×
79	} else if (type.equalsIgnoreCase("double")) {	2✔
80	this.type = DataTypes.DOUBLE;	2✔
81	} else if (type.equalsIgnoreCase("array")) {	×
82	this.type = DataTypes.createDefaultArrayType();	×
83	} else if (type.equalsIgnoreCase("struct")) {	×
84	this.type = DataTypes.createDefaultStructType();	×
85	} else if (type.equalsIgnoreCase("map")) {	×
86	this.type = DataTypes.createDefaultMapType();	×
87	} else {
88	throw new IllegalArgumentException("unsupported data type: " + type);	×
89	}
90	}	2✔
91
92	public Field(String name, String type, List<StructField> fields) {	2✔
93	this.name = name.toLowerCase().trim();	2✔
94	this.children = fields;	2✔
95	if (type.equalsIgnoreCase("string")) {	2✔
96	this.type = DataTypes.STRING;	×
97	} else if (type.equalsIgnoreCase("varchar")) {	2✔
98	this.type = DataTypes.VARCHAR;	×
99	} else if (type.equalsIgnoreCase("date")) {	2✔
100	this.type = DataTypes.DATE;	×
101	} else if (type.equalsIgnoreCase("timestamp")) {	2✔
102	this.type = DataTypes.TIMESTAMP;	×
103	} else if (type.equalsIgnoreCase("boolean")) {	2✔
104	this.type = DataTypes.BOOLEAN;	×
105	} else if (type.equalsIgnoreCase("byte")) {	2✔
106	this.type = DataTypes.BYTE;	×
107	} else if (type.equalsIgnoreCase("short")) {	2✔
108	this.type = DataTypes.SHORT;	×
109	} else if (type.equalsIgnoreCase("int")) {	2✔
110	this.type = DataTypes.INT;	×
111	} else if (type.equalsIgnoreCase("long")) {	2✔
112	this.type = DataTypes.LONG;	×
113	} else if (type.equalsIgnoreCase("float")) {	2✔
114	this.type = DataTypes.FLOAT;	×
115	} else if (type.equalsIgnoreCase("double")) {	2✔
116	this.type = DataTypes.DOUBLE;	×
117	} else if (type.equalsIgnoreCase("array")) {	2✔
118	this.type = DataTypes.createArrayType(fields.get(0).getDataType());	2✔
119	} else if (type.equalsIgnoreCase("struct")) {	2✔
120	this.type = DataTypes.createStructType(fields);	2✔
121	} else {
122	throw new IllegalArgumentException("unsupported data type: " + type);	×
123	}
124	}	2✔
125
126
127
128	public Field(String name, DataType type, List<StructField> fields) {	2✔
129	this.name = name.toLowerCase().trim();	2✔
130	this.type = type;	2✔
131	this.children = fields;	2✔
132	}	2✔
133
134	public Field(String name, DataType type) {	2✔
135	this.name = name.toLowerCase().trim();	2✔
136	this.type = type;	2✔
137	initComplexTypeChildren();	2✔
138	}	2✔
139
140	/**
141	* Construct Field from ColumnSchema
142	*
143	* @param columnSchema ColumnSchema, Store the information about the column meta data
144	*/
145	public Field(ColumnSchema columnSchema) {	2✔
146	this.name = columnSchema.getColumnName().toLowerCase().trim();	2✔
147	this.type = columnSchema.getDataType();	2✔
148	children = new LinkedList<>();	2✔
149	schemaOrdinal = columnSchema.getSchemaOrdinal();	2✔
150	precision = columnSchema.getPrecision();	2✔
151	scale = columnSchema.getScale();	2✔
152	}	2✔
153
154	public String getFieldName() {
155	return name;	2✔
156	}
157
158	public DataType getDataType() {
159	return type;	2✔
160	}
161
162	public List<StructField> getChildren() {
163	return children;	2✔
164	}
165
166	public void setChildren(List<StructField> children) {
167	this.children = children;	×
168	}	×
169
170	public String getParent() {
171	return parent;	×
172	}
173
174	public void setParent(String parent) {
175	this.parent = parent;	×
176	}	×
177
178	public String getStoreType() {
179	return storeType;	×
180	}
181
182	public int getSchemaOrdinal() {
183	return schemaOrdinal;	2✔
184	}
185
186	public void setSchemaOrdinal(int schemaOrdinal) {
187	this.schemaOrdinal = schemaOrdinal;	×
188	}	×
189
190	public int getPrecision() {
191	return precision;	×
192	}
193
194	public void setPrecision(int precision) {
195	this.precision = precision;	×
196	}	×
197
198	public int getScale() {
199	return scale;	×
200	}
201
202	public void setScale(int scale) {
203	this.scale = scale;	×
204	}	×
205
206	public String getRawSchema() {
207	return rawSchema;	×
208	}
209
210	public void setRawSchema(String rawSchema) {
211	this.rawSchema = rawSchema;	×
212	}	×
213
214	public String getColumnComment() {
215	return columnComment;	×
216	}
217
218	public void setColumnComment(String columnComment) {
219	this.columnComment = columnComment;	×
220	}	×
221
222	/* for SDK, change string type to varchar by default for parent columns */
223	public void updateDataTypeToVarchar() {
224	this.type = DataTypes.VARCHAR;	×
225	}	×
226
227	private void initComplexTypeChildren() {
228	if (getDataType().isComplexType()) {	2✔
229	StructField subFields = prepareSubFields(getFieldName(), getDataType());	2✔
230	if (DataTypes.isArrayType(getDataType()) \|\| DataTypes.isMapType(getDataType())) {	2✔
231	children = subFields.getChildren();	2✔
232	} else if (DataTypes.isStructType(getDataType())) {	1✔
233	children = ((StructType) subFields.getDataType()).getFields();	1✔
234	}
235	}
236	}	2✔
237
238	@Override
239	public String toString() {
240	return "Field{" +	×
241	"name='" + name + '\'' +
242	", type=" + type +
243	", schemaOrdinal=" + schemaOrdinal +
244	'}';
245	}
246
247	/**
248	* prepare sub fields for complex types
249	*
250	* @param fieldName column name
251	* @param dataType data type of column or it's children
252	* @return
253	*/
254	private StructField prepareSubFields(String fieldName, DataType dataType) {
255	if (DataTypes.isArrayType(dataType)) {	2✔
256	List<StructField> arrayFields = new ArrayList<>();	2✔
257	StructField arrayField = prepareSubFields(fieldName, ((ArrayType) dataType).getElementType());	2✔
258	arrayFields.add(arrayField);	2✔
259	return new StructField(fieldName, DataTypes.createArrayType(arrayField.getDataType()),	2✔
260	arrayFields);
261	} else if (DataTypes.isStructType(dataType)) {	2✔
262	List<StructField> structFields = new ArrayList<>();	1✔
263	List<StructField> fields = ((StructType) dataType).getFields();	1✔
264	for (StructField field : fields) {	1✔
265	structFields.add(prepareSubFields(field.getFieldName(), field.getDataType()));	1✔
266	}	1✔
267	return new StructField(fieldName, DataTypes.createStructType(structFields), structFields);	1✔
268	} else if (DataTypes.isMapType(dataType)) {	2✔
269	// Internally Map<key, value> is stored as Array<struct<key, value>>. So the below method
270	// will convert a map type into similar field structure. The columnSchema will be formed
271	// as Map<Struct<key,value>>
272	List<StructField> mapFields = new ArrayList<>();	2✔
273	MapType mapType = (MapType) dataType;	2✔
274	// key is primitive type so type can be fetched directly
275	StructField keyField = new StructField(fieldName + ".key", mapType.getKeyType());	2✔
276	StructField valueField = prepareSubFields(fieldName + ".value", mapType.getValueType());	2✔
277	mapFields.add(keyField);	2✔
278	mapFields.add(valueField);	2✔
279	StructField field =	2✔
280	new StructField(fieldName + ".val", DataTypes.createStructType(mapFields));	2✔
281	MapType mapDataType = DataTypes.createMapType(keyField.getDataType(), field.getDataType());	2✔
282	List<StructField> mapStructField = new ArrayList<>();	2✔
283	mapStructField.add(field);	2✔
284	return new StructField(fieldName, mapDataType, mapStructField);	2✔
285	} else {
286	return new StructField(fieldName, dataType);	2✔
287	}
288	}
289
290	@Override
291	public int hashCode() {
292	return super.hashCode();	×
293	}
294
295	@Override
296	public boolean equals(Object obj) {
297	if (obj instanceof Field) {	2✔
298	Field field = (Field) obj;	2✔
299	if ((!this.getDataType().equals(field.getDataType()))	2✔
300	\|\| (!this.getFieldName().equals(field.getFieldName()))	2✔
301	\|\| (!(this.getSchemaOrdinal() == (field.getSchemaOrdinal())))	2✔
302	) {
303	return false;	2✔
304	}
305	} else {	2✔
306	return false;	×
307	}
308	return true;	2✔
309	}
310	}

apache / carbondata / 10226

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous