private static void Comparer_VerifyWhereAll <T>(T[] left, T[] right, T value) where T : IComparable <T> { // Try operations between array and single value Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.Equal); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.NotEqual); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.GreaterThan); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.GreaterThanOrEqual); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.LessThan); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.Single(new T[1] { value }, left.Length), CompareOperator.LessThanOrEqual); // Try operations between two arrays Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.Equal); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.NotEqual); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.GreaterThan); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.GreaterThanOrEqual); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.LessThan); Comparer_VerifyWhere <T>(XArray.All(left, left.Length), XArray.All(right, right.Length), CompareOperator.LessThanOrEqual); }
private XArray Get(int count) { if (IsNull) { return(XArray.Null(_array, count)); } return(XArray.Single(_array, count)); }
// Return an IsSingleElement array with just the first value of the xarray, but the same count public static XArray First(XArray values) { Array modifiedArray = null; Allocator.AllocateToSize(ref modifiedArray, 1, values.Array.GetType().GetElementType()); modifiedArray.SetValue(values.Array.GetValue(values.Index(0)), 0); return(XArray.Single(modifiedArray, values.Count)); }
public ConstantColumn(IXTable source, object value, Type type, bool wasUnwrappedLiteral = false) { Source = source; Allocator.AllocateToSize(ref _array, 1, type); _array.SetValue(value, 0); IsNull = (value == null || value.Equals("null")); _xArray = (IsNull ? XArray.Null(_array, 1) : XArray.Single(_array, 1)); WasUnwrappedLiteral = wasUnwrappedLiteral; ColumnDetails = new ColumnDetails(string.Empty, type); }
public static bool TryConvertSingle(object value, Type targetType, out object result) { // Nulls are always converted to null if (value == null) { result = null; return(true); } // If the type is already right, just return it Type sourceType = value.GetType(); if (sourceType.Equals(targetType)) { result = value; return(true); } // Get the converter for the desired type combination Func <XArray, XArray> converter = GetConverter(sourceType, targetType); Array array = null; Allocator.AllocateToSize(ref array, 1, sourceType); array.SetValue(value, 0); XArray resultxarray = converter(XArray.Single(array, 1)); // Verify the result was not null unless the input was "" or 'null' if (resultxarray.HasNulls && resultxarray.NullRows[resultxarray.Index(0)]) { result = null; string stringValue = value.ToString(); if (stringValue != "" || String.Compare(stringValue, "null", true) == 0) { return(true); } return(false); } result = resultxarray.Array.GetValue(resultxarray.Index(0)); return(true); }
private XArray Convert(XArray xarray) { // If a single value was returned, only convert it if (xarray.Selector.IsSingleValue) { Allocator.AllocateToSize(ref _buffer, 1); _buffer[0] = _function(((T[])xarray.Array)[0]); return(XArray.Single(_buffer, xarray.Count)); } // Allocate for results Allocator.AllocateToSize(ref _buffer, xarray.Count); // Convert each non-null value T[] array = (T[])xarray.Array; for (int i = 0; i < xarray.Count; ++i) { int index = xarray.Index(i); bool rowIsNull = (xarray.HasNulls && xarray.NullRows[index]); _buffer[i] = (rowIsNull ? default(U) : _function(array[index])); } return(XArray.All(_buffer, xarray.Count, XArray.RemapNulls(xarray, ref _isNull))); }
private XArray Get() { return(_isNull ? XArray.Null(_array, _source.CurrentRowCount) : XArray.Single(_array, _source.CurrentRowCount)); }
public XArray Add(XArray left, XArray right) { long[] leftArray = (long[])left.Array; long[] rightArray = (long[])right.Array; int count = left.Count; if (right.Count != count) { throw new InvalidOperationException("Computations must get the same number of rows from each argument."); } bool areAnyNull = false; // Allocate for results Allocator.AllocateToSize(ref _buffer, count); Allocator.AllocateToSize(ref _isNull, count); // Check how the XArrays are configured and run the fastest loop possible for the configuration. if (left.HasNulls || right.HasNulls) { for (int i = 0; i < count; ++i) { int index1 = left.Index(i); int index2 = right.Index(i); bool rowIsNull = (left.HasNulls && left.NullRows[index1]) || (right.HasNulls && right.NullRows[index2]); areAnyNull |= rowIsNull; _isNull[i] = rowIsNull; _buffer[i] = leftArray[index1] + rightArray[index2]; } } else if (left.Selector.Indices != null || right.Selector.Indices != null) { for (int i = 0; i < left.Count; ++i) { _buffer[i] = leftArray[left.Index(i)] + rightArray[right.Index(i)]; } } else if (!right.Selector.IsSingleValue && !left.Selector.IsSingleValue) { int leftStart = left.Selector.StartIndexInclusive; int rightStart = right.Selector.StartIndexInclusive; for (int i = 0; i < count; ++i) { _buffer[i] = leftArray[i + leftStart] + rightArray[i + rightStart]; } } else if (!left.Selector.IsSingleValue) { int leftStart = left.Selector.StartIndexInclusive; long rightValue = rightArray[right.Selector.StartIndexInclusive]; for (int i = 0; i < count; ++i) { _buffer[i] = leftArray[i + leftStart] + rightValue; } } else if (!right.Selector.IsSingleValue) { long leftValue = leftArray[left.Selector.StartIndexInclusive]; int rightStart = right.Selector.StartIndexInclusive; for (int i = 0; i < count; ++i) { _buffer[i] = leftValue + rightArray[i + rightStart]; } } else { _buffer[0] = leftArray[left.Selector.StartIndexInclusive] + rightArray[right.Selector.StartIndexInclusive]; return(XArray.Single(_buffer, count)); } return(XArray.All(_buffer, count, (areAnyNull ? _isNull : null))); }