implements Comparable<TypeDescription>, Serializable, Cloneable {

private static final int MAX_PRECISION = 38;

private static final int MAX_SCALE = 38;

private static final int DEFAULT_PRECISION = 38;

private static final int DEFAULT_SCALE = 10;

public static final int MAX_DECIMAL64_PRECISION = 18;

public static final long MAX_DECIMAL64 = 999_999_999_999_999_999L;

public static final long MIN_DECIMAL64 = -MAX_DECIMAL64;

private static final int DEFAULT_LENGTH = 256;

private static final String DEFAULT_CRS = "OGC:CRS84";

static final Pattern UNQUOTED_NAMES = Pattern.compile("^[a-zA-Z0-9_]+$");

// type attributes

public static final String ENCRYPT_ATTRIBUTE = "encrypt";

public static final String MASK_ATTRIBUTE = "mask";

public enum EdgeInterpolationAlgorithm {

SPHERICAL("spherical"),

VINCENTY("vincenty"),

THOMAS("thomas"),

ANDOYER("andoyer"),

KARNEY("karney");

EdgeInterpolationAlgorithm(String name) {

this.name = name;

}

final String name;

}

private static final EdgeInterpolationAlgorithm DEFAULT_EDGE_INTERPOLATION_ALGORITHM

= EdgeInterpolationAlgorithm.SPHERICAL;

@Override

public int compareTo(TypeDescription other) {

if (this == other) {

return 0;

} else if (other == null) {

return -1;

} else {

int result = category.compareTo(other.category);

if (result == 0) {

switch (category) {

case CHAR:

case VARCHAR:

return maxLength - other.maxLength;

case DECIMAL:

if (precision != other.precision) {

return precision - other.precision;

}

return scale - other.scale;

case UNION:

case LIST:

case MAP:

if (children.size() != other.children.size()) {

return children.size() - other.children.size();

}

for(int c=0; result == 0 && c < children.size(); ++c) {

result = children.get(c).compareTo(other.children.get(c));

}

break;

case STRUCT:

if (children.size() != other.children.size()) {

return children.size() - other.children.size();

}

for(int c=0; result == 0 && c < children.size(); ++c) {

result = fieldNames.get(c).compareTo(other.fieldNames.get(c));

if (result == 0) {

result = children.get(c).compareTo(other.children.get(c));

}

}

break;

default:

// PASS

}

}

return result;

}

}

public enum Category {

BOOLEAN("boolean", true),

BYTE("tinyint", true),

SHORT("smallint", true),

INT("int", true),

LONG("bigint", true),

FLOAT("float", true),

DOUBLE("double", true),

STRING("string", true),

DATE("date", true),

TIMESTAMP("timestamp", true),

BINARY("binary", true),

DECIMAL("decimal", true),

VARCHAR("varchar", true),

CHAR("char", true),

LIST("array", false),

MAP("map", false),

STRUCT("struct", false),

UNION("uniontype", false),

TIMESTAMP_INSTANT("timestamp with local time zone", true),

Geometry("geometry", true),

Geography("geography", true);

Category(String name, boolean isPrimitive) {

this.name = name;

this.isPrimitive = isPrimitive;

}

final boolean isPrimitive;

final String name;

public boolean isPrimitive() {

return isPrimitive;

}

public String getName() {

return name;

}

}

public static TypeDescription createBoolean() {

return new TypeDescription(Category.BOOLEAN);

}

public static TypeDescription createByte() {

return new TypeDescription(Category.BYTE);

}

public static TypeDescription createShort() {

return new TypeDescription(Category.SHORT);

}

public static TypeDescription createInt() {

return new TypeDescription(Category.INT);

}

public static TypeDescription createLong() {

return new TypeDescription(Category.LONG);

}

public static TypeDescription createFloat() {

return new TypeDescription(Category.FLOAT);

}

public static TypeDescription createDouble() {

return new TypeDescription(Category.DOUBLE);

}

public static TypeDescription createString() {

return new TypeDescription(Category.STRING);

}

public static TypeDescription createDate() {

return new TypeDescription(Category.DATE);

}

public static TypeDescription createTimestamp() {

return new TypeDescription(Category.TIMESTAMP);

}

public static TypeDescription createTimestampInstant() {

return new TypeDescription(Category.TIMESTAMP_INSTANT);

}

public static TypeDescription createBinary() {

return new TypeDescription(Category.BINARY);

}

public static TypeDescription createDecimal() {

return new TypeDescription(Category.DECIMAL);

}

public static TypeDescription createGeometry() {

return new TypeDescription(Category.Geometry);

}

public static TypeDescription createGeography() {

return new TypeDescription(Category.Geography);

}

/**

public static TypeDescription fromString(String typeName) {

if (typeName == null) {

return null;

}

ParserUtils.StringPosition source = new ParserUtils.StringPosition(typeName);

TypeDescription result = ParserUtils.parseType(source);

if (source.hasCharactersLeft()) {

throw new IllegalArgumentException("Extra characters at " + source);

}

return result;

}

/**

public TypeDescription withPrecision(int precision) {

if (category != Category.DECIMAL) {

throw new IllegalArgumentException("precision is only allowed on decimal"+

" and not " + category.name);

} else if (precision < 1 || precision > MAX_PRECISION) {

throw new IllegalArgumentException(

"precision " + precision + " must be between 1 and " + MAX_PRECISION

);

} else if (scale > precision) {

throw new IllegalArgumentException("scale " + scale +

" must be less than or equal to precision " + precision);

}

this.precision = precision;

return this;

}

/**

public TypeDescription withScale(int scale) {

if (category != Category.DECIMAL) {

throw new IllegalArgumentException("scale is only allowed on decimal"+

" and not " + category.name);

} else if (scale < 0 || scale > MAX_SCALE || scale > precision) {

throw new IllegalArgumentException("scale is out of range at " + scale);

}

this.scale = scale;

return this;

}

public TypeDescription withCRS(String crs) {

if (category != Category.Geometry &&

category != Category.Geography) {

throw new IllegalArgumentException("crs is only allowed on Geometry/Geography" +

" and not " + category.name);

}

this.crs = crs;

return this;

}

public TypeDescription withEdgeInterpolationAlgorithm(

EdgeInterpolationAlgorithm edgeInterpolationAlgorithm) {

if (category != Category.Geography) {

throw new IllegalArgumentException("edgeInterpolationAlgorithm is only allowed on Geography" +

" and not " + category.name);

}

this.edgeInterpolationAlgorithm = edgeInterpolationAlgorithm;

return this;

}

/**

public TypeDescription setAttribute(@NotNull String key,

String value) {

if (value == null) {

attributes.remove(key);

} else {

attributes.put(key, value);

}

return this;

}

/**

public TypeDescription removeAttribute(@NotNull String key) {

attributes.remove(key);

return this;

}

public static TypeDescription createVarchar() {

return new TypeDescription(Category.VARCHAR);

}

public static TypeDescription createChar() {

return new TypeDescription(Category.CHAR);

}

/**

public TypeDescription withMaxLength(int maxLength) {

if (category != Category.VARCHAR && category != Category.CHAR) {

throw new IllegalArgumentException("maxLength is only allowed on char" +

" and varchar and not " + category.name);

}

this.maxLength = maxLength;

return this;

}

public static TypeDescription createList(TypeDescription childType) {

TypeDescription result = new TypeDescription(Category.LIST);

result.children.add(childType);

childType.parent = result;

return result;

}

public static TypeDescription createMap(TypeDescription keyType,

TypeDescription valueType) {

TypeDescription result = new TypeDescription(Category.MAP);

result.children.add(keyType);

result.children.add(valueType);

keyType.parent = result;

valueType.parent = result;

return result;

}

public static TypeDescription createUnion() {

return new TypeDescription(Category.UNION);

}

public static TypeDescription createStruct() {

return new TypeDescription(Category.STRUCT);

}

/**

public TypeDescription addUnionChild(TypeDescription child) {

if (category != Category.UNION) {

throw new IllegalArgumentException("Can only add types to union type" +

" and not " + category);

}

addChild(child);

return this;

}

/**

public TypeDescription addField(String field, TypeDescription fieldType) {

if (category != Category.STRUCT) {

throw new IllegalArgumentException("Can only add fields to struct type" +

" and not " + category);

}

fieldNames.add(field);

addChild(fieldType);

return this;

}

/**

public int getId() {

// if the id hasn't been assigned, assign all of the ids from the root

if (id == -1) {

TypeDescription root = this;

while (root.parent != null) {

root = root.parent;

}

root.assignIds(0);

}

return id;

}

@Override

public TypeDescription clone() {

TypeDescription result = new TypeDescription(category);

result.maxLength = maxLength;

result.precision = precision;

result.scale = scale;

result.crs = crs;

result.edgeInterpolationAlgorithm = edgeInterpolationAlgorithm;

if (fieldNames != null) {

result.fieldNames.addAll(fieldNames);

}

if (children != null) {

for(TypeDescription child: children) {

TypeDescription clone = child.clone();

clone.parent = result;

result.children.add(clone);

}

}

for (Map.Entry<String,String> pair: attributes.entrySet()) {

result.attributes.put(pair.getKey(), pair.getValue());

}

return result;

}

@Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + category.hashCode();

if (children != null) {

result = prime * result + children.hashCode();

}

result = prime * result + maxLength;

result = prime * result + precision;

result = prime * result + scale;

return result;

}

@Override

public boolean equals(Object other) {

return equals(other, true);

}

/**

public boolean equals(Object other, boolean checkAttributes) {

if (other == null || !(other instanceof TypeDescription castOther)) {

return false;

}

if (other == this) {

return true;

}

if (category != castOther.category ||

maxLength != castOther.maxLength ||

scale != castOther.scale ||

precision != castOther.precision) {

return false;

}

if (checkAttributes) {

// make sure the attributes are the same

List<String> attributeNames = getAttributeNames();

if (castOther.getAttributeNames().size() != attributeNames.size()) {

return false;

}

for (String attribute : attributeNames) {

if (!getAttributeValue(attribute).equals(castOther.getAttributeValue(attribute))) {

return false;

}

}

}

// check the children

if (children != null) {

if (children.size() != castOther.children.size()) {

return false;

}

for (int i = 0; i < children.size(); ++i) {

if (!children.get(i).equals(castOther.children.get(i), checkAttributes)) {

return false;

}

}

}

if (category == Category.STRUCT) {

for(int i=0; i < fieldNames.size(); ++i) {

if (!fieldNames.get(i).equals(castOther.fieldNames.get(i))) {

return false;

}

}

}

return true;

}

/**

public int getMaximumId() {

// if the id hasn't been assigned, assign all of the ids from the root

if (maxId == -1) {

TypeDescription root = this;

while (root.parent != null) {

root = root.parent;

}

root.assignIds(0);

}

return maxId;

}

/**

public enum RowBatchVersion {

ORIGINAL,

USE_DECIMAL64;

}

public VectorizedRowBatch createRowBatch(RowBatchVersion version, int size) {

VectorizedRowBatch result;

if (category == Category.STRUCT) {

result = new VectorizedRowBatch(children.size(), size);

for(int i=0; i < result.cols.length; ++i) {

result.cols[i] = TypeUtils.createColumn(children.get(i), version, size);

}

} else {

result = new VectorizedRowBatch(1, size);

result.cols[0] = TypeUtils.createColumn(this, version, size);

}

result.reset();

return result;

}

/**

public VectorizedRowBatch createRowBatchV2() {

return createRowBatch(RowBatchVersion.USE_DECIMAL64,

VectorizedRowBatch.DEFAULT_SIZE);

}

/**

public VectorizedRowBatch createRowBatch(int maxSize) {

return createRowBatch(RowBatchVersion.ORIGINAL, maxSize);

}

/**

public VectorizedRowBatch createRowBatch() {

return createRowBatch(RowBatchVersion.ORIGINAL,

VectorizedRowBatch.DEFAULT_SIZE);

}

/**

public Category getCategory() {

return category;

}

/**

public int getMaxLength() {

return maxLength;

}

/**

public int getPrecision() {

return precision;

}

/**

public int getScale() {

return scale;

}

public String getCrs() {

return crs;

}

public EdgeInterpolationAlgorithm getEdgeInterpolationAlgorithm() {

return edgeInterpolationAlgorithm;

}

/**

public List<String> getFieldNames() {

return Collections.unmodifiableList(fieldNames);

}

/**

public List<String> getAttributeNames() {

List<String> result = new ArrayList<>(attributes.keySet());

Collections.sort(result);

return result;

}

/**

public String getAttributeValue(String attributeName) {

return attributes.get(attributeName);

}

/**

public TypeDescription getParent() {

return parent;

}

/**

public List<TypeDescription> getChildren() {

return children == null ? null : Collections.unmodifiableList(children);

}

/**

private int assignIds(int startId) {

id = startId++;

if (children != null) {

for (TypeDescription child : children) {

startId = child.assignIds(startId);

}

}

maxId = startId - 1;

return startId;

}

/**

public void addChild(TypeDescription child) {

switch (category) {

case LIST:

if (children.size() >= 1) {

throw new IllegalArgumentException("Can't add more children to list");

}

case MAP:

if (children.size() >= 2) {

throw new IllegalArgumentException("Can't add more children to map");

}

case UNION:

case STRUCT:

children.add(child);

child.parent = this;

break;

default:

throw new IllegalArgumentException("Can't add children to " + category);

}

}

public TypeDescription(Category category) {

this.category = category;

if (category.isPrimitive) {

children = null;

} else {

children = new ArrayList<>();

}

if (category == Category.STRUCT) {

fieldNames = new ArrayList<>();

} else {

fieldNames = null;

}

}

private int id = -1;

private int maxId = -1;

private TypeDescription parent;

private final Category category;

private final List<TypeDescription> children;

private final List<String> fieldNames;

private final Map<String,String> attributes = new HashMap<>();

private int maxLength = DEFAULT_LENGTH;

private int precision = DEFAULT_PRECISION;

private int scale = DEFAULT_SCALE;

private String crs = DEFAULT_CRS;

private EdgeInterpolationAlgorithm edgeInterpolationAlgorithm

= DEFAULT_EDGE_INTERPOLATION_ALGORITHM;

static void printFieldName(StringBuilder buffer, String name) {

if (UNQUOTED_NAMES.matcher(name).matches()) {

buffer.append(name);

} else {

buffer.append('`');

buffer.append(name.replace("`", "``"));

buffer.append('`');

}

}

public void printToBuffer(StringBuilder buffer) {

buffer.append(category.name);

switch (category) {

case DECIMAL:

buffer.append('(');

buffer.append(precision);

buffer.append(',');

buffer.append(scale);

buffer.append(')');

break;

case CHAR:

case VARCHAR:

buffer.append('(');

buffer.append(maxLength);

buffer.append(')');

break;

case Geometry:

buffer.append('(');

buffer.append(crs);

buffer.append(')');

break;

case Geography:

buffer.append('(');

buffer.append(crs);

buffer.append(',');

buffer.append(edgeInterpolationAlgorithm.name());

buffer.append(')');

break;

case LIST:

case MAP:

case UNION:

buffer.append('<');

for(int i=0; i < children.size(); ++i) {

if (i != 0) {

buffer.append(',');

}

children.get(i).printToBuffer(buffer);

}

buffer.append('>');

break;

case STRUCT:

buffer.append('<');

for(int i=0; i < children.size(); ++i) {

if (i != 0) {

buffer.append(',');

}

printFieldName(buffer, fieldNames.get(i));

buffer.append(':');

children.get(i).printToBuffer(buffer);

}

buffer.append('>');

break;

default:

break;

}

}

@Override

public String toString() {

StringBuilder buffer = new StringBuilder();

printToBuffer(buffer);

return buffer.toString();

}

private void printJsonToBuffer(String prefix, StringBuilder buffer,

int indent) {

for(int i=0; i < indent; ++i) {

buffer.append(' ');

}

buffer.append(prefix);

buffer.append("{\"category\": \"");

buffer.append(category.name);

buffer.append("\", \"id\": ");

buffer.append(getId());

buffer.append(", \"max\": ");

buffer.append(maxId);

switch (category) {

case DECIMAL:

buffer.append(", \"precision\": ");

buffer.append(precision);

buffer.append(", \"scale\": ");

buffer.append(scale);

break;

case CHAR:

case VARCHAR:

buffer.append(", \"length\": ");

buffer.append(maxLength);

break;

case Geometry:

buffer.append(", \"crs\": ");

buffer.append(crs);

break;

case Geography:

buffer.append(", \"crs\": ");

buffer.append(crs);

buffer.append(", \"edge_interpolation_algorithm\": ");

buffer.append(edgeInterpolationAlgorithm.name());

break;

case LIST:

case MAP:

case UNION:

buffer.append(", \"children\": [");

for(int i=0; i < children.size(); ++i) {

buffer.append('\n');

children.get(i).printJsonToBuffer("", buffer, indent + 2);

if (i != children.size() - 1) {

buffer.append(',');

}

}

buffer.append("]");

break;

case STRUCT:

buffer.append(", \"fields\": [");

for(int i=0; i < children.size(); ++i) {

buffer.append('\n');

buffer.append('{');

children.get(i).printJsonToBuffer("\"" + fieldNames.get(i) + "\": ",

buffer, indent + 2);

buffer.append('}');

if (i != children.size() - 1) {

buffer.append(',');

}

}

buffer.append(']');

break;

default:

break;

}

buffer.append('}');

}

public String toJson() {

StringBuilder buffer = new StringBuilder();

printJsonToBuffer("", buffer, 0);

return buffer.toString();

}

/**

public TypeDescription findSubtype(int goal) {

ParserUtils.TypeFinder result = new ParserUtils.TypeFinder(this);

ParserUtils.findSubtype(this, goal, result);

return result.current;

}

/**

public TypeDescription findSubtype(String columnName) {

return findSubtype(columnName, true);

}

public TypeDescription findSubtype(String columnName,

boolean isSchemaEvolutionCaseAware) {

ParserUtils.StringPosition source = new ParserUtils.StringPosition(columnName);

TypeDescription result = ParserUtils.findSubtype(this, source,

isSchemaEvolutionCaseAware);

if (source.hasCharactersLeft()) {

throw new IllegalArgumentException("Remaining text in parsing field name "

+ source);

}

return result;

}

/**

public List<TypeDescription> findSubtypes(String columnNameList) {

ParserUtils.StringPosition source = new ParserUtils.StringPosition(columnNameList);

List<TypeDescription> result = ParserUtils.findSubtypeList(this, source);

if (source.hasCharactersLeft()) {

throw new IllegalArgumentException("Remaining text in parsing field name "

+ source);

}

return result;

}

/**

public void annotateEncryption(String encryption, String masks) {

ParserUtils.StringPosition source = new ParserUtils.StringPosition(encryption);

ParserUtils.parseKeys(source, this);

if (source.hasCharactersLeft()) {

throw new IllegalArgumentException("Remaining text in parsing encryption keys "

+ source);

}

source = new ParserUtils.StringPosition(masks);

ParserUtils.parseMasks(source, this);

if (source.hasCharactersLeft()) {

throw new IllegalArgumentException("Remaining text in parsing encryption masks "

+ source);

}

}

/**

private int getChildIndex(TypeDescription child) {

for(int i=children.size() - 1; i >= 0; --i) {

if (children.get(i) == child) {

return i;

}

}

throw new IllegalArgumentException("Child not found");

}

/**

private String getPartialName(TypeDescription child) {

switch (category) {

case LIST:

return "_elem";

case MAP:

return getChildIndex(child) == 0 ? "_key" : "_value";

case STRUCT:

return fieldNames.get(getChildIndex(child));

case UNION:

return Integer.toString(getChildIndex(child));

default:

throw new IllegalArgumentException(

"Can't get the field name of a primitive type");

}

}

/**