// generate SQL code for dyadic antijoin operations
DataTableSql DyadicAntijoin(DataTableSql other, DataHeading joinhdg, DataHeading newheading)
{
var sql = _gen.SelectAntijoin(GetFrom(), other.GetFrom(), newheading, joinhdg);
var newtable = CreateFromSql(newheading, sql);
return(newtable);
}
// generate SQL code for dyadic set operations
DataTableSql DyadicSet(DataTableSql other, DataHeading newheading, JoinOps joinop)
{
var sql = _gen.SelectSet(GetFrom(), other.GetFrom(), newheading, joinop);
var newtable = DataTableSql.CreateFromSql(newheading, sql);
return(newtable);
}
// Get a catalog value by entry from database or catalog
public TypedValue GetValue(CatalogEntry entry)
{
if (entry.IsDatabase)
{
if (_catalog.SqlFlag)
{
// Database sql comes from external table
var table = DataTableSql.Create(entry.Name, entry.DataType.Heading);
return(RelationValue.Create(table));
}
else if (!entry.IsLoaded) // lazy load
// Database non-sql lazy loaded from store on path, then in catalog
{
var value = Persist.Create(_catalog.DatabasePath, true).Load(entry.Name);
if (entry.DataType != value.DataType)
{
throw ProgramError.Fatal("Catalog", "Type mismatch for variable {0}", entry.Name);
}
entry.IsLoaded = true;
return(Persist.Create(_catalog.DatabasePath, true).Load(entry.Name));
}
}
// Non-database exists only in the catalog
return(entry.Value);
}
// Generate SQL for COUNT
DataTableSql GenCount()
{
var sql = _gen.SelectCount(GetFrom());
var newtable = DataTableSql.CreateFromSql(DataHeading.Empty, sql);
return(newtable);
}
// Sql to delete multiple rows of data from named table
void DeleteValuesQuery(DataTableSql other)
{
_database.OpenStatement();
// SQL does positional matching, so column order must come from other
var sql = _gen.DeleteNamed(TableName, other.Heading, other.GetQuery()); //WRONG?
_database.ExecuteCommand(sql);
_database.CloseStatement();
}
// Create new table with previous as a subquery (ran out of slots)
static DataTableSql CreateFromSubquery(DataTableSql table)
{
var newtable = new DataTableSql {
DataType = DataTypeRelation.Get(table.Heading),
SqlSelectText = table._gen.SelectAll(table.GetFrom(), table),
};
return(newtable);
}
// Create new table from a partial query, allow more clauses to be added
static DataTableSql CreateFromSql(DataHeading heading, string sql)
{
var newtable = new DataTableSql {
DataType = DataTypeRelation.Get(heading),
SqlSelectText = sql,
};
return(newtable);
}
//--- functions to manipulate queries
// generate SQL code for restrict
DataTableSql AddWhere(ExpressionEval expr, bool hasgroupby)
{
if (SqlWhereText != null)
{
return(DataTableSql.CreateFromSubquery(this).AddWhere(expr, hasgroupby));
}
SqlWhereText = (hasgroupby) ? _gen.Having(expr) : _gen.Where(expr);
return(this);
}
// generate SQL code for order by
DataTableSql AddOrderBy(ExpressionEval[] expr)
{
if (SqlOrderByText != null)
{
return(DataTableSql.CreateFromSubquery(this).AddOrderBy(expr));
}
SqlOrderByText = _gen.OrderBy(expr);
return(this);
}
public string SelectAll(string tableorquery, DataTableSql other)
{
var dict = new Dictionary <string, SubstituteDelegate> {
{ "select", (x) => tableorquery },
{ "namelist", (x) => NameList(other.Heading) },
};
return(_templater.Process("SelectAll", dict));
}
public override DataTable Transform(DataHeading heading, ExpressionEval[] exprs)
{
_database.RegisterExpressions(exprs);
var sql = _gen.SelectAs(GetFrom(), exprs);
var newtable = DataTableSql.CreateFromSql(heading, sql);
Logger.WriteLine(4, "[Trn '{0}']", newtable);
return(newtable);
}
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);
}
// Compare tables: joinop is INTERSECT, MINUS or NUL (for equals)
bool SetCompare(DataTableSql other, JoinOps joinop, bool both)
{
Logger.Assert(Heading.Equals(other.Heading));
var sql = _gen.SelectOneWhere(GetQuery(), other.GetQuery(), joinop, both);
var ret = GetBoolValue(sql);
Release();
other.Release();
return(ret);
}
// Create new base table, assumed to exist
public static DataTableSql Create(string name, DataHeading heading)
{
var ret = new DataTableSql {
DataType = DataTypeRelation.Get(heading),
TableName = name,
};
ret.DataType.ProposeCleanName(name);
return(ret);
}
public override DataTable TransformAggregate(DataHeading heading, ExpressionEval[] exprs)
{
_database.RegisterExpressions(exprs);
// groups must include all cols that are input to anything other than Aggregate
var groups = GroupColumns(exprs);
var sql = _gen.SelectAsGroup(GetFrom(), exprs, groups);
var newtable = DataTableSql.CreateFromSql(heading, sql);
newtable.HasGroupBy = true;
Logger.WriteLine(4, "[TrnA '{0}']", newtable);
return(newtable);
}
// Store new entry to catalog, perhaps removing old value first
// Currently only for Sql -- Local does total dump
internal void StoreEntry(CatalogEntry entry, CatalogEntry oldentry = null)
{
var ctm = CatalogTableMaker.Create(_catalogtableheading);
if (SqlFlag)
{
var table = DataTableSql.Create(CatalogTableName, _catalogtableheading);
if (oldentry != null)
{
var ctmx = CatalogTableMaker.Create(_catalogtableheading);
ctmx.Table.AddRow(ctmx.MakeEntry(oldentry));
table.UpdateJoin(ctmx.Table, JoinOps.MINUS);
}
ctm.Table.AddRow(ctm.MakeEntry(entry));
table.UpdateJoin(ctm.Table, JoinOps.UNION);
}
}
// set entry to value, update as needed
internal void SetValue(CatalogEntry entry, TypedValue value)
{
// Choose where to store and whether to convert
TypedValue finalvalue;
if (entry.IsDatabase && _catalog.SqlFlag)
{
// Database + sql => hand it to sql, to create table if needed
// set a default value to carry the type
DataTableSql.Create(entry.Name, value.AsTable());
finalvalue = value.DataType.DefaultValue();
}
else
{
// everything else stored in catalog
if (value.DataType is DataTypeRelation)
{
finalvalue = RelationValue.Create(DataTableLocal.Convert(value.AsTable()));
}
else
{
finalvalue = value;
}
// set flags for persisting
if (entry.IsPersistent)
{
entry.IsUnsaved = true;
entry.IsLoaded = true;
}
}
// store value if changed
if (finalvalue != entry.Value)
{
var oldvalue = (entry.Value == null) ? null : entry;
entry.Set(finalvalue);
if (entry.IsPersistent && _catalog.SaveFlag)
{
_catalog.StoreEntry(entry, oldvalue);
}
}
}
//--- persistence Mk II
// Store the persistent catalog and modified tables, local only
// note: for Sql, only used to create new empty catalog
public void StoreToTable()
{
Logger.WriteLine(2, "Save catalog for '{0}'", DatabaseName);
var ctm = CatalogTableMaker.Create(_catalogtableheading);
var table = ctm.AddEntries(PersistentVars.GetEntries()).Table;
if (SqlFlag)
{
DataTableSql.Create(CatalogTableName, table);
}
else
{
Persist.Create(DatabasePath, true).Store(CatalogTableName, RelationValue.Create(table));
var savers = PersistentVars.GetEntries().Where(e => e.IsUnsaved);
Logger.WriteLine(2, $"Persist {savers.Count()} entries");
foreach (var entry in savers)
{
Persist.Create(DatabasePath, true).Store(entry.Name, entry.Value);
}
}
}
// Get the value of a relation from a database
// Entry previously created by peeking
public bool LinkRelvar(string name)
{
var entry = GlobalVars.FindEntry(name);
Logger.Assert(entry != null && entry.IsDatabase);
var heading = entry.DataType.Heading;
if (SqlFlag)
{
var sqlheading = SqlTarget.Current.GetTableHeading(name);
if (sqlheading == null)
{
throw ProgramError.Fatal("Catalog", "sql table not found: '{0}'", name);
}
// TODO: smarter test, but still may not match exactly
//if (!heading.Equals(sqlheading))
if (heading.Degree != sqlheading.Degree)
{
throw ProgramError.Fatal("Catalog", "sql table schema mismatch: '{0}'", name);
}
var table = DataTableSql.Create(name, heading);
GlobalVars.SetValue(entry, RelationValue.Create(table));
}
else
{
var tablev = Persist.Create(DatabasePath, false).Load(name);
if (tablev == null)
{
throw ProgramError.Fatal("Catalog", "local table not found: '{0}'", name);
}
if (!heading.Equals(tablev.Heading))
{
throw ProgramError.Fatal("Catalog", "local table schema mismatch: '{0}'", name);
}
GlobalVars.SetValue(entry, RelationValue.Create(tablev.AsTable()));
}
return(true);
}
public override DataTable TransformOrdered(DataHeading heading, ExpressionEval[] exprs, ExpressionEval[] orderexps)
{
_database.RegisterExpressions(exprs);
var names = exprs.Where(e => e.IsProject).Select(e => e.Name);
var isagg = exprs.Any(e => e.HasFold);
var allin = orderexps.All(o => names.Contains(o.Name));
// if all ordering fields are in exprs then add order to newtable, else to this table
if (!allin)
{
AddOrderBy(orderexps);
}
var sql = (isagg) ? _gen.SelectAsGroup(GetFrom(), exprs, GroupColumns(exprs))
: _gen.SelectAs(GetFrom(), exprs);
var newtable = DataTableSql.CreateFromSql(heading, sql);
if (allin)
{
newtable.AddOrderBy(orderexps);
}
newtable.HasGroupBy = isagg;
Logger.WriteLine(4, "[TrnO '{0}']", newtable);
return(newtable);
}