/*
* Licensed 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 com.facebook.presto.jdbc.internal.client;
import com.facebook.presto.jdbc.internal.type.type.TypeSignature;
import com.facebook.presto.jdbc.internal.jackson.annotation.JsonCreator;
import com.facebook.presto.jdbc.internal.jackson.annotation.JsonProperty;
import com.facebook.presto.jdbc.internal.guava.base.Objects;
import com.facebook.presto.jdbc.internal.guava.collect.ImmutableList;
import com.facebook.presto.jdbc.internal.guava.io.BaseEncoding;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import javax.validation.constraints.NotNull;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static com.facebook.presto.jdbc.internal.type.type.TypeSignature.parseTypeSignature;
import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkArgument;
import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkNotNull;
import static com.facebook.presto.jdbc.internal.guava.collect.Iterables.unmodifiableIterable;
import static java.util.Collections.unmodifiableList;
@Immutable
public class QueryResults
{
private final String id;
private final URI infoUri;
private final URI partialCancelUri;
private final URI nextUri;
private final List<Column> columns;
private final Iterable<List<Object>> data;
private final StatementStats stats;
private final QueryError error;
@JsonCreator
public QueryResults(
@JsonProperty("id") String id,
@JsonProperty("infoUri") URI infoUri,
@JsonProperty("partialCancelUri") URI partialCancelUri,
@JsonProperty("nextUri") URI nextUri,
@JsonProperty("columns") List<Column> columns,
@JsonProperty("data") List<List<Object>> data,
@JsonProperty("stats") StatementStats stats,
@JsonProperty("error") QueryError error)
{
this(id, infoUri, partialCancelUri, nextUri, columns, fixData(columns, data), stats, error);
}
public QueryResults(
String id,
URI infoUri,
URI partialCancelUri,
URI nextUri,
List<Column> columns,
Iterable<List<Object>> data,
StatementStats stats,
QueryError error)
{
this.id = checkNotNull(id, "id is null");
this.infoUri = checkNotNull(infoUri, "infoUri is null");
this.partialCancelUri = partialCancelUri;
this.nextUri = nextUri;
this.columns = (columns != null) ? ImmutableList.copyOf(columns) : null;
this.data = (data != null) ? unmodifiableIterable(data) : null;
this.stats = checkNotNull(stats, "stats is null");
this.error = error;
}
@NotNull
@JsonProperty
public String getId()
{
return id;
}
@NotNull
@JsonProperty
public URI getInfoUri()
{
return infoUri;
}
@Nullable
@JsonProperty
public URI getPartialCancelUri()
{
return partialCancelUri;
}
@Nullable
@JsonProperty
public URI getNextUri()
{
return nextUri;
}
@Nullable
@JsonProperty
public List<Column> getColumns()
{
return columns;
}
@Nullable
@JsonProperty
public Iterable<List<Object>> getData()
{
return data;
}
@NotNull
@JsonProperty
public StatementStats getStats()
{
return stats;
}
@Nullable
@JsonProperty
public QueryError getError()
{
return error;
}
@Override
public String toString()
{
return Objects.toStringHelper(this)
.add("id", id)
.add("infoUri", infoUri)
.add("partialCancelUri", partialCancelUri)
.add("nextUri", nextUri)
.add("columns", columns)
.add("hasData", data != null)
.add("stats", stats)
.add("error", error)
.toString();
}
private static Iterable<List<Object>> fixData(List<Column> columns, List<List<Object>> data)
{
if (data == null) {
return null;
}
checkNotNull(columns, "columns is null");
ImmutableList.Builder<List<Object>> rows = ImmutableList.builder();
for (List<Object> row : data) {
checkArgument(row.size() == columns.size(), "row/column size mismatch");
List<Object> newRow = new ArrayList<>();
for (int i = 0; i < row.size(); i++) {
newRow.add(fixValue(columns.get(i).getType(), row.get(i)));
}
rows.add(unmodifiableList(newRow)); // allow nulls in list
}
return rows.build();
}
/**
* Force values coming from Jackson to have the expected object type.
*/
private static Object fixValue(String type, Object value)
{
if (value == null) {
return null;
}
TypeSignature signature = parseTypeSignature(type);
if (signature.getBase().equals("array")) {
List<Object> fixedValue = new ArrayList<>();
for (Object object : List.class.cast(value)) {
fixedValue.add(fixValue(signature.getParameters().get(0).toString(), object));
}
return fixedValue;
}
if (signature.getBase().equals("map")) {
String keyType = signature.getParameters().get(0).toString();
String valueType = signature.getParameters().get(1).toString();
Map<Object, Object> fixedValue = new HashMap<>();
for (Map.Entry<?, ?> entry : (Set<Map.Entry<?, ?>>) Map.class.cast(value).entrySet()) {
fixedValue.put(fixValue(keyType, entry.getKey()), fixValue(valueType, entry.getValue()));
}
return fixedValue;
}
switch (type) {
case "bigint":
return ((Number) value).longValue();
case "double":
if (value instanceof String) {
return Double.parseDouble((String) value);
}
return ((Number) value).doubleValue();
case "boolean":
return Boolean.class.cast(value);
case "varchar":
case "time":
case "time with time zone":
case "timestamp":
case "timestamp with time zone":
case "date":
case "interval year to month":
case "interval day to second":
return String.class.cast(value);
default:
// for now we assume that only the explicit types above are passed
// as a plain text and everything else is base64 encoded binary
if (value instanceof String) {
return BaseEncoding.base64().decode((String) value);
}
return value;
}
}
}