8323

Build # 8323

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/d1806f7f6db990996504c8231a6ae36a44addeda">d1806f7f6<a href="https://github.com/apache/carbondata/commit/d1806f7f6db990996504c8231a6ae36a44addeda">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/67cccb16b3de7d232bfafa491a68300327ac4749">67cccb16b</a>">67cccb16b</a><a href="https://github.com/apache/carbondata/commit/d1806f7f6db990996504c8231a6ae36a44addeda"> into cf74c88cc">cf74c88cc</a>

Run Details

588 of 588 new or added lines in 63 files covered. (100.0%)

57838 of 71683 relevant lines covered (80.69%)

1.07 hits per line

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

77.07

/core/src/main/java/org/apache/carbondata/core/datastore/page/encoding/ColumnPageEncoderMeta.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.datastore.page.encoding;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.ByteBuffer;

import org.apache.carbondata.core.datastore.TableSpec;
import org.apache.carbondata.core.datastore.page.statistics.SimpleStatsResult;
import org.apache.carbondata.core.metadata.ValueEncoderMeta;
import org.apache.carbondata.core.metadata.datatype.DataType;
import org.apache.carbondata.core.metadata.datatype.DataTypes;
import org.apache.carbondata.core.metadata.datatype.DecimalType;
import org.apache.carbondata.core.metadata.schema.table.Writable;
import org.apache.carbondata.core.util.DataTypeUtil;

/**
 * It holds metadata for one column page
 */
public class ColumnPageEncoderMeta extends ValueEncoderMeta implements Writable {

  private static final long serialVersionUID = 1905162071950251407L;

  // column spec of this column
  private transient TableSpec.ColumnSpec columnSpec;

  // storage data type of this column, it could be different from data type in the column spec
  private DataType storeDataType;

  // compressor name for compressing and decompressing this column.
  // Make it protected for RLEEncoderMeta
  protected String compressorName;

  public ColumnPageEncoderMeta() {
  }

  public ColumnPageEncoderMeta(TableSpec.ColumnSpec columnSpec, DataType storeDataType,
      String compressorName) {
    if (columnSpec == null) {
      throw new IllegalArgumentException("columm spec must not be null");
    }
    if (storeDataType == null) {
      throw new IllegalArgumentException("store data type must not be null");
    }
    if (compressorName == null) {
      throw new IllegalArgumentException("compressor must not be null");
    }
    this.columnSpec = columnSpec;
    this.storeDataType = storeDataType;
    this.compressorName = compressorName;
    setType(DataType.convertType(storeDataType));
  }

  public ColumnPageEncoderMeta(TableSpec.ColumnSpec columnSpec, DataType storeDataType,
      SimpleStatsResult stats, String compressorName) {
    this(columnSpec, storeDataType, compressorName);
    if (stats != null) {
      setDecimal(stats.getDecimalCount());
      setMaxValue(stats.getMax());
      setMinValue(stats.getMin());
    }
  }

  public DataType getStoreDataType() {
    return storeDataType;
  }

  @Override
  public void write(DataOutput out) throws IOException {
    columnSpec.write(out);
    out.writeByte(storeDataType.getId());
    out.writeInt(getDecimal());
    out.writeByte(getDataTypeSelected());
    writeMinMax(out);
    out.writeUTF(compressorName);
  }

  @Override
  public void readFields(DataInput in) throws IOException {
    columnSpec = new TableSpec.ColumnSpec();
    columnSpec.readFields(in);
    storeDataType = DataTypes.valueOf(in.readByte());
    if (DataTypes.isDecimal(storeDataType)) {
      DecimalType decimalType = (DecimalType) storeDataType;
      decimalType.setPrecision(columnSpec.getPrecision());
      decimalType.setScale(columnSpec.getScale());
    }

    setDecimal(in.readInt());
    setDataTypeSelected(in.readByte());
    readMinMax(in);
    compressorName = in.readUTF();
  }

