Class Extensions


public abstract class Extensions extends Object
Contains what, in LINQ.NET, would be extension methods.

Notes on mapping from LINQ.NET to Java

We have preserved most of the API. But we've changed a few things, so that the API is more typical Java API:

  • Java method names start with a lower-case letter.
  • A few methods became keywords when their first letter was converted to lower case; hence Expressions.break_(org.apache.calcite.linq4j.tree.LabelTarget)
  • We created a Java interface Enumerable, similar to LINQ.NET's IEnumerable. IEnumerable is built into C#, and that gives it advantages: the standard collections implement it, and you can use any IEnumerable in a foreach loop. We made the Java Enumerable extend Iterable, so that it can be used in for-each loops. But the standard collections still don't implement it. A few methods that take an IEnumerable in LINQ.NET take an Iterable in LINQ4J.
  • LINQ.NET's Dictionary interface maps to Map in Java; hence, the LINQ.NET ToDictionary methods become toMap.
  • LINQ.NET's decimal type changes to BigDecimal. (A little bit unnatural, since decimal is primitive and BigDecimal is not.)
  • There is no Nullable in Java. Therefore we distinguish between methods that return, say, Long (which may be null) and long. See for example NullableLongFunction1 and LongFunction1, and the variants of ExtendedEnumerable.sum(org.apache.calcite.linq4j.function.BigDecimalFunction1<TSource>) that call them.
  • Java erases type parameters from argument types before resolving overloading. Therefore similar methods have the same erasure. Methods averageDouble, averageInteger, groupByK, selectN, selectManyN, skipWhileN, sumBigDecimal, sumNullableBigDecimal, whereN have been renamed from average, groupBy, max, min, select, selectMany, skipWhile and where to prevent ambiguity.
  • .NET allows extension methods — static methods that then become, via compiler magic, a method of any object whose type is the same as the first parameter of the extension method. In LINQ.NET, the IQueryable and IEnumerable interfaces have many such methods. In Java, those methods need to be explicitly added to the interface, and will need to be implemented by every class that implements that interface. We can help by implementing the methods as static methods, and by providing an abstract base class that implements the extension methods in the interface. Hence AbstractEnumerable and AbstractQueryable call methods in Extensions.
  • .NET Func becomes Function0, Function1, Function2, depending on the number of arguments to the function, because Java types cannot be overloaded based on the number of type parameters.
  • Types map as follows: Int32int or Integer, Int64long or Long, boolboolean or Boolean, DictionaryMap, LookupMap whose value type is an Iterable,
  • Function types that accept primitive types in LINQ.NET have become boxed types in LINQ4J. For example, a predicate function Func<T, bool> becomes Func1<T, Boolean>. It would be wrong to infer that the function is allowed to return null.