/**
* 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.hadoop.zebra.mapreduce;
import java.io.IOException;
import java.io.StringReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.zebra.io.BasicTable;
import org.apache.hadoop.zebra.io.TableScanner;
import org.apache.hadoop.zebra.parser.ParseException;
import org.apache.hadoop.zebra.schema.Schema;
import org.apache.hadoop.zebra.types.Projection;
import org.apache.pig.data.Tuple;
/**
* Table expression for reading a BasicTable.
*
* @see <a href="doc-files/examples/ReadABasicTable.java">Usage example for
* BasicTableExpr</a>
*/
class BasicTableExpr extends TableExpr {
private Path path;
/**
* default constructor.
*/
public BasicTableExpr() {
// no-op
}
/**
* Constructor.
*
* @param path
* Path of the BasicTable.
*/
public BasicTableExpr(Path path) {
this.path = path;
}
/**
* Set the path.
*
* @param path
* path to the BasicTable.
* @return self.
*/
public BasicTableExpr setPath(Path path) {
this.path = path;
return this;
}
/**
* Get the path.
*
* @return the path to the BasicTable.
*/
public Path getPath() {
return path;
}
@Override
protected BasicTableExpr decodeParam(StringReader in) throws IOException {
String strPath = TableExprUtils.decodeString(in);
if (strPath == null) {
throw new RuntimeException("Incomplete expression");
}
path = new Path(strPath);
return this;
}
@Override
protected BasicTableExpr encodeParam(StringBuilder out) {
if (path == null) {
throw new RuntimeException("Incomplete expression");
}
TableExprUtils.encodeString(out, path.toString());
return this;
}
@Override
public List<LeafTableInfo> getLeafTables(String projection) {
ArrayList<LeafTableInfo> ret = new ArrayList<LeafTableInfo>(1);
ret.add(new LeafTableInfo(path, projection));
return ret;
}
@Override
public TableScanner getScanner(BytesWritable begin, BytesWritable end,
String projection, Configuration conf) throws IOException {
String[] deletedCGs = getDeletedCGs(conf);
BasicTable.Reader reader = new BasicTable.Reader(path, deletedCGs, conf);
try {
reader.setProjection(projection);
} catch (ParseException e) {
throw new IOException("Projection parsing failed : "+e.getMessage());
}
return reader.getScanner(begin, end, true);
}
@Override
public TableScanner getScanner(RowTableSplit split, String projection,
Configuration conf) throws IOException, ParseException {
return new BasicTableScanner(split, projection, conf);
}
@Override
public Schema getSchema(Configuration conf) throws IOException {
return BasicTable.Reader.getSchema(path, conf);
}
@Override
public boolean sortedSplitCapable() {
return true;
}
@Override
protected void dumpInfo(PrintStream ps, Configuration conf, int indent) throws IOException
{
BasicTable.dumpInfo(path.toString(), ps, conf, indent);
}
/**
* Basic Table Scanner
*/
class BasicTableScanner implements TableScanner {
private int tableIndex = -1;
private Integer[] virtualColumnIndices = null;
private TableScanner scanner = null;
BasicTableScanner(RowTableSplit split, String projection,
Configuration conf) throws IOException, ParseException, ParseException {
tableIndex = split.getTableIndex();
virtualColumnIndices = Projection.getVirtualColumnIndices(projection);
BasicTable.Reader reader =
new BasicTable.Reader(new Path(split.getPath()), getDeletedCGs(conf), conf);
reader.setProjection(projection);
scanner = reader.getScanner(true, split.getSplit());
}
@Override
public boolean advance() throws IOException {
return scanner.advance();
}
@Override
public boolean atEnd() throws IOException {
return scanner.atEnd();
}
@Override
public Schema getSchema() {
return scanner.getSchema();
}
@Override
public void getKey(BytesWritable key) throws IOException {
scanner.getKey(key);
}
@Override
public void getValue(Tuple row) throws IOException {
scanner.getValue(row);
if (virtualColumnIndices != null)
{
for (int i = 0; i < virtualColumnIndices.length; i++)
{
row.set(virtualColumnIndices[i], tableIndex);
}
}
}
@Override
public boolean seekTo(BytesWritable key) throws IOException {
return scanner.seekTo(key);
}
@Override
public void seekToEnd() throws IOException {
scanner.seekToEnd();
}
@Override
public void close() throws IOException {
scanner.close();
}
@Override
public String getProjection() {
return scanner.getProjection();
}
}
}