/*
* 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.pig.scripting.jruby;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Arrays;
import org.apache.pig.impl.logicalLayer.schema.Schema;
import org.apache.pig.impl.util.Utils;
import org.apache.pig.data.DataType;
import org.apache.pig.parser.ParserException;
import org.apache.pig.impl.logicalLayer.FrontendException;
import org.jruby.Ruby;
import org.jruby.RubyHash;
import org.jruby.RubyArray;
import org.jruby.RubyClass;
import org.jruby.RubyFixnum;
import org.jruby.RubyModule;
import org.jruby.RubyObject;
import org.jruby.RubyRange;
import org.jruby.RubyString;
import org.jruby.RubySymbol;
import org.jruby.anno.JRubyClass;
import org.jruby.anno.JRubyMethod;
import org.jruby.runtime.ObjectAllocator;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.Block;
import org.jruby.runtime.builtin.IRubyObject;
//TODO implement all of the merge functions
/**
* This class encapsulated a native Schema object, and provides a more convenient
* interface for manipulating Schemas. It hides the Schema/FieldSchema distinction
* from the user, and tries to present a cleaner, more Ruby-esque API to the user.
* For general information on JRuby's API definition annotations,
* see {@link RubyDataBag}.
*/
@JRubyClass(name = "Schema")
public class RubySchema extends RubyObject {
private static final long serialVersionUID = 1L;
/**
* This is a pattern used in the conversion from ruby arguments to a valid Schema. It detects
* cases where there is a bag, map, or tuple without being followed by {}, [], or () respectively.
* It is used for convenience.
*/
private static final Pattern bmtPattern = Pattern.compile("(?:\\S+:)?(bag|map|tuple)\\s*(?:,|$)", Pattern.CASE_INSENSITIVE);
/**
* This is the encapsulated Schema object.
*/
private Schema internalSchema;
private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
public IRubyObject allocate(Ruby runtime, RubyClass klass) {
return new RubySchema(runtime, klass);
}
};
/**
* This method registers the class with the given runtime.
*
* @param runtime an instance of the Ruby runtime
* @return a RubyClass object with metadata about the registered class
*/
public static RubyClass define(Ruby runtime) {
RubyClass result = runtime.defineClass("Schema",runtime.getObject(), ALLOCATOR);
result.kindOf = new RubyModule.KindOf() {
public boolean isKindOf(IRubyObject obj, RubyModule type) {
return obj instanceof RubySchema;
}
};
result.includeModule(runtime.getEnumerable());
result.defineAnnotatedMethods(RubySchema.class);
return result;
}
protected RubySchema(final Ruby ruby, RubyClass rc) {
super(ruby,rc);
internalSchema = new Schema();
}
/**
* This constructor sets the encapsulated Schema to be equal to
* the given Schema. If copy is true, it is set equal to a copy.
* If it is false, it is set directly equal.
*
* @param ruby an instance of the ruby runtime
* @param rc an instance of the class object with meatadata
* @param s a Schema to encapsulate
* @param copy a boolean value. If true, s will be copied and the copy
* will be encapsulated. If false, it will be encapsulated
* directly.
*/
protected RubySchema(final Ruby ruby, RubyClass rc, Schema s, boolean copy) {
super(ruby,rc);
if (copy) {
internalSchema = new Schema(s);
} else {
internalSchema = s;
}
}
/**
* This constructor sets the encapsulated Schema to be equal to the
* given Schema.
*
* @param ruby an instance of the ruby runtime
* @param rc an instance of the class object with meatadata
* @param s a Schema to encapsulate
*/
protected RubySchema(final Ruby ruby, RubyClass rc, Schema s) {
this(ruby, rc, s, true);
}
/**
* This constructor is provided for convenience and sets the
* internal Schema equal to the result of a call to
* {@link Utils#getSchemaFromString}.
*
* @param ruby an instance of the ruby runtime
* @param rc an instance of the class object with meatadata
* @param s a String which will be passed to
* {@link Utils#getSchemaFromString}
*/
protected RubySchema(final Ruby ruby, RubyClass rc, String s) {
super(ruby, rc);
try {
internalSchema = Utils.getSchemaFromString(s);
} catch (ParserException e) {
throw new RuntimeException("Error converting String to Schema: " + s, e);
}
}
/**
* The ruby initializer accepts any number of arguments. With no arguments,
* it will return an empty Schema object. It can accept any number of arguments.
* To understand the valid arguments, see the documentation for {@link #rubyArgToSchema}.
*
* @param args a varargs which can take any number of valid arguments to
* {@link #rubyArgToSchema}
* @return the initialized RubySchema
*/
@JRubyMethod(rest = true)
public RubySchema initialize(IRubyObject[] args) {
internalSchema = new Schema();
for (IRubyObject arg : args) {
Schema rs = rubyArgToSchema(arg);
for (Schema.FieldSchema i : rs.getFields())
internalSchema.add(i);
}
RubySchema.fixSchemaNames(internalSchema);
return this;
}
/**
* This is a static helper method to create a null aliased bytearray Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"by", "bytearray"})
public static RubySchema nullBytearray(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.BYTEARRAY);
}
/**
* This is a static helper method to create a null aliased Boolean Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"bool", "boolean"})
public static RubySchema nullBoolean(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.BOOLEAN);
}
/**
* This is a static helper method to create a null aliased chararray Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"c", "chararray"})
public static RubySchema nullChararray(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.CHARARRAY);
}
/**
* This is a static helper method to create a null aliased long Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"l", "long"})
public static RubySchema nullLong(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.LONG);
}
/**
* This is a static helper method to create a null aliased int Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"i", "int"})
public static RubySchema nullInt(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.INTEGER);
}
/**
* This is a static helper method to create a null aliased double Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"d", "double"})
public static RubySchema nullDouble(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.DOUBLE);
}
/**
* This is a static helper method to create a null aliased float Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"f", "float"})
public static RubySchema nullFloate(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.FLOAT);
}
/**
* This is a static helper method to create a null aliased datetime Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"dt", "datetime"})
public static RubySchema nullDateTime(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.DATETIME);
}
/**
* This is a static helper method to create a null aliased tuple Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"t", "tuple"})
public static RubySchema nullTuple(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.TUPLE);
}
/**
* This is a static helper method to create a null aliased bag Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"b", "bag"})
public static RubySchema nullBag(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.BAG);
}
/**
* This is a static helper method to create a null aliased map Schema.
* This is useful in cases where you do not want the output to have an explicit
* name, which {@link Utils#getSchemaFromString} will assign.
*
* @param context the context the method is being executed in
* @param self an instance of the RubyClass with metadata on
* the Ruby class object this method is being
* statically invoked against
* @return a null-aliased bytearray schema
*/
@JRubyMethod(meta = true, name = {"m", "map"})
public static RubySchema nullMap(ThreadContext context, IRubyObject self) {
return makeNullAliasRubySchema(context, DataType.MAP);
}
/**
* This is a helper method to generate a RubySchema of the given type without an alias.
*
* @param context the context the method is being executed in
* @param type the DataType.PIGTYPE value to make the Schema from
* @return a RubySchema object encapsulated a Schema of the specified type
*/
private static RubySchema makeNullAliasRubySchema(ThreadContext context, byte type) {
Ruby runtime = context.getRuntime();
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(new Schema.FieldSchema(null, type)));
}
/**
* This is a helper function which converts objects into Schema objects. The valid
* options are as follows:
* <p>
* A RubyString, which will have {@link Utils#getSchemaFromString} called on it, and
* it will be added.
* <p>
* A RubySchema, which will be added directly. IMPORTANT NOTE: since this API abstracts
* away from the distinction between Schema/FieldSchema, its important to understand
* how a Schema is added to another. In this case, the FieldSchema is pulled directly
* out of the given Schema. Thus, where in Pig a Schema.FieldSchema might be passed around,
* internally to this class, generally a Schema will be passed around encapsulating it.
* <p>
* A list will create the Schema for a Tuple whose elements will be the elements of the
* list. Each element will be subjected to the same rules applied here.
* <p>
* A hash in the form of:<br>
* <code>{"name:tuple"=>["x:int","y:int,z:int"], "name2:bag"=>["a:chararray"]}</code><br>
* The keys must be a tuple, bag, or map, and the value must be an array.
*
* @param arg an object (generally an IRubyObject or String) to convert. See above for
the rules on valid arguments
* @return the Schema constructed for the given argument
*/
public static Schema rubyArgToSchema(Object arg) {
try {
/**
* Given a String or a RubyString, calls {@link Utils#getSchemaFromString}.
* Additionally, as a convenience to the user, this method uses a regex to
* detect any case where a schema declaration of "bag", "tuple", or "map"
* does not have the trailing "{}", "()", or "[]" that
* {@link Utils#getSchemaFromString} requires.
*/
if (arg instanceof String || arg instanceof RubyString) {
String s = arg.toString();
Matcher m = bmtPattern.matcher(s);
while (m.find()) {
String type = m.group(1);
String inter = s.substring(0, m.start(1));
if (type.equalsIgnoreCase("bag")) {
inter += "{}";
} else if (type.equalsIgnoreCase("map")) {
inter += "[]";
} else if (type.equalsIgnoreCase("tuple")) {
inter += "()";
} else {
throw new RuntimeException("Arriving here should be impossible");
}
s = inter + s.substring(m.end(1));
m = bmtPattern.matcher(s);
}
return Utils.getSchemaFromString(s);
// In the case of a RubySchema, can just return the encapsulated Schema
} else if (arg instanceof RubySchema) {
return ((RubySchema)arg).getInternalSchema();
// In the case of a RubyArray, the elements of the array are passed to this
// method, and they will be treated as elements of a Tuple Schema.
} else if (arg instanceof RubyArray) {
RubyArray ary = (RubyArray)arg;
Schema s = new Schema();
for (Object o : ary) {
Schema ts = rubyArgToSchema(o);
for (Schema.FieldSchema fs : ts.getFields()) {
s.add(fs);
}
}
return new Schema(new Schema.FieldSchema("tuple_0", s, DataType.TUPLE));
/**
* In the case of a RubyHash, the key serves defines a Schema that will encapsulate
* other elements. This mainly is for the convenience of being able to name
* bags, maps, and tuples while easily being able to have interchangeable elements.
* The key will be given to this method, but must return a singular map, tuple, or
* bag, or an error will be thrown. The value to that key must be an array, and
* each element will be passed to this method and then added to the Schema for
* the key.
*/
} else if (arg instanceof RubyHash) {
RubyHash hash = (RubyHash)arg;
Schema hashSchema = new Schema();
for (Object o : hash.keySet()) {
Schema s = rubyArgToSchema(o);
if (s.size() != 1) {
throw new RuntimeException("Hash key must be singular");
}
Schema.FieldSchema fs = s.getField(0);
Object v = hash.get(o);
if (v instanceof RubyArray) {
byte type = fs.type;
if (type == DataType.BAG) {
fs.schema = rubyArgToSchema(v);
} else if (type == DataType.TUPLE || type == DataType.MAP) {
fs.schema = rubyArgToSchema(v).getField(0).schema;
} else {
throw new RuntimeException("Hash key must be tuple map or bag");
}
} else {
throw new RuntimeException("Hash value must be an Array");
}
hashSchema.add(fs);
}
return hashSchema;
} else {
throw new RuntimeException("Bad argument given to rubyToSchema: " + arg + (arg != null ? " class type " + arg.getClass().toString() : ""));
}
} catch (IOException e) {
throw new RuntimeException("Error converting ruby to Schema: " + arg, e);
}
}
/**
* This is a ruby method which takes a name and an array of arguments and constructs a Tuple schema
* from them.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg1 the name for the RubySchema
* @param arg2 a list of arguments to instantiate the new RubySchema
* @return the new Tuple RubySchema
*/
@JRubyMethod(meta = true, name = {"t", "tuple"})
public static RubySchema tuple(ThreadContext context, IRubyObject self, IRubyObject arg1, IRubyObject arg2) {
RubySchema rs = tuple(context, self, arg2);
rs.setNameIf(arg1);
return rs;
}
/**
* This is a ruby method which takes an array of arguments and constructs a Tuple schema from them. The name
* will be set automatically.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg a list of arguments to instantiate the new RubySchema
* @return the new RubySchema
*/
@JRubyMethod(meta = true, name = {"t", "tuple"})
public static RubySchema tuple(ThreadContext context, IRubyObject self, IRubyObject arg) {
if (arg instanceof RubyArray) {
Schema s = rubyArgToSchema(arg);
Ruby runtime = context.getRuntime();
return new RubySchema(runtime, runtime.getClass("Schema"), s);
} else {
throw new RuntimeException("Bad argument given to Schema.tuple");
}
}
/**
* This is a ruby method which takes a name and an array of arguments and constructs a Map schema
* from them.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg1 the name for the RubySchema
* @param arg2 a list of arguments to instantiate the new RubySchema
* @return the new RubySchema
*/
@JRubyMethod(meta = true, name = {"m", "map"})
public static RubySchema map(ThreadContext context, IRubyObject self, IRubyObject arg1, IRubyObject arg2) {
RubySchema rs = map(context, self, arg2);
rs.setNameIf(arg1);
return rs;
}
/**
* This is a ruby method which takes an array of arguments and constructs a Map schema from them. The name
* will be set automatically.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg a list of arguments to instantiate the new RubySchema
* @return the new RubySchema
*/
@JRubyMethod(meta = true, name = {"m", "map"})
public static RubySchema map(ThreadContext context, IRubyObject self, IRubyObject arg) {
Schema s = tuple(context, self, arg).getInternalSchema();
Ruby runtime = context.getRuntime();
try {
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(new Schema.FieldSchema("map_0", s.getField(0).schema, DataType.MAP)));
} catch (FrontendException e) {
throw new RuntimeException("Error making map", e);
}
}
/**
* This is a ruby method which takes a name and an array of arguments and constructs a Bag schema
* from them.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg1 the name for the RubySchema
* @param arg2 a list of arguments to instantiate the new RubySchema
* @return the new RubySchema
*/
@JRubyMethod(meta = true, name={"b", "bag"})
public static RubySchema bag(ThreadContext context, IRubyObject self, IRubyObject arg1, IRubyObject arg2) {
RubySchema rs = bag(context, self, arg2);
rs.setNameIf(arg1);
return rs;
}
/**
* This is a ruby method which takes an array of arguments and constructs a Bag schema from them. The name
* will be set automatically.
*
* @param context the context the method is being executed in
* @param self the RubyClass for the Class object this was invoked on
* @param arg a list of arguments to instantiate the new RubySchema
* @return the new RubySchema
*/
@JRubyMethod(meta = true, name = {"b", "bag"})
public static RubySchema bag(ThreadContext context, IRubyObject self, IRubyObject arg) {
Schema s = tuple(context, self, arg).getInternalSchema();
Ruby runtime = context.getRuntime();
try {
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(new Schema.FieldSchema("bag_0", s, DataType.BAG)));
} catch (FrontendException e) {
throw new RuntimeException("Error making map", e);
}
}
/**
* This method will fix any name conflicts in a schema. It's important to note that
* this will change the Schema object itself. It will deal with any collisions in things
* named tuple_#, bag_#, map_#, or val_#, as these are generally names generated by
* Util.getSchemaFromString. In the case of another name conflict, it will not be
* changed, as that name conflict was created by the user.
*
* @param s a Schema object to fix in place
*/
private static void fixSchemaNames(Schema s) {
if (s == null)
return;
// This regex detects names that could possibly collide that we should change
Pattern p = Pattern.compile("(bag_|tuple_|map_|val_)(\\d+)", Pattern.CASE_INSENSITIVE);
Set<String> names = new HashSet<String>(s.size(), 1.0f);
for (Schema.FieldSchema fs : s.getFields()) {
if (fs.alias == null)
continue;
Matcher m = p.matcher(fs.alias);
if (m.matches() && names.contains(fs.alias)) {
String prefix = m.group(1);
int suffix = Integer.parseInt(m.group(2));
while (names.contains(prefix + suffix))
suffix++;
fs.alias = prefix + suffix;
}
names.add(fs.alias);
if (fs.schema != null) {
if (fs.type == DataType.BAG) {
try {
fixSchemaNames(fs.schema.getField(0).schema);
} catch (FrontendException e) {
throw new RuntimeException("Error recursively fixing schema: " + s, e);
}
} else {
fixSchemaNames(fs.schema);
}
}
}
}
/**
* This is just a convenience method which sets the name of the internalSchema to the argument that was given.
*
* @param arg a RubyString to set the name of the encapsulated Schema object
*/
private void setNameIf(IRubyObject arg) {
if (arg instanceof RubyString) {
setName(arg.toString());
} else {
throw new RuntimeException("Bad name given");
}
}
/**
* This method sets the name of a RubySchema to the name given. It's important to note that
* if the RubySchema represents anything other than a tuple, databag, or map then an error
* will be thrown.
*
* @param name a String to set the name of the encapsulated Schema object
*/
private void setName(String name) {
Schema.FieldSchema fs;
try {
fs = internalSchema.getField(0);
} catch (FrontendException e) {
throw new RuntimeException("Error getting field from schema: " + internalSchema, e);
}
byte type = fs.type;
if (type == DataType.TUPLE || type == DataType.BAG || type == DataType.MAP) {
fs.alias = name;
} else {
throw new RuntimeException("setName cannot be set on Schema: " + internalSchema);
}
}
/**
* The toString method just leverages Schema's printing.
*
* @param context the context the method is being executed in
* @return a String representation of the encapsulated Schema object
*/
@JRubyMethod(name = {"to_s", "inspect"})
public RubyString toString(ThreadContext context) {
return RubyString.newString(context.getRuntime(), internalSchema.toString());
}
/**
* This is the ruby method which allows people to access elements of the RubySchema object.
* It can be given either a single numeric index, or a Range object to specify a range of indices.
* It's important to note that the Schema object returned from this references the Schema stored
* internally, so if the user wants to make changes without affecting this object, it must be cloned.
*
* @param context the context the method is being executed in
* @param arg a Fixnum index, Range object to specify a range of values to return, or
* a String to look up by alias name
* @return the RubySchema object encapsulated the found Schema
*/
@JRubyMethod(name = {"[]", "slice"})
public RubySchema get(ThreadContext context, IRubyObject arg) {
Ruby runtime = context.getRuntime();
if (arg instanceof RubyFixnum) {
int index = (int)((RubyFixnum)arg).getLongValue();
Schema s;
try {
s = new Schema(internalSchema.getField(index));
} catch (FrontendException e) {
throw new RuntimeException("Invalid index given to get function: " + index, e);
}
return new RubySchema(runtime, runtime.getClass("Schema"), s, false); //returns the actual object itself
} else if (arg instanceof RubyRange) {
int min = (int)((RubyFixnum)((RubyRange)arg).min(context, Block.NULL_BLOCK)).getLongValue();
int max = (int)((RubyFixnum)((RubyRange)arg).max(context, Block.NULL_BLOCK)).getLongValue();
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(internalSchema.getFields().subList(min, max + 1)), false);
} else if (arg instanceof RubyString) {
try {
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(internalSchema.getField(arg.toString())), false);
} catch (FrontendException e) {
throw new RuntimeException("Unable to find field " + arg.toString() + " in schema " + internalSchema, e);
}
} else {
throw new RuntimeException("Invalid argument given to get function: " + arg.toString());
}
}
/**
* This is a version of [] which allows the range to be specified as such: [1,2].
*
* @param context the context the method is being executed in
* @param arg1 a Fixnum start index
* @param arg2 a Fixnum end index
* @return the RubySchema object encapsulated the found Schema
*/
@JRubyMethod(name = {"[]", "slice"})
public RubySchema get(ThreadContext context, IRubyObject arg1, IRubyObject arg2) {
if (arg1 instanceof RubyFixnum && arg2 instanceof RubyFixnum) {
Ruby runtime = context.getRuntime();
int min = (int)((RubyFixnum)arg1).getLongValue();
int max = (int)((RubyFixnum)arg2).getLongValue() - 1;
return new RubySchema(runtime, runtime.getClass("Schema"), new Schema(internalSchema.getFields().subList(min, max + 1)), false);
} else {
throw new RuntimeException("Bad arguments given to get function: ( " + arg1.toString() + " , " + arg2.toString()+ " )");
}
}
/**
* This allows the users to set an index or a range of values to
* a specified RubySchema. The first argument must be a Fixnum or Range,
* and the second argument may optionally be a Fixnum. The given index
* (or range of indices) will be replaced by a RubySchema instantiated
* based on the remaining arguments.
*
* @param context the contextthe method is being executed in
* @param args a varargs which has to be at least length two.
* @return the RubySchema that was added
*/
@JRubyMethod(name = {"[]=", "set"}, required = 2, rest = true)
public RubySchema set(ThreadContext context, IRubyObject[] args) {
IRubyObject arg1 = args[0];
IRubyObject arg2 = args[1];
IRubyObject[] arg3 = Arrays.copyOfRange(args, 1, args.length);
Schema s = internalSchema;
Ruby runtime = context.getRuntime();
List<Schema.FieldSchema> lfs = s.getFields();
int min, max;
if (arg1 instanceof RubyFixnum && arg2 instanceof RubyFixnum) {
min = (int)((RubyFixnum)arg1).getLongValue();
max = (int)((RubyFixnum)arg2).getLongValue();
arg3 = Arrays.copyOfRange(args, 2, args.length);
} else if (arg1 instanceof RubyFixnum) {
min = (int)((RubyFixnum)arg1).getLongValue();
max = min + 1;
} else if (arg1 instanceof RubyRange) {
min = (int)((RubyFixnum)((RubyRange)arg1).min(context, Block.NULL_BLOCK)).getLongValue();
max = (int)((RubyFixnum)((RubyRange)arg1).max(context, Block.NULL_BLOCK)).getLongValue() + 1;
} else {
throw new RuntimeException("Bad arguments given to get function: ( " + arg1.toString() + " , " + arg2.toString()+ " )");
}
for (int i = min; i < max; i++)
lfs.remove(min);
if (arg3 == null || arg3.length == 0)
throw new RuntimeException("Must have schema argument for []=");
RubySchema rs = new RubySchema(runtime, runtime.getClass("Schema")).initialize(arg3);
for (Schema.FieldSchema fs : rs.getInternalSchema().getFields())
lfs.add(min++, fs);
RubySchema.fixSchemaNames(internalSchema);
return rs;
}
/**
* This method provides addition semantics, without modifying the original Schema.
* This method can be given any number of arguments, much as with the constructor.
*
* @param context the context the method is being executed in
* @param args a varargs which can be any valid set of arguments that
* can initialize a RubySchema
* @return the Rresult of the addition
*/
@JRubyMethod(name = {"add", "+"}, rest = true)
public RubySchema add(ThreadContext context, IRubyObject[] args) {
RubySchema rsClone = clone(context);
rsClone.addInPlace(context, args);
return rsClone;
}
/**
* This method provides addition semantics, modifying the original Schema in place.
* This method can be given any number of arguments, much as with the constructor.
*
* @param context the context the method is being executed in
* @param args a varargs which can be any valid set of arguments that
* can initialize a RubySchema
*/
@JRubyMethod(name = "add!", rest = true)
public void addInPlace(ThreadContext context, IRubyObject[] args) {
Ruby runtime = context.getRuntime();
List<Schema.FieldSchema> lfs = internalSchema.getFields();
RubySchema rs = new RubySchema(runtime, runtime.getClass("Schema")).initialize(args);
for (Schema.FieldSchema fs : rs.getInternalSchema().getFields())
lfs.add(fs);
RubySchema.fixSchemaNames(internalSchema);
}
/**
* @param context the context the method is being executed in
* @return a RubySchema copy of the Schema
*/
@JRubyMethod
public RubySchema clone(ThreadContext context) {
Ruby runtime = context.getRuntime();
return new RubySchema(runtime, runtime.getClass("Schema"), internalSchema);
}
/**
* Given a field name this string will search the RubySchema for a FieldSchema
* with that name and return it encapsulated in a Schema.
*
* @param context the context the method is being executed in
* @param arg a RubyString serving as an alias to look
* for in the Schema
* @return the found RubySchema
*/
@JRubyMethod
public RubySchema find(ThreadContext context, IRubyObject arg) {
if (arg instanceof RubyString) {
Ruby runtime = context.getRuntime();
return new RubySchema(runtime, runtime.getClass("Schema"), RubySchema.find(internalSchema, arg.toString()), false);
} else {
throw new RuntimeException("Invalid arguement passed to find: " + arg);
}
}
/**
* This is a helper method which recursively searches for an alias in the Schema
* encapsulated by RubySchema. This is necessary because findFieldSchema uses
* canonicalName, not name.
*
* @param s the Schema to search through
* @param alias
* @return the found RubySchema
*/
private static Schema find(Schema s, String alias) {
for (Schema.FieldSchema fs : s.getFields())
if (alias.equals(fs.alias))
return new Schema(fs);
for (Schema.FieldSchema fs : s.getFields())
if (fs.schema != null) {
Schema r = RubySchema.find(fs.schema, alias);
if (r != null)
return r;
}
return new Schema();
}
/**
* Given a field name, this will return the index of it in the schema.
*
* @param context the context the method is being executed in
* @param arg a field name to look for
* @return the index for that field name
*/
@JRubyMethod
public RubyFixnum index(ThreadContext context, IRubyObject arg) {
if (arg instanceof RubyString) {
try {
return new RubyFixnum(context.getRuntime(), internalSchema.getPosition(arg.toString()));
} catch (FrontendException e) {
throw new RuntimeException("Unable to find position for argument: " + arg);
}
} else {
throw new RuntimeException("Invalid arguement passed to index: " + arg);
}
}
/**
* @param context the context the method is being executed in
* @return the size of the encapsulated Schema
*/
@JRubyMethod(name = {"size", "length"})
public RubyFixnum size(ThreadContext context) {
return new RubyFixnum(context.getRuntime(), internalSchema.size());
}
/**
* This is a helper method to pull out the native Java type from the ruby object.
*
* @return the encapsulated Schema
*/
public Schema getInternalSchema() {
return internalSchema;
}
/**
* This method allows access into the Schema nested in the encapsulated Schema. For example,
* if the encapsulated Schema is a bag Schema, this allows the user to access the schema of
* the interior Tuple.
*
* @param context the context the method is being executed in
* @return a RubySchema encapsulating the nested Schema
*/
@JRubyMethod(name = {"get", "inner", "in"})
public RubySchema get(ThreadContext context) {
if (internalSchema.size() != 1)
throw new RuntimeException("Can only return nested schema if there is one schema to get");
Ruby runtime = context.getRuntime();
try {
return new RubySchema(runtime, runtime.getClass("Schema"), internalSchema.getField(0).schema, false);
} catch (FrontendException e) {
throw new RuntimeException("Schema does not have a nested FieldScema", e);
}
}
/**
* This method allows the user to see the name of the alias of the FieldSchema of the encapsulated
* Schema. This method only works if the Schema has one FieldSchema.
*
* @param context the context the method is being executed in
* @return the name of the Schema
*/
@JRubyMethod(name = "name")
public RubyString getName(ThreadContext context) {
try {
if (internalSchema.size() != 1)
throw new RuntimeException("Can only get name if there is one schema present");
return RubyString.newString(context.getRuntime(), internalSchema.getField(0).alias);
} catch (FrontendException e) {
throw new RuntimeException("Unable to get field from Schema", e);
}
}
/**
* This method allows the user to set the name of the alias of the FieldSchema of the encapsulated
* Schema. This method only works if the Schema has one FieldSchema.
*
* @param arg a RubyString to set the name to
* @return the new name
*/
@JRubyMethod(name = "name=")
public RubyString setName(IRubyObject arg) {
if (arg instanceof RubyString) {
if (internalSchema.size() != 1)
throw new RuntimeException("Can only set name if there is one schema present");
try {
internalSchema.getField(0).alias = arg.toString();
return (RubyString)arg;
} catch (FrontendException e) {
throw new RuntimeException("Unable to get field from Schema", e);
}
} else {
throw new RuntimeException("Improper argument passed to 'name=':" + arg);
}
}
}