3503

Build # 3503

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/c29b3ac79313f362695e4f9b4a6a4d2e53fa2385">c29b3ac79<a href="https://github.com/apache/carbondata/commit/c29b3ac79313f362695e4f9b4a6a4d2e53fa2385">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/3b12161e3cc88c434ad5ba5d4d6e78c51a63d3fa">3b12161e3</a>">3b12161e3</a><a href="https://github.com/apache/carbondata/commit/c29b3ac79313f362695e4f9b4a6a4d2e53fa2385"> into 4d7c8ada9">4d7c8ada9</a>

Run Details

398 of 398 new or added lines in 23 files covered. (100.0%)

64089 of 81962 relevant lines covered (78.19%)

1.03 hits per line

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

96.77

/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;

  private boolean hasColumnDrift = false;

  // 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();
    updateHasColumnDrift();
  }

  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.TABLE_BLOCK_SIZE_DEFAULT;
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(
            "Table block size not specified for " + getTableUniqueName() +
                ". Therefore considering the default value " +
                CarbonCommonConstants.TABLE_BLOCK_SIZE_DEFAULT + " 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);
    out.writeBoolean(hasColumnDrift);
    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();
    this.hasColumnDrift = 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;
  }

  private void updateHasColumnDrift() {
    this.hasColumnDrift = false;
    for (ColumnSchema columnSchema : factTable.getListOfColumns()) {
      if (columnSchema.isDimensionColumn() && !columnSchema.isInvisible()) {
        Map<String, String> columnProperties = columnSchema.getColumnProperties();
        if (columnProperties != null) {
          if (columnProperties.get(CarbonCommonConstants.COLUMN_DRIFT) != null) {
            this.hasColumnDrift = true;
            break;
          }
        }
      }
    }
  }

  public boolean hasColumnDrift() {
    return hasColumnDrift;
  }
}

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	private boolean hasColumnDrift = false;	2✔
95
96	// this identifier is a lazy field which will be created when it is used first time
97	private AbsoluteTableIdentifier identifier;
98
99	private List<DataMapSchema> dataMapSchemaList;
100
101	private List<RelationIdentifier> parentRelationIdentifiers;
102
103	/**
104	* flag to check whether any schema modification operation has happened after creation of table
105	*/
106	private boolean isSchemaModified;
107
108	public TableInfo() {	2✔
109	dataMapSchemaList = new ArrayList<>();	2✔
110	isTransactionalTable = true;	2✔
111	}	2✔
112
113	/**
114	* @return the factTable
115	*/
116	public TableSchema getFactTable() {
117	return factTable;	2✔
118	}
119
120	/**
121	* @param factTable the factTable to set
122	*/
123	public void setFactTable(TableSchema factTable) {
124	this.factTable = factTable;	2✔
125	updateParentRelationIdentifier();	2✔
126	updateIsSchemaModified();	2✔
127	updateHasColumnDrift();	2✔
128	}	2✔
129
130	private void updateIsSchemaModified() {
131	if (null != factTable.getSchemaEvolution()) {	2✔
132	// If schema evolution entry list size is > 1 that means an alter operation is performed
133	// which has added the new schema entry in the schema evolution list.
134	// Currently apart from create table schema evolution entries
135	// are getting added only in the alter operations.
136	isSchemaModified =	2✔
137	factTable.getSchemaEvolution().getSchemaEvolutionEntryList().size() > 1 ? true : false;	2✔
138	}
139	}	2✔
140
141	private void updateParentRelationIdentifier() {
142	Set<RelationIdentifier> parentRelationIdentifiers = new HashSet<>();	2✔
143	this.parentRelationIdentifiers = new ArrayList<>();	2✔
144	List<ColumnSchema> listOfColumns = this.factTable.getListOfColumns();	2✔
145	for (ColumnSchema columnSchema : listOfColumns) {	2✔
146	List<ParentColumnTableRelation> parentColumnTableRelations =	2✔
147	columnSchema.getParentColumnTableRelations();	2✔
148	if (null != parentColumnTableRelations) {	2✔
149	for (int i = 0; i < parentColumnTableRelations.size(); i++) {	1✔
150	parentRelationIdentifiers.add(parentColumnTableRelations.get(i).getRelationIdentifier());	1✔
151	}
152	}
153	}	2✔
154	this.parentRelationIdentifiers.addAll(parentRelationIdentifiers);	2✔
155	}	2✔
156
157	/**
158	* @return the databaseName
159	*/
160	public String getDatabaseName() {
161	return databaseName;	2✔
162	}
163
164	/**
165	* @param databaseName the databaseName to set
166	*/
167	public void setDatabaseName(String databaseName) {
168	this.databaseName = databaseName;	2✔
169	}	2✔
170
171	/**
172	* @return the tableUniqueName
173	*/
174	public String getTableUniqueName() {
175	return tableUniqueName;	2✔
176	}
177
178	/**
179	* @param tableUniqueName the tableUniqueName to set
180	*/
181	public void setTableUniqueName(String tableUniqueName) {
182	this.tableUniqueName = tableUniqueName;	2✔
183	}	2✔
184
185	/**
186	* @return the lastUpdatedTime
187	*/
188	public long getLastUpdatedTime() {
189	return lastUpdatedTime;	2✔
190	}
191
192	/**
193	* @param lastUpdatedTime the lastUpdatedTime to set
194	*/
195	public void setLastUpdatedTime(long lastUpdatedTime) {
196	this.lastUpdatedTime = lastUpdatedTime;	2✔
197	}	2✔
198
199	public void setTablePath(String tablePath) {
200	this.tablePath = tablePath;	2✔
201	}	2✔
202
203	public List<DataMapSchema> getDataMapSchemaList() {
204	return dataMapSchemaList;	2✔
205	}
206
207	public void setDataMapSchemaList(List<DataMapSchema> dataMapSchemaList) {
208	this.dataMapSchemaList = dataMapSchemaList;	2✔
209	}	2✔
210
211	/**
212	* to generate the hash code
213	*/
214	@Override public int hashCode() {
215	final int prime = 31;	1✔
216	int result = 1;	1✔
217	result = prime * result + ((databaseName == null) ? 0 : databaseName.hashCode());	1✔
218	result = prime * result + ((tableUniqueName == null) ? 0 : tableUniqueName.hashCode());	1✔
219	return result;	1✔
220	}
221
222	/**
223	* Overridden equals method
224	*/
225	@Override public boolean equals(Object obj) {
226	if (this == obj) {	2✔
227	return true;	×
228	}
229	if (obj == null) {	2✔
230	return false;	×
231	}
232	if (!(obj instanceof TableInfo)) {	2✔
233	return false;	×
234	}
235	TableInfo other = (TableInfo) obj;	2✔
236	if (null == databaseName \|\| null == other.databaseName) {	2✔
237	return false;	×
238	}
239
240	if (null == tableUniqueName \|\| null == other.tableUniqueName) {	2✔
241	return false;	×
242	}
243
244	if (!tableUniqueName.equals(other.tableUniqueName)) {	2✔
245	return false;	2✔
246	}
247	return true;	2✔
248	}
249
250	/**
251	* This method will return the table size. Default table block size will be considered
252	* in case not specified by the user
253	*/
254	int getTableBlockSizeInMB() {
255	String tableBlockSize = null;	2✔
256	// In case of old store there will not be any map for table properties so table properties
257	// will be null
258	Map<String, String> tableProperties = getFactTable().getTableProperties();	2✔
259	if (null != tableProperties) {	2✔
260	tableBlockSize = tableProperties.get(CarbonCommonConstants.TABLE_BLOCKSIZE);	2✔
261	}
262	if (null == tableBlockSize) {	2✔
263	tableBlockSize = CarbonCommonConstants.TABLE_BLOCK_SIZE_DEFAULT;	2✔
264	if (LOGGER.isDebugEnabled()) {	2✔
265	LOGGER.debug(	2✔
266	"Table block size not specified for " + getTableUniqueName() +	2✔
267	". Therefore considering the default value " +
268	CarbonCommonConstants.TABLE_BLOCK_SIZE_DEFAULT + " MB");
269	}
270	}
271	return Integer.parseInt(tableBlockSize);	2✔
272	}
273
274	@Override
275	public void write(DataOutput out) throws IOException {
276	out.writeUTF(databaseName);	1✔
277	out.writeUTF(tableUniqueName);	1✔
278	factTable.write(out);	1✔
279	out.writeLong(lastUpdatedTime);	1✔
280	out.writeUTF(getOrCreateAbsoluteTableIdentifier().getTablePath());	1✔
281	out.writeBoolean(isTransactionalTable);	1✔
282	out.writeBoolean(hasColumnDrift);	1✔
283	boolean isChildSchemaExists =	1✔
284	null != dataMapSchemaList && dataMapSchemaList.size() > 0;	1✔
285	out.writeBoolean(isChildSchemaExists);	1✔
286	if (isChildSchemaExists) {	1✔
287	out.writeShort(dataMapSchemaList.size());	1✔
288	for (int i = 0; i < dataMapSchemaList.size(); i++) {	1✔
289	dataMapSchemaList.get(i).write(out);	1✔
290	}
291	}
292	boolean isParentTableRelationIndentifierExists =	1✔
293	null != parentRelationIdentifiers && parentRelationIdentifiers.size() > 0;	1✔
294	out.writeBoolean(isParentTableRelationIndentifierExists);	1✔
295	if (isParentTableRelationIndentifierExists) {	1✔
296	out.writeShort(parentRelationIdentifiers.size());	1✔
297	for (int i = 0; i < parentRelationIdentifiers.size(); i++) {	1✔
298	parentRelationIdentifiers.get(i).write(out);	1✔
299	}
300	}
301	out.writeBoolean(isSchemaModified);	1✔
302	}	1✔
303
304	@Override public void readFields(DataInput in) throws IOException {
305	this.databaseName = in.readUTF();	1✔
306	this.tableUniqueName = in.readUTF();	1✔
307	this.factTable = new TableSchema();	1✔
308	this.factTable.readFields(in);	1✔
309	this.lastUpdatedTime = in.readLong();	1✔
310	this.tablePath = in.readUTF();	1✔
311	this.isTransactionalTable = in.readBoolean();	1✔
312	this.hasColumnDrift = in.readBoolean();	1✔
313	boolean isChildSchemaExists = in.readBoolean();	1✔
314	this.dataMapSchemaList = new ArrayList<>();	1✔
315	if (isChildSchemaExists) {	1✔
316	short numberOfChildTable = in.readShort();	1✔
317	for (int i = 0; i < numberOfChildTable; i++) {	1✔
318	DataMapSchema childSchema = new DataMapSchema();	1✔
319	childSchema.readFields(in);	1✔
320	DataMapSchema dataMapSchema = DataMapSchemaFactory.INSTANCE	1✔
321	.getDataMapSchema(childSchema.getDataMapName(), childSchema.getProviderName());	1✔
322	dataMapSchema.setChildSchema(childSchema.getChildSchema());	1✔
323	dataMapSchema.setRelationIdentifier(childSchema.getRelationIdentifier());	1✔
324	dataMapSchema.setProperties(childSchema.getProperties());	1✔
325	dataMapSchemaList.add(dataMapSchema);	1✔
326	}
327	}
328	boolean isParentTableRelationIdentifierExists = in.readBoolean();	1✔
329	if (isParentTableRelationIdentifierExists) {	1✔
330	short parentTableIdentifiersListSize = in.readShort();	1✔
331	this.parentRelationIdentifiers = new ArrayList<>();	1✔
332	for (int i = 0; i < parentTableIdentifiersListSize; i++) {	1✔
333	RelationIdentifier relationIdentifier = new RelationIdentifier(null, null, null);	1✔
334	relationIdentifier.readFields(in);	1✔
335	this.parentRelationIdentifiers.add(relationIdentifier);	1✔
336	}
337	}
338	this.isSchemaModified = in.readBoolean();	1✔
339	}	1✔
340
341	public AbsoluteTableIdentifier getOrCreateAbsoluteTableIdentifier() {
342	if (identifier == null) {	2✔
343	CarbonTableIdentifier carbontableIdentifier =	2✔
344	new CarbonTableIdentifier(databaseName, factTable.getTableName(), factTable.getTableId());	2✔
345	identifier = AbsoluteTableIdentifier.from(tablePath, carbontableIdentifier);	2✔
346	}
347	return identifier;	2✔
348	}
349
350	public byte[] serialize() throws IOException {
351	ByteArrayOutputStream bao = new ByteArrayOutputStream();	1✔
352	this.write(new DataOutputStream(bao));	1✔
353	return bao.toByteArray();	1✔
354	}
355
356	public static TableInfo deserialize(byte[] bytes) throws IOException {
357	TableInfo tableInfo = new TableInfo();	1✔
358	DataInputStream in = new DataInputStream(new ByteArrayInputStream(bytes));	1✔
359	tableInfo.readFields(in);	1✔
360	return tableInfo;	1✔
361	}
362
363	public List<RelationIdentifier> getParentRelationIdentifiers() {
364	return parentRelationIdentifiers;	1✔
365	}
366
367	public boolean isTransactionalTable() {
368	return isTransactionalTable;	2✔
369	}
370
371	public void setTransactionalTable(boolean transactionalTable) {
372	isTransactionalTable = transactionalTable;	1✔
373	}	1✔
374
375	public boolean isSchemaModified() {
376	return isSchemaModified;	1✔
377	}
378
379	private void updateHasColumnDrift() {
380	this.hasColumnDrift = false;	2✔
381	for (ColumnSchema columnSchema : factTable.getListOfColumns()) {	2✔
382	if (columnSchema.isDimensionColumn() && !columnSchema.isInvisible()) {	2✔
383	Map<String, String> columnProperties = columnSchema.getColumnProperties();	2✔
384	if (columnProperties != null) {	2✔
385	if (columnProperties.get(CarbonCommonConstants.COLUMN_DRIFT) != null) {	1✔
386	this.hasColumnDrift = true;	1✔
387	break;	1✔
388	}
389	}
390	}
391	}	2✔
392	}	2✔
393
394	public boolean hasColumnDrift() {
395	return hasColumnDrift;	1✔
396	}
397	}

apache / carbondata / 3503

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