  private void writeMinMax(DataOutput out) throws IOException {
    DataType dataType = columnSpec.getSchemaDataType();
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      out.writeByte((byte) getMaxValue());
      out.writeByte((byte) getMinValue());
      out.writeLong(0L); // unique value is obsoleted, maintain for compatibility
    } else if (dataType == DataTypes.SHORT) {
      out.writeShort((short) getMaxValue());
      out.writeShort((short) getMinValue());
      out.writeLong(0L); // unique value is obsoleted, maintain for compatibility
    } else if (dataType == DataTypes.INT) {
      out.writeInt((int) getMaxValue());
      out.writeInt((int) getMinValue());
      out.writeLong(0L); // unique value is obsoleted, maintain for compatibility
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      out.writeLong((Long) getMaxValue());
      out.writeLong((Long) getMinValue());
      out.writeLong(0L); // unique value is obsoleted, maintain for compatibility
    } else if (dataType == DataTypes.DOUBLE) {
      out.writeDouble((Double) getMaxValue());
      out.writeDouble((Double) getMinValue());
      out.writeDouble(0d); // unique value is obsoleted, maintain for compatibility
    } else if (DataTypes.isDecimal(dataType)) {
      byte[] maxAsBytes = getMaxAsBytes(columnSpec.getSchemaDataType());
      byte[] minAsBytes = getMinAsBytes(columnSpec.getSchemaDataType());
      byte[] unique = DataTypeUtil.bigDecimalToByte(BigDecimal.ZERO);
      out.writeShort((short) maxAsBytes.length);
      out.write(maxAsBytes);
      out.writeShort((short) minAsBytes.length);
      out.write(minAsBytes);
      // unique value is obsoleted, maintain for compatibility
      out.writeShort((short) unique.length);
      out.write(unique);
      if (DataTypes.isDecimal(dataType)) {
        DecimalType decimalType = (DecimalType) dataType;
        out.writeInt(decimalType.getScale());
        out.writeInt(decimalType.getPrecision());
      } else {
        out.writeInt(-1);
        out.writeInt(-1);
      }
    } else if (dataType == DataTypes.BYTE_ARRAY) {
      // for complex type, it will come here, ignoring stats for complex type
      // TODO: support stats for complex type
    } else {
      throw new IllegalArgumentException("invalid data type: " + storeDataType);
    }
  }

  private void readMinMax(DataInput in) throws IOException {
    DataType dataType = columnSpec.getSchemaDataType();
    if (dataType == DataTypes.BOOLEAN || dataType == DataTypes.BYTE) {
      this.setMaxValue(in.readByte());
      this.setMinValue(in.readByte());
      in.readLong();  // for non exist value which is obsoleted, it is backward compatibility;
    } else if (dataType == DataTypes.SHORT) {
      this.setMaxValue(in.readShort());
      this.setMinValue(in.readShort());
      in.readLong();  // for non exist value which is obsoleted, it is backward compatibility;
    } else if (dataType == DataTypes.INT) {
      this.setMaxValue(in.readInt());
      this.setMinValue(in.readInt());
      in.readLong();  // for non exist value which is obsoleted, it is backward compatibility;
    } else if (dataType == DataTypes.LONG || dataType == DataTypes.TIMESTAMP) {
      this.setMaxValue(in.readLong());
      this.setMinValue(in.readLong());
      in.readLong();  // for non exist value which is obsoleted, it is backward compatibility;
    } else if (dataType == DataTypes.DOUBLE) {
      this.setMaxValue(in.readDouble());
      this.setMinValue(in.readDouble());
      in.readDouble(); // for non exist value which is obsoleted, it is backward compatibility;
    } else if (DataTypes.isDecimal(dataType)) {
      byte[] max = new byte[in.readShort()];
      in.readFully(max);
      this.setMaxValue(DataTypeUtil.byteToBigDecimal(max));
      byte[] min = new byte[in.readShort()];
      in.readFully(min);
      this.setMinValue(DataTypeUtil.byteToBigDecimal(min));
      // unique value is obsoleted, maintain for compatiability
      short uniqueLength = in.readShort();
      in.readFully(new byte[uniqueLength]);
      // scale field is obsoleted. It is stored in the schema data type in columnSpec
      in.readInt();
      // precision field is obsoleted. It is stored in the schema data type in columnSpec
      in.readInt();
    } else if (dataType == DataTypes.BYTE_ARRAY) {
      // for complex type, it will come here, ignoring stats for complex type
      // TODO: support stats for complex type
    } else {
      throw new IllegalArgumentException("invalid data type: " + storeDataType);
    }
  }

  private byte[] getMaxAsBytes(DataType dataType) {
    return getValueAsBytes(getMaxValue(), dataType);
  }

  private byte[] getMinAsBytes(DataType dataType) {
    return getValueAsBytes(getMinValue(), dataType);
  }

  /**
   * convert value to byte array
   */
  private byte[] getValueAsBytes(Object value, DataType dataType) {
    ByteBuffer b;
    if (dataType == DataTypes.BYTE_ARRAY) {
      b = ByteBuffer.allocate(8);
      b.putLong((byte) value);
      b.flip();
      return b.array();
    } else if (dataType == DataTypes.SHORT) {
      b = ByteBuffer.allocate(8);
      b.putLong((short) value);
      b.flip();
      return b.array();
    } else if (dataType == DataTypes.INT) {
      b = ByteBuffer.allocate(8);
      b.putLong((int) value);
      b.flip();
      return b.array();
    } else if (dataType == DataTypes.LONG) {
      b = ByteBuffer.allocate(8);
      b.putLong((long) value);
      b.flip();
      return b.array();
    } else if (dataType == DataTypes.DOUBLE) {
      b = ByteBuffer.allocate(8);
      b.putDouble((double) value);
      b.flip();
      return b.array();
    } else if (DataTypes.isDecimal(dataType)) {
      return DataTypeUtil.bigDecimalToByte((BigDecimal) value);
    } else if (dataType == DataTypes.STRING || dataType == DataTypes.TIMESTAMP
        || dataType == DataTypes.DATE) {
      return (byte[]) value;
    } else {
      throw new IllegalArgumentException("Invalid data type: " + storeDataType);
    }
  }

  public int getScale() {
    if (DataTypes.isDecimal(columnSpec.getSchemaDataType())) {
      return columnSpec.getScale();
    }
    throw new UnsupportedOperationException();
  }

  public int getPrecision() {
    if (DataTypes.isDecimal(columnSpec.getSchemaDataType())) {
      return columnSpec.getPrecision();
    }
    throw new UnsupportedOperationException();
  }

  public TableSpec.ColumnSpec getColumnSpec() {
    return columnSpec;
  }

  public String getCompressorName() {
    return compressorName;
  }

  public DataType getSchemaDataType() {
    return columnSpec.getSchemaDataType();
  }
}

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.core.datastore.page.encoding;
19
20	import java.io.DataInput;
21	import java.io.DataOutput;
22	import java.io.IOException;
23	import java.math.BigDecimal;
24	import java.nio.ByteBuffer;
25
26	import org.apache.carbondata.core.datastore.TableSpec;
27	import org.apache.carbondata.core.datastore.page.statistics.SimpleStatsResult;
28	import org.apache.carbondata.core.metadata.ValueEncoderMeta;
29	import org.apache.carbondata.core.metadata.datatype.DataType;
30	import org.apache.carbondata.core.metadata.datatype.DataTypes;
31	import org.apache.carbondata.core.metadata.datatype.DecimalType;
32	import org.apache.carbondata.core.metadata.schema.table.Writable;
33	import org.apache.carbondata.core.util.DataTypeUtil;
34
35	/**
36	* It holds metadata for one column page
37	*/
38	public class ColumnPageEncoderMeta extends ValueEncoderMeta implements Writable {
39
40	private static final long serialVersionUID = 1905162071950251407L;
41
42	// column spec of this column
43	private transient TableSpec.ColumnSpec columnSpec;
44
45	// storage data type of this column, it could be different from data type in the column spec
46	private DataType storeDataType;
47
48	// compressor name for compressing and decompressing this column.
49	// Make it protected for RLEEncoderMeta
50	protected String compressorName;
51
52	public ColumnPageEncoderMeta() {	2✔
53	}	2✔
54
55	public ColumnPageEncoderMeta(TableSpec.ColumnSpec columnSpec, DataType storeDataType,
56	String compressorName) {	2✔
57	if (columnSpec == null) {	2✔
58	throw new IllegalArgumentException("columm spec must not be null");	×
59	}
60	if (storeDataType == null) {	2✔
61	throw new IllegalArgumentException("store data type must not be null");	×
62	}
63	if (compressorName == null) {	2✔
64	throw new IllegalArgumentException("compressor must not be null");	×
65	}
66	this.columnSpec = columnSpec;	2✔
67	this.storeDataType = storeDataType;	2✔
68	this.compressorName = compressorName;	2✔
69	setType(DataType.convertType(storeDataType));	2✔
70	}	2✔
71
72	public ColumnPageEncoderMeta(TableSpec.ColumnSpec columnSpec, DataType storeDataType,
73	SimpleStatsResult stats, String compressorName) {
74	this(columnSpec, storeDataType, compressorName);	2✔
75	if (stats != null) {	2✔
76	setDecimal(stats.getDecimalCount());	2✔
77	setMaxValue(stats.getMax());	2✔
78	setMinValue(stats.getMin());	2✔
79	}
80	}	2✔
81
82	public DataType getStoreDataType() {
83	return storeDataType;	2✔
84	}
85
86	@Override
87	public void write(DataOutput out) throws IOException {
88	columnSpec.write(out);	2✔
89	out.writeByte(storeDataType.getId());	2✔
90	out.writeInt(getDecimal());	2✔
91	out.writeByte(getDataTypeSelected());	2✔
92	writeMinMax(out);	2✔
93	out.writeUTF(compressorName);	2✔
94	}	2✔
95
96	@Override
97	public void readFields(DataInput in) throws IOException {
98	columnSpec = new TableSpec.ColumnSpec();	2✔
99	columnSpec.readFields(in);	2✔
100	storeDataType = DataTypes.valueOf(in.readByte());	2✔
101	if (DataTypes.isDecimal(storeDataType)) {	2✔
102	DecimalType decimalType = (DecimalType) storeDataType;	1✔
103	decimalType.setPrecision(columnSpec.getPrecision());	1✔
104	decimalType.setScale(columnSpec.getScale());	1✔
105	}
106
107	setDecimal(in.readInt());	2✔
108	setDataTypeSelected(in.readByte());	2✔
109	readMinMax(in);	2✔
110	compressorName = in.readUTF();	2✔
111	}	2✔
112
113	private void writeMinMax(DataOutput out) throws IOException {
114	DataType dataType = columnSpec.getSchemaDataType();	2✔
115	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	2✔
116	out.writeByte((byte) getMaxValue());	2✔
117	out.writeByte((byte) getMinValue());	2✔
118	out.writeLong(0L); // unique value is obsoleted, maintain for compatibility	2✔
119	} else if (dataType == DataTypes.SHORT) {	2✔
120	out.writeShort((short) getMaxValue());	1✔
121	out.writeShort((short) getMinValue());	1✔
122	out.writeLong(0L); // unique value is obsoleted, maintain for compatibility	1✔
123	} else if (dataType == DataTypes.INT) {	2✔
124	out.writeInt((int) getMaxValue());	1✔
125	out.writeInt((int) getMinValue());	1✔
126	out.writeLong(0L); // unique value is obsoleted, maintain for compatibility	1✔
127	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	2✔
128	out.writeLong((Long) getMaxValue());	1✔
129	out.writeLong((Long) getMinValue());	1✔
130	out.writeLong(0L); // unique value is obsoleted, maintain for compatibility	1✔
131	} else if (dataType == DataTypes.DOUBLE) {	2✔
132	out.writeDouble((Double) getMaxValue());	1✔
133	out.writeDouble((Double) getMinValue());	1✔
134	out.writeDouble(0d); // unique value is obsoleted, maintain for compatibility	1✔
135	} else if (DataTypes.isDecimal(dataType)) {	2✔
136	byte[] maxAsBytes = getMaxAsBytes(columnSpec.getSchemaDataType());	1✔
137	byte[] minAsBytes = getMinAsBytes(columnSpec.getSchemaDataType());	1✔
138	byte[] unique = DataTypeUtil.bigDecimalToByte(BigDecimal.ZERO);	1✔
139	out.writeShort((short) maxAsBytes.length);	1✔
140	out.write(maxAsBytes);	1✔
141	out.writeShort((short) minAsBytes.length);	1✔
142	out.write(minAsBytes);	1✔
143	// unique value is obsoleted, maintain for compatibility
144	out.writeShort((short) unique.length);	1✔
145	out.write(unique);	1✔
146	if (DataTypes.isDecimal(dataType)) {	1✔
147	DecimalType decimalType = (DecimalType) dataType;	1✔
148	out.writeInt(decimalType.getScale());	1✔
149	out.writeInt(decimalType.getPrecision());	1✔
150	} else {	1✔
151	out.writeInt(-1);	×
152	out.writeInt(-1);	×
153	}
154	} else if (dataType == DataTypes.BYTE_ARRAY) {	2✔
155	// for complex type, it will come here, ignoring stats for complex type
156	// TODO: support stats for complex type
157	} else {
158	throw new IllegalArgumentException("invalid data type: " + storeDataType);	×
159	}
160	}	2✔
161
162	private void readMinMax(DataInput in) throws IOException {
163	DataType dataType = columnSpec.getSchemaDataType();	2✔
164	if (dataType == DataTypes.BOOLEAN \|\| dataType == DataTypes.BYTE) {	2✔
165	this.setMaxValue(in.readByte());	1✔
166	this.setMinValue(in.readByte());	1✔
167	in.readLong(); // for non exist value which is obsoleted, it is backward compatibility;	1✔
168	} else if (dataType == DataTypes.SHORT) {	2✔
169	this.setMaxValue(in.readShort());	1✔
170	this.setMinValue(in.readShort());	1✔
171	in.readLong(); // for non exist value which is obsoleted, it is backward compatibility;	1✔
172	} else if (dataType == DataTypes.INT) {	2✔
173	this.setMaxValue(in.readInt());	1✔
174	this.setMinValue(in.readInt());	1✔
175	in.readLong(); // for non exist value which is obsoleted, it is backward compatibility;	1✔
176	} else if (dataType == DataTypes.LONG \|\| dataType == DataTypes.TIMESTAMP) {	2✔
177	this.setMaxValue(in.readLong());	1✔
178	this.setMinValue(in.readLong());	1✔
179	in.readLong(); // for non exist value which is obsoleted, it is backward compatibility;	1✔
180	} else if (dataType == DataTypes.DOUBLE) {	2✔
181	this.setMaxValue(in.readDouble());	1✔
182	this.setMinValue(in.readDouble());	1✔
183	in.readDouble(); // for non exist value which is obsoleted, it is backward compatibility;	1✔
184	} else if (DataTypes.isDecimal(dataType)) {	2✔
185	byte[] max = new byte[in.readShort()];	1✔
186	in.readFully(max);	1✔
187	this.setMaxValue(DataTypeUtil.byteToBigDecimal(max));	1✔
188	byte[] min = new byte[in.readShort()];	1✔
189	in.readFully(min);	1✔
190	this.setMinValue(DataTypeUtil.byteToBigDecimal(min));	1✔
191	// unique value is obsoleted, maintain for compatiability
192	short uniqueLength = in.readShort();	1✔
193	in.readFully(new byte[uniqueLength]);	1✔
194	// scale field is obsoleted. It is stored in the schema data type in columnSpec
195	in.readInt();	1✔
196	// precision field is obsoleted. It is stored in the schema data type in columnSpec
197	in.readInt();	1✔
198	} else if (dataType == DataTypes.BYTE_ARRAY) {	2✔
199	// for complex type, it will come here, ignoring stats for complex type
200	// TODO: support stats for complex type
201	} else {
202	throw new IllegalArgumentException("invalid data type: " + storeDataType);	×
203	}
204	}	2✔
205
206	private byte[] getMaxAsBytes(DataType dataType) {
207	return getValueAsBytes(getMaxValue(), dataType);	1✔
208	}
209
210	private byte[] getMinAsBytes(DataType dataType) {
211	return getValueAsBytes(getMinValue(), dataType);	1✔
212	}
213
214	/**
215	* convert value to byte array
216	*/
217	private byte[] getValueAsBytes(Object value, DataType dataType) {
218	ByteBuffer b;
219	if (dataType == DataTypes.BYTE_ARRAY) {	1✔
220	b = ByteBuffer.allocate(8);	×
221	b.putLong((byte) value);	×
222	b.flip();	×
223	return b.array();	×
224	} else if (dataType == DataTypes.SHORT) {	1✔
225	b = ByteBuffer.allocate(8);	×
226	b.putLong((short) value);	×
227	b.flip();	×
228	return b.array();	×
229	} else if (dataType == DataTypes.INT) {	1✔
230	b = ByteBuffer.allocate(8);	×
231	b.putLong((int) value);	×
232	b.flip();	×
233	return b.array();	×
234	} else if (dataType == DataTypes.LONG) {	1✔
235	b = ByteBuffer.allocate(8);	×
236	b.putLong((long) value);	×
237	b.flip();	×
238	return b.array();	×
239	} else if (dataType == DataTypes.DOUBLE) {	1✔
240	b = ByteBuffer.allocate(8);	×
241	b.putDouble((double) value);	×
242	b.flip();	×
243	return b.array();	×
244	} else if (DataTypes.isDecimal(dataType)) {	1✔
245	return DataTypeUtil.bigDecimalToByte((BigDecimal) value);	1✔
246	} else if (dataType == DataTypes.STRING \|\| dataType == DataTypes.TIMESTAMP	×
247	\|\| dataType == DataTypes.DATE) {
248	return (byte[]) value;	×
249	} else {
250	throw new IllegalArgumentException("Invalid data type: " + storeDataType);	×
251	}
252	}
253
254	public int getScale() {
255	if (DataTypes.isDecimal(columnSpec.getSchemaDataType())) {	×
256	return columnSpec.getScale();	×
257	}
258	throw new UnsupportedOperationException();	×
259	}
260
261	public int getPrecision() {
262	if (DataTypes.isDecimal(columnSpec.getSchemaDataType())) {	×
263	return columnSpec.getPrecision();	×
264	}
265	throw new UnsupportedOperationException();	×
266	}
267
268	public TableSpec.ColumnSpec getColumnSpec() {
269	return columnSpec;	2✔
270	}
271
272	public String getCompressorName() {
273	return compressorName;	2✔
274	}
275
276	public DataType getSchemaDataType() {
277	return columnSpec.getSchemaDataType();	1✔
278	}
279	}

apache / carbondata / 8323

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