public override DataTable Project(ExpressionEval[] exprs)
{
var heading = DataHeading.Create(exprs);
var sql = _gen.SelectAs(GetFrom(), exprs);
var newtable = DataTableSql.CreateFromSql(heading, sql);
Logger.WriteLine(4, "[Pro '{0}']", newtable);
return(newtable);
}
public override DataTable Rename(ExpressionEval[] exprs)
{
// note: heading order must match exprs (cf Local)
var heading = DataHeading.Create(exprs);
var sql = _gen.SelectAs(GetFrom(), exprs);
var newtable = DataTableSql.CreateFromSql(heading, sql);
Logger.WriteLine(4, "[Ren '{0}']", newtable);
return(newtable);
}
// Create a codeless expression block for renames and projects
// Create a lookup so later code can easily track total set of inputs
public static ExpressionBlock Create(string name, string oldname, DataType rtntype)
{
return(new ExpressionBlock {
Kind = (name == oldname) ? ExpressionKinds.Project : ExpressionKinds.Rename,
Name = name,
ReturnType = rtntype,
OldName = oldname,
InternalLookup = DataHeading.Create(new DataColumn[] { DataColumn.Create(oldname, rtntype) }),
});
}
public static AddinInfo[] GetAddinInfo()
{
var addins = new List <AddinInfo>();
addins.Add(AddinInfo.Create("read", 1, DataTypes.Text, "Read"));
addins.Add(AddinInfo.Create("write", 1, DataTypes.Void, "Write"));
addins.Add(AddinInfo.Create("pause", 1, DataTypes.Void, "Pause"));
addins.Add(AddinInfo.Create("fail", 2, DataTypes.Void, "Fail"));
addins.Add(AddinInfo.Create("assert", 2, DataTypes.Void, "Assert"));
addins.Add(AddinInfo.Create("type", 1, DataTypes.Text, "Type"));
addins.Add(AddinInfo.Create("binary", 1, DataTypes.Binary, "Binary"));
addins.Add(AddinInfo.Create("bool", 1, DataTypes.Bool, "Bool"));
addins.Add(AddinInfo.Create("number", 1, DataTypes.Number, "Number,NumberT"));
addins.Add(AddinInfo.Create("time", 1, DataTypes.Time, "Time,TimeD")); //FIX:
addins.Add(AddinInfo.Create("text", 1, DataTypes.Text, "Text"));
addins.Add(AddinInfo.Create("format", 1, DataTypes.Text, "Format"));
addins.Add(AddinInfo.Create("pp", 1, DataTypes.Text, "PrettyPrint"));
addins.Add(AddinInfo.Create("length", 1, DataTypes.Number, "Length"));
addins.Add(AddinInfo.Create("fill", 2, DataTypes.Text, "Fill"));
addins.Add(AddinInfo.Create("trim", 1, DataTypes.Text, "Trim"));
addins.Add(AddinInfo.Create("left", 2, DataTypes.Text, "Left"));
addins.Add(AddinInfo.Create("right", 2, DataTypes.Text, "Right"));
addins.Add(AddinInfo.Create("before", 2, DataTypes.Text, "Before"));
addins.Add(AddinInfo.Create("after", 2, DataTypes.Text, "After"));
addins.Add(AddinInfo.Create("toupper", 1, DataTypes.Text, "ToUpper"));
addins.Add(AddinInfo.Create("tolower", 1, DataTypes.Text, "ToLower"));
addins.Add(AddinInfo.Create("bget", 1, DataTypes.Number, "BinaryGet"));
addins.Add(AddinInfo.Create("bset", 1, DataTypes.Binary, "BinarySet"));
addins.Add(AddinInfo.Create("blength", 1, DataTypes.Binary, "BinaryLength"));
addins.Add(AddinInfo.Create("now", 0, DataTypes.Time, "Now"));
addins.Add(AddinInfo.Create("date", 1, Builtin.DateValue.StaticDatatype, "FromTime"));
addins.Add(AddinInfo.Create("dateymd", 3, Builtin.DateValue.StaticDatatype, "FromYmd"));
addins.Add(AddinInfo.Create("year", 1, DataTypes.Number, "Year"));
addins.Add(AddinInfo.Create("month", 1, DataTypes.Number, "Month"));
addins.Add(AddinInfo.Create("day", 1, DataTypes.Number, "Day"));
addins.Add(AddinInfo.Create("dow", 1, DataTypes.Number, "DayOfWeek"));
addins.Add(AddinInfo.Create("daysdiff", 2, DataTypes.Number, "DaysDifference"));
//addins.Add(AddinInfo.Create("time", 1, DataTypes.Time, "TimeD"));
addins.Add(AddinInfo.Create("count", 1, DataTypes.Number, "Count"));
addins.Add(AddinInfo.Create("degree", 1, DataTypes.Number, "Degree"));
addins.Add(AddinInfo.Create("schema", 1, DataTypeRelation.Get(DataHeading.Create("Name:text", "Type:text")), "Schema"));
addins.Add(AddinInfo.Create("seq", 1, DataTypeRelation.Get(DataHeading.Create("N:number")), "Sequence"));
addins.Add(AddinInfo.Create("andl_variable", 0, DataTypeRelation.Get(Catalog.CatalogTableHeading(Catalog.CatalogTables.Variable)), "Variables"));
addins.Add(AddinInfo.Create("andl_operator", 0, DataTypeRelation.Get(Catalog.CatalogTableHeading(Catalog.CatalogTables.Operator)), "Operators"));
addins.Add(AddinInfo.Create("andl_member", 0, DataTypeRelation.Get(Catalog.CatalogTableHeading(Catalog.CatalogTables.Member)), "Members"));
return(addins.ToArray());
}
// Create and return new type
// Note: heading must have IsTuple=false to preserve order
public static DataTypeCode Get(DataType type, DataColumn[] columns)
{
var dt = new DataTypeCode {
Returns = type,
Arguments = (columns == null) ? DataHeading.Empty : DataHeading.Create(columns, false),
Flags = TypeFlags.Variable,
};
//dt.NativeType = TypeMaker.CreateType(dt); // TODO:
return(dt);
}
// relation representing heading
public RelationValue Schema(RelationValue relarg)
{
var heading = DataHeading.Create("Name:text", "Type:text");
var table = DataTableLocal.Create(heading);
foreach (var col in relarg.Value.Heading.Columns)
{
table.AddRow(DataRow.Create(heading, col.Name, col.DataType.Name));
}
return(RelationValue.Create(table));
}
DataHeading Peek()
{
var schema = GetSchema();
var scols = schema.Columns;
var cols = Enumerable.Range(0, scols.Count)
.Select(x => DataColumn.Create(scols[x].ColumnName,
_type2datatype.ContainsKey(scols[x].DataType) ? _type2datatype[scols[x].DataType] : DataTypes.Text))
.ToArray();
return(DataHeading.Create(cols));
}
// Transform tuple
public TupleValue TransTuple(TupleValue tuparg, params CodeValue[] exprargs)
{
Logger.WriteLine(3, "TransTuple {0} {1}", tuparg, exprargs.Select(e => e.AsEval.Kind.ToString()).ToArray());
var tup = tuparg.Value;
var exprs = exprargs.Select(e => (e as CodeValue).AsEval).ToArray();
var heading = DataHeading.Create(exprs);
var tupnew = tup.Transform(heading, exprs);
Logger.WriteLine(3, "[TrT {0}]", tupnew);
return(TupleValue.Create(tupnew));
}
// Transform plus aggregation
public RelationValue TransAgg(RelationValue relarg, params CodeValue[] exprargs)
{
Logger.WriteLine(3, "TransAgg {0} {1}", relarg, exprargs.Select(e => e.AsEval.Kind.ToString()).ToArray());
var rel = relarg.Value;
var exprs = exprargs.Select(e => e.AsEval).ToArray();
var heading = DataHeading.Create(exprs);
var relnew = rel.TransformAggregate(heading, exprs);
Logger.WriteLine(3, "[TrA {0}]", relnew);
return(RelationValue.Create(relnew));
}
public string CreateTable(string tablename, DataTable other)
{
var heading = (other.Heading.Degree == 0) ? DataHeading.Create("_dummy") : other.Heading;
var dict = new Dictionary <string, SubstituteDelegate> {
{ "table", (x) => tablename },
{ "coldefs", (x) => ColDefs(heading.Columns) },
{ "colnames", (x) => NameList(heading) },
};
return(_templater.Process("Create", dict));
}
public string GroupBy(DataColumn[] cols)
{
if (cols.Length == 0)
{
return("");
}
var dict = new Dictionary <string, SubstituteDelegate> {
{ "grpcols", (x) => NameList(DataHeading.Create(cols)) },
};
return(_templater.Process("GroupBy", dict));
}
// Transform plus window functions (which depend on ordering)
public RelationValue TransWin(RelationValue relarg, params CodeValue[] exprargs)
{
Logger.WriteLine(3, "TransOrd {0} {1}", relarg, exprargs.Select(e => e.AsEval.Kind.ToString()).ToArray());
var rel = relarg.Value;
var exprs = exprargs.Select(e => (e as CodeValue).AsEval).ToArray();
var tranexprs = exprs.Where(e => !e.IsOrder).ToArray();
var orderexps = exprs.Where(e => e.IsOrder).ToArray();
var heading = DataHeading.Create(tranexprs);
var relnew = rel.TransformWindowed(heading, tranexprs, orderexps);
Logger.WriteLine(3, "[TrO {0}]", relnew);
return(RelationValue.Create(relnew));
}
// Transform does Rename and/or Project and/or Extend combo
public RelationValue Transform(RelationValue relarg, params CodeValue[] exprargs)
{
Logger.WriteLine(3, "Transform {0} {1}", relarg, exprargs.Select(e => e.AsEval.Kind.ToString()).ToArray());
var rel = relarg.Value;
var exprs = exprargs.Select(e => (e as CodeValue).AsEval).ToArray();
Logger.Assert(!exprs.Any(e => e.HasFold), "transform folded");
var heading = DataHeading.Create(exprs);
var relnew = rel.Transform(heading, exprs);
Logger.WriteLine(3, "[Tr {0}]", relnew);
return(RelationValue.Create(relnew));
}
// Project onto named columns
public override DataTable Project(ExpressionEval[] exprs)
{
var newheading = DataHeading.Create(exprs);
var newtable = DataTableLocal.Create(newheading);
var newexprs = newtable.Heading.Reorder(exprs);
foreach (var row in GetRows()) //TODO:Enumerable
{
newtable.AddRow(row.Transform(newheading, newexprs));
}
Logger.WriteLine(4, "[Project={0}]", newtable);
return(newtable);
}
// 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));
}
// read a heading
public DataHeading ReadHeading()
{
var istuple = _reader.ReadBoolean();
var degree = _reader.ReadInt32();
Logger.Assert(degree >= 0 && degree < Persist.MaxDegree, degree);
var cols = new List <DataColumn>();
while (degree-- > 0)
{
cols.Add(ReadColumn());
}
return(DataHeading.Create(cols.ToArray(), istuple));
}
// Create and add, return new type (must not exist)
// Note: heading must have IsTuple=false to preserve order
public static DataTypeUser Get(string name, DataColumn[] columns)
{
var old = Find(name);
if (old != null && columns.SequenceEqual(old.Heading.Columns))
{
return(old);
}
Logger.Assert(!_usertypes.ContainsKey(name), name);
var flags = columns.Any(c => c.DataType.IsOrdered) ? TypeFlags.Ordered : TypeFlags.None;
var dt = DataTypeUser.Create(name, DataHeading.Create(columns, false), // preserve column order
flags | TypeFlags.Variable | TypeFlags.Generated | TypeFlags.HasName | TypeFlags.HasHeading);
_usertypes[name] = dt;
return(dt);
}
static IEnumerable <DataRow> GetRows(object instance, DataColumn[] columns)
{
var type = instance.GetType();
var countpi = type.GetProperty("Count");
var itempi = type.GetProperty("Item");
var count = (int)countpi.GetValue(instance, null);
var rows = new List <DataRow>();
var heading = DataHeading.Create(columns, false); // preserve column order
for (var x = 0; x < count; ++x)
{
var row = itempi.GetValue(instance, new object[] { x });
var values = GetValues(row, columns);
rows.Add(DataRow.Create(heading, values));
}
return(rows);
}
// Generic input
public override DataHeading Peek(string table)
{
Logger.WriteLine(2, "Sql Peek '{0}'", table);
if (table == "*")
{
return(Peek());
}
var reader = Open(table);
var s = Enumerable.Range(0, reader.FieldCount)
.Select(n => reader.GetName(n) + ":" + reader.GetDataTypeName(n)).ToArray();
Logger.WriteLine(3, "Table {0} fields {1}", table, String.Join(",", s));
var cols = Enumerable.Range(0, reader.FieldCount)
.Where(x => _convdict.ContainsKey(reader.GetDataTypeName(x)))
.Select(x => DataColumn.Create(reader.GetName(x), GetType(_convdict[reader.GetDataTypeName(x)])))
.ToArray();
Close();
return(DataHeading.Create(cols, false)); // preserve order
}
public override DataHeading Peek(string file)
{
var path = GetPath(file);
if (!File.Exists(path))
{
return(null);
}
using (var rdr = new TextFieldParser(path)
{
TextFieldType = FieldType.Delimited,
Delimiters = new string[] { "," },
}) {
var row = rdr.ReadFields();
if (_hasid)
{
row = (new string[] { "Id:number" })
.Concat(row).ToArray();
}
return(DataHeading.Create(row));
}
}
///-------------------------------------------------------------------
///
/// Catalog info
///
// Construct and return a heading for a database table
// return null if not found or error
// TODO:
public DataHeading GetTableHeading(string table)
{
Tuple <string, SqlCommonType>[] columns;
// optional sql
var sql = SqlGen.GetColumns(table);
var optsql = sql.Length > 0;
Logger.WriteLine(3, "GetTableHeading {0}", optsql ? sql : table);
if (optsql)
{
Logger.WriteLine(2, ">>>(th){0}", sql);
}
Logger.Assert(_database != null, "gth");
var ok = _database.GetTableColumns(optsql ? sql : table, out columns);
if (!ok || columns.Length == 0)
{
return(null);
}
var cols = columns.Select(c => DataColumn.Create(c.Item1, FromSqlCommon[c.Item2]));
return(DataHeading.Create(cols)); // ignore column order
}
static DataHeading()
{
Empty = DataHeading.Create(new DataColumn[0], false); // avoids assert later
}
public override DataHeading Peek(string file)
{
return(DataHeading.Create("line"));
}