1261

Build # 1261

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/ad0f19b72962bd3cd9fda07d0609fd37b53cd79f">ad0f19b72<a href="https://github.com/apache/carbondata/commit/ad0f19b72962bd3cd9fda07d0609fd37b53cd79f">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/4dd83983ea2fff831de3d301dfbff11f87549a6f">4dd83983e</a>">4dd83983e</a><a href="https://github.com/apache/carbondata/commit/ad0f19b72962bd3cd9fda07d0609fd37b53cd79f"> into b62b0fd9c">b62b0fd9c</a>

Run Details

44 of 44 new or added lines in 14 files covered. (100.0%)

60631 of 76644 relevant lines covered (79.11%)

1.04 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.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;

import org.apache.log4j.Logger;

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

apache / carbondata / 1261

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