apache / carbondata / 785

Build # 785

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357">1312b9eff<a href="https://github.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/33b60dd368d7677b6336579497c7e0e58cf8d5cb">33b60dd36</a>">33b60dd36</a><a href="https://github.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357"> into 3cd8b947c">3cd8b947c</a>

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

60460 of 75012 relevant lines covered (80.6%)

1.06 hits per line

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

96.38

/core/src/main/java/org/apache/carbondata/core/metadata/schema/table/TableInfo.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.core.metadata.schema.table;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.carbondata.common.logging.LogService;
import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.metadata.AbsoluteTableIdentifier;
import org.apache.carbondata.core.metadata.CarbonTableIdentifier;
import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
import org.apache.carbondata.core.metadata.schema.table.column.ParentColumnTableRelation;

/**
 * Store the information about the table.
 * it stores the fact table as well as aggregate table present in the schema
 */
public class TableInfo implements Serializable, Writable {

  private static final LogService LOGGER =
      LogServiceFactory.getLogService(TableInfo.class.getName());

  /**
   * serialization version
   */
  private static final long serialVersionUID = -5034287968314105193L;

  /**
   * name of the database;
   */
  private String databaseName;

  /**
   * table name to group fact table and aggregate table
   */
  private String tableUniqueName;

  /**
   * fact table information
   */
  private TableSchema factTable;

  /**
   * last updated time to update the table if any changes
   */
  private long lastUpdatedTime;

  /**
   * store location of the table, it will be set in identifier.tablePath also
   */
  private String tablePath;

  /**
   * The boolean field which points if the data written for Non Transactional Table
   * or Transactional Table. The difference between Transactional and Non Transactional table is
   * Non Transactional Table will not contain any Metadata folder and subsequently
   * no TableStatus or Schema files.
   * All ACID properties cannot be aplied to Non Transactional Table as there is no Commit points
   * i.e. no TableStatus File.
   * What ever files present in the path will be read but it system doesnot ensure ACID rules for
   * this data, mostly Consistency part.
   *
   */
  private boolean isTransactionalTable = true;

  // this identifier is a lazy field which will be created when it is used first time
  private AbsoluteTableIdentifier identifier;

  private List<DataMapSchema> dataMapSchemaList;

  private List<RelationIdentifier> parentRelationIdentifiers;

  /**
   * flag to check whether any schema modification operation has happened after creation of table
   */
  private boolean isSchemaModified;

  public TableInfo() {
    dataMapSchemaList = new ArrayList<>();
    isTransactionalTable = true;
  }

  /**
   * @return the factTable
   */
  public TableSchema getFactTable() {
    return factTable;
  }

  /**
   * @param factTable the factTable to set
   */
  public void setFactTable(TableSchema factTable) {
    this.factTable = factTable;
    updateParentRelationIdentifier();
    updateIsSchemaModified();
  }

  private void updateIsSchemaModified() {
    if (null != factTable.getSchemaEvolution()) {
      // If schema evolution entry list size is > 1 that means an alter operation is performed
      // which has added the new schema entry in the schema evolution list.
      // Currently apart from create table schema evolution entries
      // are getting added only in the alter operations.
      isSchemaModified =
          factTable.getSchemaEvolution().getSchemaEvolutionEntryList().size() > 1 ? true : false;
    }
  }

  private void updateParentRelationIdentifier() {
    Set<RelationIdentifier> parentRelationIdentifiers = new HashSet<>();
    this.parentRelationIdentifiers = new ArrayList<>();
    List<ColumnSchema> listOfColumns = this.factTable.getListOfColumns();
    for (ColumnSchema columnSchema : listOfColumns) {
      List<ParentColumnTableRelation> parentColumnTableRelations =
          columnSchema.getParentColumnTableRelations();
      if (null != parentColumnTableRelations) {
        for (int i = 0; i < parentColumnTableRelations.size(); i++) {
          parentRelationIdentifiers.add(parentColumnTableRelations.get(i).getRelationIdentifier());
        }
      }
    }
    this.parentRelationIdentifiers.addAll(parentRelationIdentifiers);
  }

  /**
   * @return the databaseName
   */
  public String getDatabaseName() {
    return databaseName;
  }

