public NumberValue BinaryGet(BinaryValue value, NumberValue index)
{
if (index.Value < 0 || index.Value > value.Value.Length)
{
throw ProgramError.Fatal("Binary", "get index out of range");
}
return(NumberValue.Create(value.Value[(int)index.Value]));
}
// Parse string as number
public NumberValue Number(TextValue value)
{
decimal d;
if (Decimal.TryParse(value.Value, out d))
{
return(NumberValue.Create(d));
}
throw ProgramError.Fatal("Convert", "not a valid number");
}
// Return rank of attribute with tuple indexing
public TypedValue Rank(CodeValue attribute, NumberValue index, PointerValue lookup)
{
var row = lookup.Value as DataRow;
Logger.Assert(row != null, "lookup is not row");
var value = attribute.AsEval.EvalOpen(row);
var offset = row.Heading.FindIndex(attribute.AsEval.Name);
return(NumberValue.Create(index.Value + 1));
}
// sequence of integers
public RelationValue Sequence(NumberValue countarg)
{
var heading = DataHeading.Create("N:number");
var table = DataTableLocal.Create(heading);
var n = Decimal.Zero;
var count = (int)countarg.Value;
for (var i = 0; i < count; ++i)
{
table.AddRow(DataRow.Create(heading, new TypedValue[] { NumberValue.Create(n) }));
n += 1;
}
return(RelationValue.Create(table));
}
// Converter driven by source type
TypedValue Converter(ConversionTypes type, object value)
{
switch (type)
{
case ConversionTypes.Bool: return(BoolValue.Create((bool)value));
case ConversionTypes.Int: return(NumberValue.Create((int)value));
case ConversionTypes.String: return(TextValue.Create((string)value));
case ConversionTypes.Decimal: return(NumberValue.Create((decimal)value));
case ConversionTypes.DateTime: return(TimeValue.Create((DateTime)value));
default: return(TypedValue.Empty);
}
}
public static TypedValue Parse(DataType type, string value)
{
if (type == DataTypes.Bool)
{
return(BoolValue.Create(bool.Parse(value)));
}
if (type == DataTypes.Number)
{
return(NumberValue.Create(Decimal.Parse(value)));
}
if (type == DataTypes.Time)
{
return(TimeValue.Create(DateTime.Parse(value)));
}
if (type == DataTypes.Text)
{
return(TextValue.Create(value));
}
return(TypedValue.Empty);
}
void AddMember(string parent, DataHeading heading)
{
int index = 0;
foreach (var column in heading.Columns)
{
var addrow = DataRow.Create(Table.Heading, new TypedValue[]
{ TextValue.Create(parent),
NumberValue.Create(++index),
TextValue.Create(column.Name),
TextValue.Create(column.DataType.BaseType.Name),
TextValue.Create(column.DataType.GetUniqueName ?? "") });
Table.AddRow(addrow);
// Recursive call. note: may be duplicate, but no matter.
if (column.DataType.GetUniqueName != null)
{
AddMember(column.DataType.GetUniqueName, column.DataType.Heading);
}
}
}
// Bitwise overloads
public NumberValue BitAnd(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create((Int64)arg1.Value & (Int64)arg2.Value));
}
// Return ordinal value for row, optionally within group
public NumberValue Ordinal(bool isgroup)
{
var ret = isgroup ? OrderedIndex.Offset(this, 0, OffsetModes.Absolute) : Order;
return(NumberValue.Create(ret));
}
public NumberValue Mod(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(Decimal.Remainder(Decimal.Truncate(arg1.Value), Decimal.Truncate(arg2.Value))));
}
// Return cardinality as scalar
public NumberValue Count(RelationValue arg)
{
return(NumberValue.Create(arg.Value.GetCount()));
}
public NumberValue Subtract(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(arg1.Value - arg2.Value));
}
public NumberValue Divide(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(arg1.Value / arg2.Value));
}
///=================================================================
///
/// Arithmetic operations
///
public NumberValue Neg(NumberValue arg1)
{
return(NumberValue.Create(-arg1.Value));
}
public NumberValue BitXor(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create((Int64)arg1.Value ^ (Int64)arg2.Value));
}
public NumberValue BinaryLength(BinaryValue arg1)
{
return(NumberValue.Create(arg1.Value.Length));
}
// Convert time value to seconds
public NumberValue NumberT(TimeValue value)
{
return(NumberValue.Create(value.Value.Ticks / 10000000.0m));
}
public void SetNumber(int colno, decimal value)
{
_valueholder._values[colno] = NumberValue.Create(value);
}
public NumberValue BitNot(NumberValue arg1)
{
return(NumberValue.Create(~(Int64)arg1.Value));
}
public NumberValue Length(TextValue arg1)
{
return(NumberValue.Create(arg1.Value.Length));
}
public NumberValue Add(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(arg1.Value + arg2.Value));
}
public NumberValue Year(DateValue arg1)
{
return(NumberValue.Create(arg1.Value.Year));
}
public NumberValue Multiply(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(arg1.Value * arg2.Value));
}
public NumberValue Month(DateValue arg1)
{
return(NumberValue.Create(arg1.Value.Month));
}
public NumberValue Div(NumberValue arg1, NumberValue arg2)
{
return(NumberValue.Create(Decimal.Truncate(Decimal.Divide(Decimal.Truncate(arg1.Value), Decimal.Truncate(arg2.Value)))));
}
public NumberValue Day(DateValue arg1)
{
return(NumberValue.Create(arg1.Value.Day));
}
public NumberValue Pow(NumberValue arg1, NumberValue arg2)
{
var v = Math.Pow((double)arg1.Value, (double)arg2.Value);
return(NumberValue.Create((decimal)v));
}
public NumberValue DayOfWeek(DateValue arg1)
{
return(NumberValue.Create((int)arg1.Value.DayOfWeek));
}
// Return degree as scalar
public NumberValue Degree(RelationValue arg)
{
return(NumberValue.Create(arg.Value.Degree));
}
public NumberValue DaysDifference(DateValue arg1, DateValue arg2)
{
return(NumberValue.Create((int)arg1.Value.Subtract(arg2.Value).TotalDays));
}
