public Fragment(String fragmentId, Path path, TableMeta meta, long start, long length) {
this();
TableMeta newMeta = new TableMetaImpl(meta.getProto());
SchemaProto newSchemaProto =
TCatUtil.getQualfiedSchema(fragmentId, meta.getSchema().getProto());
newMeta.setSchema(new Schema(newSchemaProto));
this.set(fragmentId, path, newMeta, start, length);
}
protected void mergeLocalToBuilder() {
if (builder == null) {
this.builder = TabletProto.newBuilder(proto);
}
if (this.fragmentId != null) {
builder.setId(this.fragmentId);
}
if (this.startOffset != null) {
builder.setStartOffset(this.startOffset);
}
if (this.meta != null) {
builder.setMeta(meta.getProto());
}
if (this.length != null) {
builder.setLength(this.length);
}
if (this.path != null) {
builder.setPath(this.path.toString());
}
if (this.distCached != null) {
builder.setDistCached(this.distCached);
}
}
public Object clone() throws CloneNotSupportedException {
TableDesc desc = (TableDesc) super.clone();
desc.builder = TableDescProto.newBuilder();
desc.tableName = tableName;
desc.schema = (Schema) schema.clone();
desc.meta = (TableMeta) meta.clone();
desc.uri = uri;
desc.stats = stats != null ? (TableStats) stats.clone() : null;
desc.partitionMethodDesc =
partitionMethodDesc != null ? (PartitionMethodDesc) partitionMethodDesc.clone() : null;
return desc;
}
public Object clone() throws CloneNotSupportedException {
Fragment frag = (Fragment) super.clone();
initFromProto();
frag.proto = null;
frag.viaProto = false;
frag.builder = TabletProto.newBuilder();
frag.fragmentId = fragmentId;
frag.path = path;
frag.meta = (TableMeta) (meta != null ? meta.clone() : null);
frag.distCached = distCached;
return frag;
}
public boolean equals(Object object) {
if (object instanceof TableDesc) {
TableDesc other = (TableDesc) object;
boolean eq = tableName.equals(other.tableName);
eq = eq && schema.equals(other.schema);
eq = eq && meta.equals(other.meta);
eq = eq && uri.equals(other.uri);
eq = eq && TUtil.checkEquals(partitionMethodDesc, other.partitionMethodDesc);
return eq && TUtil.checkEquals(stats, other.stats);
}
return false;
}
private boolean isClonedTable(String orignalTable, String newTable) throws Exception {
assertTableExists(newTable);
TableDesc origTableDesc = client.getTableDesc(orignalTable);
TableDesc newTableDesc = client.getTableDesc(newTable);
if (isClonedSchema(origTableDesc.getSchema(), newTableDesc.getSchema()) == false) {
fail("Schema of input tables do not match");
return false;
}
// Check partition information
PartitionMethodDesc origPartMethod = origTableDesc.getPartitionMethod();
PartitionMethodDesc newPartMethod = newTableDesc.getPartitionMethod();
if (origPartMethod != null) {
if (newPartMethod == null) {
fail("New table does not have partition info");
return false;
}
if (isClonedSchema(origPartMethod.getExpressionSchema(), newPartMethod.getExpressionSchema())
== false) {
fail("Partition columns of input tables do not match");
return false;
}
if (origPartMethod.getPartitionType().equals(newPartMethod.getPartitionType()) == false) {
fail("Partition type of input tables do not match");
return false;
}
}
// Check external flag
if (origTableDesc.isExternal() != newTableDesc.isExternal()) {
fail("External table flag on input tables not equal");
return false;
}
if (origTableDesc.getMeta() != null) {
TableMeta origMeta = origTableDesc.getMeta();
TableMeta newMeta = newTableDesc.getMeta();
if (origMeta.getDataFormat().equals(newMeta.getDataFormat()) == false) {
fail("Store type of input tables not equal");
return false;
}
KeyValueSet origOptions = origMeta.getPropertySet();
KeyValueSet newOptions = newMeta.getPropertySet();
if (origOptions.equals(newOptions) == false) {
fail("Meta options of input tables not equal");
return false;
}
}
return true;
}
/** Insert row values */
private void insertRowValues(
QueryContext queryContext,
InsertNode insertNode,
SubmitQueryResponse.Builder responseBuilder) {
try {
String nodeUniqName =
insertNode.getTableName() == null
? new Path(insertNode.getUri()).getName()
: insertNode.getTableName();
String queryId = nodeUniqName + "_" + System.currentTimeMillis();
URI finalOutputUri = insertNode.getUri();
Tablespace space = TablespaceManager.get(finalOutputUri).get();
TableMeta tableMeta = new TableMeta(insertNode.getStorageType(), insertNode.getOptions());
tableMeta.putOption(StorageConstants.INSERT_DIRECTLY, Boolean.TRUE.toString());
FormatProperty formatProperty = space.getFormatProperty(tableMeta);
TaskAttemptContext taskAttemptContext;
if (formatProperty
.directInsertSupported()) { // if this format and storage supports direct insertion
taskAttemptContext = new TaskAttemptContext(queryContext, null, null, null, null);
taskAttemptContext.setOutputPath(new Path(finalOutputUri));
EvalExprExec evalExprExec =
new EvalExprExec(taskAttemptContext, (EvalExprNode) insertNode.getChild());
InsertRowsExec exec = new InsertRowsExec(taskAttemptContext, insertNode, evalExprExec);
try {
exec.init();
exec.next();
} finally {
exec.close();
}
} else {
URI stagingSpaceUri =
space.prepareStagingSpace(context.getConf(), queryId, queryContext, tableMeta);
Path stagingDir = new Path(stagingSpaceUri);
Path stagingResultDir = new Path(stagingDir, TajoConstants.RESULT_DIR_NAME);
taskAttemptContext = new TaskAttemptContext(queryContext, null, null, null, stagingDir);
taskAttemptContext.setOutputPath(new Path(stagingResultDir, "part-01-000000"));
insertRowsThroughStaging(
taskAttemptContext, insertNode, new Path(finalOutputUri), stagingDir, stagingResultDir);
}
// set insert stats (how many rows and bytes)
TableStats stats = new TableStats();
stats.setNumBytes(taskAttemptContext.getResultStats().getNumBytes());
stats.setNumRows(taskAttemptContext.getResultStats().getNumRows());
if (insertNode.hasTargetTable()) {
CatalogProtos.UpdateTableStatsProto.Builder builder =
CatalogProtos.UpdateTableStatsProto.newBuilder();
builder.setTableName(insertNode.getTableName());
builder.setStats(stats.getProto());
catalog.updateTableStats(builder.build());
TableDesc desc =
new TableDesc(
insertNode.getTableName(), insertNode.getTargetSchema(), tableMeta, finalOutputUri);
responseBuilder.setTableDesc(desc.getProto());
} else { // If INSERT INTO LOCATION
// Empty TableDesc
List<CatalogProtos.ColumnProto> columns = new ArrayList<CatalogProtos.ColumnProto>();
CatalogProtos.TableDescProto tableDescProto =
CatalogProtos.TableDescProto.newBuilder()
.setTableName(nodeUniqName)
.setMeta(
CatalogProtos.TableProto.newBuilder()
.setStoreType(BuiltinStorages.TEXT)
.build())
.setSchema(CatalogProtos.SchemaProto.newBuilder().addAllFields(columns).build())
.setStats(stats.getProto())
.build();
responseBuilder.setTableDesc(tableDescProto);
}
// If queryId == NULL_QUERY_ID and MaxRowNum == -1, TajoCli prints only number of inserted
// rows.
responseBuilder.setMaxRowNum(-1);
responseBuilder.setQueryId(QueryIdFactory.NULL_QUERY_ID.getProto());
responseBuilder.setResultType(ResultType.NO_RESULT);
responseBuilder.setState(OK);
} catch (Throwable t) {
throw new RuntimeException(t);
}
}
@Override
public void initFromProto() {
mergeProtoToLocal();
meta.initFromProto();
}
public TableDescProto getProto() {
if (builder == null) {
builder = TableDescProto.newBuilder();
}
if (this.tableName != null) {
builder.setId(this.tableName);
}
if (this.schema != null) {
builder.setSchema(schema.getProto());
}
if (this.meta != null) {
builder.setMeta(meta.getProto());
}
if (this.uri != null) {
builder.setPath(this.uri.toString());
}
if (this.stats != null) {
builder.setStats(this.stats.getProto());
}
if (this.partitionMethodDesc != null) {
builder.setPartition(this.partitionMethodDesc.getProto());
}
return builder.build();
}