  /**
   * @param databaseName the databaseName to set
   */
  public void setDatabaseName(String databaseName) {
    this.databaseName = databaseName;
  }

  /**
   * @return the tableUniqueName
   */
  public String getTableUniqueName() {
    return tableUniqueName;
  }

  /**
   * @param tableUniqueName the tableUniqueName to set
   */
  public void setTableUniqueName(String tableUniqueName) {
    this.tableUniqueName = tableUniqueName;
  }

  /**
   * @return the lastUpdatedTime
   */
  public long getLastUpdatedTime() {
    return lastUpdatedTime;
  }

  /**
   * @param lastUpdatedTime the lastUpdatedTime to set
   */
  public void setLastUpdatedTime(long lastUpdatedTime) {
    this.lastUpdatedTime = lastUpdatedTime;
  }

  public void setTablePath(String tablePath) {
    this.tablePath = tablePath;
  }

  public List<DataMapSchema> getDataMapSchemaList() {
    return dataMapSchemaList;
  }

  public void setDataMapSchemaList(List<DataMapSchema> dataMapSchemaList) {
    this.dataMapSchemaList = dataMapSchemaList;
  }

  /**
   * to generate the hash code
   */
  @Override public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((databaseName == null) ? 0 : databaseName.hashCode());
    result = prime * result + ((tableUniqueName == null) ? 0 : tableUniqueName.hashCode());
    return result;
  }

  /**
   * Overridden equals method
   */
  @Override public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (!(obj instanceof TableInfo)) {
      return false;
    }
    TableInfo other = (TableInfo) obj;
    if (null == databaseName || null == other.databaseName) {
      return false;
    }

    if (null == tableUniqueName || null == other.tableUniqueName) {
      return false;
    }

    if (!tableUniqueName.equals(other.tableUniqueName)) {
      return false;
    }
    return true;
  }

  /**
   * This method will return the table size. Default table block size will be considered
   * in case not specified by the user
   */
  int getTableBlockSizeInMB() {
    String tableBlockSize = null;
    // In case of old store there will not be any map for table properties so table properties
    // will be null
    Map<String, String> tableProperties = getFactTable().getTableProperties();
    if (null != tableProperties) {
      tableBlockSize = tableProperties.get(CarbonCommonConstants.TABLE_BLOCKSIZE);
    }
    if (null == tableBlockSize) {
      tableBlockSize = CarbonCommonConstants.BLOCK_SIZE_DEFAULT_VAL;
      LOGGER.info("Table block size not specified for " + getTableUniqueName()
          + ". Therefore considering the default value "
          + CarbonCommonConstants.BLOCK_SIZE_DEFAULT_VAL + " MB");
    }
    return Integer.parseInt(tableBlockSize);
  }

  @Override
  public void write(DataOutput out) throws IOException {
    out.writeUTF(databaseName);
    out.writeUTF(tableUniqueName);
    factTable.write(out);
    out.writeLong(lastUpdatedTime);
    out.writeUTF(getOrCreateAbsoluteTableIdentifier().getTablePath());
    out.writeBoolean(isTransactionalTable);
    boolean isChildSchemaExists =
        null != dataMapSchemaList && dataMapSchemaList.size() > 0;
    out.writeBoolean(isChildSchemaExists);
    if (isChildSchemaExists) {
      out.writeShort(dataMapSchemaList.size());
      for (int i = 0; i < dataMapSchemaList.size(); i++) {
        dataMapSchemaList.get(i).write(out);
      }
    }
    boolean isParentTableRelationIndentifierExists =
        null != parentRelationIdentifiers && parentRelationIdentifiers.size() > 0;
    out.writeBoolean(isParentTableRelationIndentifierExists);
    if (isParentTableRelationIndentifierExists) {
      out.writeShort(parentRelationIdentifiers.size());
      for (int i = 0; i < parentRelationIdentifiers.size(); i++) {
        parentRelationIdentifiers.get(i).write(out);
      }
    }
    out.writeBoolean(isSchemaModified);
  }

  @Override public void readFields(DataInput in) throws IOException {
    this.databaseName = in.readUTF();
    this.tableUniqueName = in.readUTF();
    this.factTable = new TableSchema();
    this.factTable.readFields(in);
    this.lastUpdatedTime = in.readLong();
    this.tablePath = in.readUTF();
    this.isTransactionalTable = in.readBoolean();
    boolean isChildSchemaExists = in.readBoolean();
    this.dataMapSchemaList = new ArrayList<>();
    if (isChildSchemaExists) {
      short numberOfChildTable = in.readShort();
      for (int i = 0; i < numberOfChildTable; i++) {
        DataMapSchema childSchema = new DataMapSchema();
        childSchema.readFields(in);
        DataMapSchema dataMapSchema = DataMapSchemaFactory.INSTANCE
            .getDataMapSchema(childSchema.getDataMapName(), childSchema.getProviderName());
        dataMapSchema.setChildSchema(childSchema.getChildSchema());
        dataMapSchema.setRelationIdentifier(childSchema.getRelationIdentifier());
        dataMapSchema.setProperties(childSchema.getProperties());
        dataMapSchemaList.add(dataMapSchema);
      }
    }
    boolean isParentTableRelationIdentifierExists = in.readBoolean();
    if (isParentTableRelationIdentifierExists) {
      short parentTableIdentifiersListSize = in.readShort();
      this.parentRelationIdentifiers = new ArrayList<>();
      for (int i = 0; i < parentTableIdentifiersListSize; i++) {
        RelationIdentifier relationIdentifier = new RelationIdentifier(null, null, null);
        relationIdentifier.readFields(in);
        this.parentRelationIdentifiers.add(relationIdentifier);
      }
    }
    this.isSchemaModified = in.readBoolean();
  }

  public AbsoluteTableIdentifier getOrCreateAbsoluteTableIdentifier() {
    if (identifier == null) {
      CarbonTableIdentifier carbontableIdentifier =
          new CarbonTableIdentifier(databaseName, factTable.getTableName(), factTable.getTableId());
      identifier = AbsoluteTableIdentifier.from(tablePath, carbontableIdentifier);
    }
    return identifier;
  }

  public byte[] serialize() throws IOException {
    ByteArrayOutputStream bao = new ByteArrayOutputStream();
    this.write(new DataOutputStream(bao));
    return bao.toByteArray();
  }

  public static TableInfo deserialize(byte[] bytes) throws IOException {
    TableInfo tableInfo = new TableInfo();
    DataInputStream in = new DataInputStream(new ByteArrayInputStream(bytes));
    tableInfo.readFields(in);
    return tableInfo;
  }

  public List<RelationIdentifier> getParentRelationIdentifiers() {
    return parentRelationIdentifiers;
  }

  public boolean isTransactionalTable() {
    return isTransactionalTable;
  }

  public void setTransactionalTable(boolean transactionalTable) {
    isTransactionalTable = transactionalTable;
  }

  public boolean isSchemaModified() {
    return isSchemaModified;
  }

}

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	package org.apache.carbondata.core.metadata.schema.table;
18
19	import java.io.ByteArrayInputStream;
20	import java.io.ByteArrayOutputStream;
21	import java.io.DataInput;
22	import java.io.DataInputStream;
23	import java.io.DataOutput;
24	import java.io.DataOutputStream;
25	import java.io.IOException;
26	import java.io.Serializable;
27	import java.util.ArrayList;
28	import java.util.HashSet;
29	import java.util.List;
30	import java.util.Map;
31	import java.util.Set;
32
33	import org.apache.carbondata.common.logging.LogService;
34	import org.apache.carbondata.common.logging.LogServiceFactory;
35	import org.apache.carbondata.core.constants.CarbonCommonConstants;
36	import org.apache.carbondata.core.metadata.AbsoluteTableIdentifier;
37	import org.apache.carbondata.core.metadata.CarbonTableIdentifier;
38	import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
39	import org.apache.carbondata.core.metadata.schema.table.column.ParentColumnTableRelation;
40
41	/**
42	* Store the information about the table.
43	* it stores the fact table as well as aggregate table present in the schema
44	*/
45	public class TableInfo implements Serializable, Writable {
46
47	private static final LogService LOGGER =	2✔
48	LogServiceFactory.getLogService(TableInfo.class.getName());	2✔
49
50	/**
51	* serialization version
52	*/
53	private static final long serialVersionUID = -5034287968314105193L;
54
55	/**
56	* name of the database;
57	*/
58	private String databaseName;
59
60	/**
61	* table name to group fact table and aggregate table
62	*/
63	private String tableUniqueName;
64
65	/**
66	* fact table information
67	*/
68	private TableSchema factTable;
69
70	/**
71	* last updated time to update the table if any changes
72	*/
73	private long lastUpdatedTime;
74
75	/**
76	* store location of the table, it will be set in identifier.tablePath also
77	*/
78	private String tablePath;
79
80	/**
81	* The boolean field which points if the data written for Non Transactional Table
82	* or Transactional Table. The difference between Transactional and Non Transactional table is
83	* Non Transactional Table will not contain any Metadata folder and subsequently
84	* no TableStatus or Schema files.
85	* All ACID properties cannot be aplied to Non Transactional Table as there is no Commit points
86	* i.e. no TableStatus File.
87	* What ever files present in the path will be read but it system doesnot ensure ACID rules for
88	* this data, mostly Consistency part.
89	*
90	*/
91	private boolean isTransactionalTable = true;	2✔
92
93	// this identifier is a lazy field which will be created when it is used first time
94	private AbsoluteTableIdentifier identifier;
95
96	private List<DataMapSchema> dataMapSchemaList;
97
98	private List<RelationIdentifier> parentRelationIdentifiers;
99
100	/**
101	* flag to check whether any schema modification operation has happened after creation of table
102	*/
103	private boolean isSchemaModified;
104
105	public TableInfo() {	2✔
106	dataMapSchemaList = new ArrayList<>();	2✔
107	isTransactionalTable = true;	2✔
108	}	2✔
109
110	/**
111	* @return the factTable
112	*/
113	public TableSchema getFactTable() {
114	return factTable;	2✔
115	}
116
117	/**
118	* @param factTable the factTable to set
119	*/
120	public void setFactTable(TableSchema factTable) {
121	this.factTable = factTable;	2✔
122	updateParentRelationIdentifier();	2✔
123	updateIsSchemaModified();	2✔
124	}	2✔
125
126	private void updateIsSchemaModified() {
127	if (null != factTable.getSchemaEvolution()) {	2✔
128	// If schema evolution entry list size is > 1 that means an alter operation is performed
129	// which has added the new schema entry in the schema evolution list.
130	// Currently apart from create table schema evolution entries
131	// are getting added only in the alter operations.
132	isSchemaModified =	2✔
133	factTable.getSchemaEvolution().getSchemaEvolutionEntryList().size() > 1 ? true : false;	2✔
134	}
135	}	2✔
136
137	private void updateParentRelationIdentifier() {
138	Set<RelationIdentifier> parentRelationIdentifiers = new HashSet<>();	2✔
139	this.parentRelationIdentifiers = new ArrayList<>();	2✔
140	List<ColumnSchema> listOfColumns = this.factTable.getListOfColumns();	2✔
141	for (ColumnSchema columnSchema : listOfColumns) {	2✔
142	List<ParentColumnTableRelation> parentColumnTableRelations =	2✔
143	columnSchema.getParentColumnTableRelations();	2✔
144	if (null != parentColumnTableRelations) {	2✔
145	for (int i = 0; i < parentColumnTableRelations.size(); i++) {	1✔
146	parentRelationIdentifiers.add(parentColumnTableRelations.get(i).getRelationIdentifier());	1✔
147	}
148	}
149	}	2✔
150	this.parentRelationIdentifiers.addAll(parentRelationIdentifiers);	2✔
151	}	2✔
152
153	/**
154	* @return the databaseName
155	*/
156	public String getDatabaseName() {
157	return databaseName;	2✔
158	}
159
160	/**
161	* @param databaseName the databaseName to set
162	*/
163	public void setDatabaseName(String databaseName) {
164	this.databaseName = databaseName;	2✔
165	}	2✔
166
167	/**
168	* @return the tableUniqueName
169	*/
170	public String getTableUniqueName() {
171	return tableUniqueName;	2✔
172	}
173
174	/**
175	* @param tableUniqueName the tableUniqueName to set
176	*/
177	public void setTableUniqueName(String tableUniqueName) {
178	this.tableUniqueName = tableUniqueName;	2✔
179	}	2✔
180
181	/**
182	* @return the lastUpdatedTime
183	*/
184	public long getLastUpdatedTime() {
185	return lastUpdatedTime;	2✔
186	}
187
188	/**
189	* @param lastUpdatedTime the lastUpdatedTime to set
190	*/
191	public void setLastUpdatedTime(long lastUpdatedTime) {
192	this.lastUpdatedTime = lastUpdatedTime;	2✔
193	}	2✔
194
195	public void setTablePath(String tablePath) {
196	this.tablePath = tablePath;	2✔
197	}	2✔
198
199	public List<DataMapSchema> getDataMapSchemaList() {
200	return dataMapSchemaList;	2✔
201	}
202
203	public void setDataMapSchemaList(List<DataMapSchema> dataMapSchemaList) {
204	this.dataMapSchemaList = dataMapSchemaList;	2✔
205	}	2✔
206
207	/**
208	* to generate the hash code
209	*/
210	@Override public int hashCode() {
211	final int prime = 31;	1✔
212	int result = 1;	1✔
213	result = prime * result + ((databaseName == null) ? 0 : databaseName.hashCode());	1✔
214	result = prime * result + ((tableUniqueName == null) ? 0 : tableUniqueName.hashCode());	1✔
215	return result;	1✔
216	}
217
218	/**
219	* Overridden equals method
220	*/
221	@Override public boolean equals(Object obj) {
222	if (this == obj) {	2✔
223	return true;	×
224	}
225	if (obj == null) {	2✔
226	return false;	×
227	}
228	if (!(obj instanceof TableInfo)) {	2✔
229	return false;	×
230	}
231	TableInfo other = (TableInfo) obj;	2✔
232	if (null == databaseName \|\| null == other.databaseName) {	2✔
233	return false;	×
234	}
235
236	if (null == tableUniqueName \|\| null == other.tableUniqueName) {	2✔
237	return false;	×
238	}
239
240	if (!tableUniqueName.equals(other.tableUniqueName)) {	2✔
241	return false;	2✔
242	}
243	return true;	2✔
244	}
245
246	/**
247	* This method will return the table size. Default table block size will be considered
248	* in case not specified by the user
249	*/
250	int getTableBlockSizeInMB() {
251	String tableBlockSize = null;	2✔
252	// In case of old store there will not be any map for table properties so table properties
253	// will be null
254	Map<String, String> tableProperties = getFactTable().getTableProperties();	2✔
255	if (null != tableProperties) {	2✔
256	tableBlockSize = tableProperties.get(CarbonCommonConstants.TABLE_BLOCKSIZE);	2✔
257	}
258	if (null == tableBlockSize) {	2✔
259	tableBlockSize = CarbonCommonConstants.BLOCK_SIZE_DEFAULT_VAL;	2✔
260	LOGGER.info("Table block size not specified for " + getTableUniqueName()	2✔
261	+ ". Therefore considering the default value "
262	+ CarbonCommonConstants.BLOCK_SIZE_DEFAULT_VAL + " MB");
263	}
264	return Integer.parseInt(tableBlockSize);	2✔
265	}
266
267	@Override
268	public void write(DataOutput out) throws IOException {
269	out.writeUTF(databaseName);	1✔
270	out.writeUTF(tableUniqueName);	1✔
271	factTable.write(out);	1✔
272	out.writeLong(lastUpdatedTime);	1✔
273	out.writeUTF(getOrCreateAbsoluteTableIdentifier().getTablePath());	1✔
274	out.writeBoolean(isTransactionalTable);	1✔
275	boolean isChildSchemaExists =	1✔
276	null != dataMapSchemaList && dataMapSchemaList.size() > 0;	1✔
277	out.writeBoolean(isChildSchemaExists);	1✔
278	if (isChildSchemaExists) {	1✔
279	out.writeShort(dataMapSchemaList.size());	1✔
280	for (int i = 0; i < dataMapSchemaList.size(); i++) {	1✔
281	dataMapSchemaList.get(i).write(out);	1✔
282	}
283	}
284	boolean isParentTableRelationIndentifierExists =	1✔
285	null != parentRelationIdentifiers && parentRelationIdentifiers.size() > 0;	1✔
286	out.writeBoolean(isParentTableRelationIndentifierExists);	1✔
287	if (isParentTableRelationIndentifierExists) {	1✔
288	out.writeShort(parentRelationIdentifiers.size());	1✔
289	for (int i = 0; i < parentRelationIdentifiers.size(); i++) {	1✔
290	parentRelationIdentifiers.get(i).write(out);	1✔
291	}
292	}
293	out.writeBoolean(isSchemaModified);	1✔
294	}	1✔
295
296	@Override public void readFields(DataInput in) throws IOException {
297	this.databaseName = in.readUTF();	1✔
298	this.tableUniqueName = in.readUTF();	1✔
299	this.factTable = new TableSchema();	1✔
300	this.factTable.readFields(in);	1✔
301	this.lastUpdatedTime = in.readLong();	1✔
302	this.tablePath = in.readUTF();	1✔
303	this.isTransactionalTable = in.readBoolean();	1✔
304	boolean isChildSchemaExists = in.readBoolean();	1✔
305	this.dataMapSchemaList = new ArrayList<>();	1✔
306	if (isChildSchemaExists) {	1✔
307	short numberOfChildTable = in.readShort();	1✔
308	for (int i = 0; i < numberOfChildTable; i++) {	1✔
309	DataMapSchema childSchema = new DataMapSchema();	1✔
310	childSchema.readFields(in);	1✔
311	DataMapSchema dataMapSchema = DataMapSchemaFactory.INSTANCE	1✔
312	.getDataMapSchema(childSchema.getDataMapName(), childSchema.getProviderName());	1✔
313	dataMapSchema.setChildSchema(childSchema.getChildSchema());	1✔
314	dataMapSchema.setRelationIdentifier(childSchema.getRelationIdentifier());	1✔
315	dataMapSchema.setProperties(childSchema.getProperties());	1✔
316	dataMapSchemaList.add(dataMapSchema);	1✔
317	}
318	}
319	boolean isParentTableRelationIdentifierExists = in.readBoolean();	1✔
320	if (isParentTableRelationIdentifierExists) {	1✔
321	short parentTableIdentifiersListSize = in.readShort();	1✔
322	this.parentRelationIdentifiers = new ArrayList<>();	1✔
323	for (int i = 0; i < parentTableIdentifiersListSize; i++) {	1✔
324	RelationIdentifier relationIdentifier = new RelationIdentifier(null, null, null);	1✔
325	relationIdentifier.readFields(in);	1✔
326	this.parentRelationIdentifiers.add(relationIdentifier);	1✔
327	}
328	}
329	this.isSchemaModified = in.readBoolean();	1✔
330	}	1✔
331
332	public AbsoluteTableIdentifier getOrCreateAbsoluteTableIdentifier() {
333	if (identifier == null) {	2✔
334	CarbonTableIdentifier carbontableIdentifier =	2✔
335	new CarbonTableIdentifier(databaseName, factTable.getTableName(), factTable.getTableId());	2✔
336	identifier = AbsoluteTableIdentifier.from(tablePath, carbontableIdentifier);	2✔
337	}
338	return identifier;	2✔
339	}
340
341	public byte[] serialize() throws IOException {
342	ByteArrayOutputStream bao = new ByteArrayOutputStream();	1✔
343	this.write(new DataOutputStream(bao));	1✔
344	return bao.toByteArray();	1✔
345	}
346
347	public static TableInfo deserialize(byte[] bytes) throws IOException {
348	TableInfo tableInfo = new TableInfo();	1✔
349	DataInputStream in = new DataInputStream(new ByteArrayInputStream(bytes));	1✔
350	tableInfo.readFields(in);	1✔
351	return tableInfo;	1✔
352	}
353
354	public List<RelationIdentifier> getParentRelationIdentifiers() {
355	return parentRelationIdentifiers;	1✔
356	}
357
358	public boolean isTransactionalTable() {
359	return isTransactionalTable;	2✔
360	}
361
362	public void setTransactionalTable(boolean transactionalTable) {
363	isTransactionalTable = transactionalTable;	1✔
364	}	1✔
365
366	public boolean isSchemaModified() {
367	return isSchemaModified;	1✔
368	}
369
370	}

apache / carbondata / 785

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