public ColumnReference(TableReference tableReference, Column columnDescription)
{
InitializeMembers();
this.tableReference = tableReference;
this.columnName = columnDescription.Name;
this.dataType = columnDescription.DataType;
}
public static SelectList Create(TableReference tableReference)
{
SelectList root = null;
SelectList last = null;
Create(ref root, ref last, tableReference);
return root;
}
private void CopyMembers(TableStatistics old)
{
this.table = old.table;
this.binCount = old.binCount;
this.keyColumn = old.keyColumn;
this.keyValue = new List<double>(old.keyValue);
this.keyCount = new List<long>(old.keyCount);
this.rowCount = old.rowCount;
}
public override Node Interpret()
{
if (IsUdf)
{
this.tableReference = new TableReference(this);
}
return base.Interpret();
}
public override Node Interpret()
{
// Subqueries already initialize this
if (this.tableReference == null)
{
this.tableReference = new TableReference(this);
}
return base.Interpret();
}
public bool IsSpecificToTable(TableReference table)
{
foreach (var tr in NodeExtensions.EnumerateTableReferences(this))
{
if (tr != null && !tr.Compare(table))
{
return false;
}
}
return true;
}
public WhereClause GenerateWhereClauseSpecificToTable(TableReference table)
{
SearchCondition sc = null;
// Loop over all conditions (JOIN ONs and WHERE conditions)
// Result will be a combinations of the table specific conditions terms
// of all these
// Chain up search conditions with AND operator
foreach (var condition in conditions)
{
foreach (var ex in EnumerateCnfTermsSpecificToTable(condition, table))
{
var nsc = ex.GetParsingTree();
if (sc != null)
{
nsc.Stack.AddLast(Whitespace.Create());
nsc.Stack.AddLast(LogicalOperator.CreateAnd());
nsc.Stack.AddLast(Whitespace.Create());
nsc.Stack.AddLast(sc);
}
sc = nsc;
}
}
// Prefix with the WHERE keyword
if (sc != null)
{
var where = new WhereClause();
where.Stack.AddLast(Keyword.Create("WHERE"));
where.Stack.AddLast(Whitespace.Create());
where.Stack.AddLast(sc);
return where;
}
else
{
return null;
}
}
private void InitializeMembers()
{
this.sourceTableReferences = new Dictionary<string, TableReference>(Schema.SchemaManager.Comparer);
this.resultsTableReference = new TableReference(this);
}
private string GetEscapedUniqueName(TableReference table)
{
if (table.IsSubquery || table.IsComputed)
{
return EscapeIdentifierName(table.Alias);
}
else
{
string res = String.Empty;
if (table.DatasetName != null)
{
res += String.Format("{0}_", EscapeIdentifierName(table.DatasetName));
}
if (table.DatabaseName != null)
{
res += String.Format("{0}_", EscapeIdentifierName(table.DatabaseName));
}
if (table.SchemaName != null)
{
res += String.Format("{0}_", EscapeIdentifierName(table.SchemaName));
}
if (table.DatabaseObjectName != null)
{
res += String.Format("{0}", EscapeIdentifierName(table.DatabaseObjectName));
}
return res;
}
}
/// <summary>
/// Composes a source query for a remote table
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public SourceTableQuery PrepareCopyRemoteTable(TableReference table)
{
// -- Load schema
var sm = this.GetSchemaManager(false);
var ds = sm.Datasets[table.DatasetName];
// Graywulf dataset has to be converted to prevent registry access
if (ds is GraywulfDataset)
{
ds = new SqlServerDataset(ds);
}
// --- Generate most restrictive query
// Find the query specification this table belongs to
var qs = ((TableSource)table.Node).QuerySpecification;
// Run the normalizer to convert where clause to a normal form
var cnr = new SearchConditionNormalizer();
cnr.NormalizeQuerySpecification(qs);
var cg = SqlCodeGeneratorFactory.CreateCodeGenerator(ds);
var sql = cg.GenerateMostRestrictiveTableQuery(table, true, 0);
return new SourceTableQuery()
{
Dataset = ds,
Query = sql
};
}
public void PrepareComputeTableStatistics(Context context, TableReference tr, out string connectionString, out string sql)
{
// Assign a database server to the query
// TODO: maybe make this function generic
// TODO: check this part to use appropriate server and database
var sm = GetSchemaManager(false);
var ds = sm.Datasets[tr.DatasetName];
if (ds is GraywulfDataset && !((GraywulfDataset)ds).IsSpecificInstanceRequired)
{
var gds = (GraywulfDataset)ds;
var dd = new DatabaseDefinition(context);
dd.Guid = gds.DatabaseDefinition.Guid;
dd.Load();
// Get a server from the scheduler
var si = new ServerInstance(Context);
si.Guid = Scheduler.GetNextServerInstance(new Guid[] { dd.Guid }, StatDatabaseVersionName, null);
si.Load();
connectionString = si.GetConnectionString().ConnectionString;
SubstituteDatabaseName(tr, si.Guid, StatDatabaseVersionName);
tr.DatabaseObject = null;
}
else
{
// Run it on the specific database
connectionString = ds.ConnectionString;
}
// Generate statistics query
var cg = new SqlServerCodeGenerator();
cg.ResolveNames = true;
sql = cg.GenerateTableStatisticsQuery(tr);
}
/// <summary>
/// Checks if table is a remote table cached locally and if so,
/// substitutes corresponding temp table name
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public string SubstituteRemoteTableName(TableReference tr)
{
if (RemoteTableReferences.ContainsKey(tr.UniqueName))
{
/*return String.Format("[{0}].[{1}].[{2}]",
GetTemporaryDatabaseConnectionString().InitialCatalog,
Query.TemporarySchemaName,
TemporaryTables[table.UniqueName]);*/
var table = TemporaryTables[tr.UniqueName];
return String.Format("[{0}].[{1}].[{2}]",
!String.IsNullOrEmpty(table.DatabaseName) ? table.DatabaseName : table.Dataset.DatabaseName,
table.SchemaName,
table.TableName);
}
else
{
return tr.GetFullyResolvedName();
}
}
public void CopyRemoteTable(TableReference table, SourceQueryParameters source)
{
// Temp table name
var temptable = GetTemporaryTable(table.EscapedUniqueName);
TemporaryTables.TryAdd(table.UniqueName, temptable);
var destination = new DestinationTableParameters()
{
Table = temptable,
Operation = DestinationTableOperation.Drop | DestinationTableOperation.Create,
};
var bcp = CreateQueryImporter(source, destination, false);
bcp.Source = source;
bcp.Destination = destination;
bcp.CreateDestinationTable();
var guid = Guid.NewGuid();
RegisterCancelable(guid, bcp);
bcp.Execute();
UnregisterCancelable(guid);
}
private static void Create(ref SelectList root, ref SelectList last, TableReference tableReference)
{
foreach (var cr in tableReference.ColumnReferences)
{
// Create new expression
var nsl = SelectList.Create(cr);
// If root is uninitialized, initialize now
if (root == null)
{
root = nsl;
}
// Append to list if not the first
if (last != null)
{
last.Append(nsl);
}
last = nsl;
}
if (root == null)
{
throw new InvalidOperationException();
}
}
private void InitializeMembers()
{
this.tableReference = null;
}
private void CopyMembers(QuerySpecification old)
{
this.sourceTableReferences = new Dictionary <string, TableReference>(old.sourceTableReferences);
this.resultsTableReference = new TableReference(old.resultsTableReference);
}
private void OnAsyncExecute(Guid workflowInstanceGuid, string activityInstanceId, QueryBase query, TableReference tableReference, string connectionString, string sql)
{
RegisterCancelable(workflowInstanceGuid, activityInstanceId, query);
query.ComputeTableStatistics(tableReference, connectionString, sql);
UnregisterCancelable(workflowInstanceGuid, activityInstanceId, query);
}
public SourceQueryParameters PrepareCopyRemoteTable(TableReference table)
{
// Load schema
var sm = this.GetSchemaManager(false);
var ds = sm.Datasets[table.DatasetName];
// Graywulf dataset is to be converted to prevent registry access
if (ds is GraywulfDataset)
{
ds = new SqlServerDataset(ds);
}
var source = new SourceQueryParameters();
source.Dataset = ds;
// Find the query specification this table belongs to
var qs = ((TableSource)table.Node).QuerySpecification;
// Run the normalizer
var cnr = new SearchConditionNormalizer();
cnr.NormalizeQuerySpecification(qs);
var cg = SqlCodeGeneratorFactory.CreateCodeGenerator(ds);
source.Query = cg.GenerateMostRestrictiveTableQuery(table, true, 0);
return source;
}
private void OnAsyncExecute(Guid workflowInstanceGuid, string activityInstanceId, QueryPartitionBase querypartition, TableReference remotetable, SourceQueryParameters source)
{
RegisterCancelable(workflowInstanceGuid, activityInstanceId, querypartition);
querypartition.CopyRemoteTable(remotetable, source);
UnregisterCancelable(workflowInstanceGuid, activityInstanceId, querypartition);
}
/// <summary>
/// Gather statistics for the table with the specified bin size
/// </summary>
/// <param name="tr"></param>
/// <param name="binSize"></param>
public virtual void ComputeTableStatistics(TableReference tr, string connectionString, string sql)
{
using (SqlConnection cn = new SqlConnection(connectionString))
{
cn.Open();
using (SqlCommand cmd = new SqlCommand(sql, cn))
{
cmd.Parameters.Add("@BinCount", SqlDbType.Decimal).Value = tr.Statistics.BinCount;
cmd.CommandTimeout = queryTimeout;
ExecuteLongCommandReader(cmd, dr =>
{
long rc = 0;
while (dr.Read())
{
tr.Statistics.KeyValue.Add(dr.GetDouble(0));
tr.Statistics.KeyCount.Add(dr.GetInt64(1));
rc += dr.GetInt64(1);
}
tr.Statistics.RowCount = rc;
});
}
}
}
private void CopyMembers(ColumnReference old)
{
this.columnExpression = old.columnExpression;
this.columnIdentifier = old.columnIdentifier;
this.tableReference = old.tableReference;
this.columnName = old.columnName;
this.dataType = old.dataType;
this.columnAlias = old.columnAlias;
this.isStar = old.isStar;
this.isComplexExpression = old.isComplexExpression;
this.selectListIndex = old.selectListIndex;
this.columnContext = old.columnContext;
}
/// <summary>
/// Copies a table from a remote data source by creating and
/// executing a table copy task.
/// </summary>
/// <param name="table"></param>
/// <param name="source"></param>
public void CopyRemoteTable(TableReference table, SourceTableQuery source)
{
// Create a target table name
var temptable = GetTemporaryTable(GetEscapedUniqueName(table));
TemporaryTables.TryAdd(table.UniqueName, temptable);
var dest = new DestinationTable(temptable)
{
Options = TableInitializationOptions.Drop | TableInitializationOptions.Create
};
var tc = CreateTableCopyTask(source, dest, false);
var guid = Guid.NewGuid();
RegisterCancelable(guid, tc);
tc.Execute();
UnregisterCancelable(guid);
}
private void InitializeMembers()
{
this.columnExpression = null;
this.columnIdentifier = null;
this.tableReference = null;
this.columnName = null;
this.dataType = DataType.Unknown;
this.columnAlias = null;
this.isStar = false;
this.isComplexExpression = false;
this.selectListIndex = -1;
this.columnContext = Graywulf.SqlParser.ColumnContext.None;
}
/// <summary>
/// Checks if table is a remote table cached locally and if so,
/// substitutes corresponding temp table name
/// </summary>
/// <param name="table"></param>
/// <returns></returns>
public string SubstituteRemoteTableName(TableReference tr)
{
if (RemoteTableReferences.ContainsKey(tr.UniqueName))
{
return CodeGenerator.GetResolvedTableName(TemporaryTables[tr.UniqueName]);
}
else
{
return CodeGenerator.GetResolvedTableName(tr);
}
}
/// <summary>
/// Collect list of table sources and load columns from the schema.
/// </summary>
/// <remarks>
/// Source tables are put into a dictionary that is keyed by table alias
/// or table name.
/// </remarks>
/// <param name="qs"></param>
private void CollectSourceTableReferences(QuerySpecification qs)
{
// --- Collect column references from subqueries or load from the database schema
foreach (var tr in qs.EnumerateSourceTableReferences(false))
{
string tablekey;
if (tr.IsSubquery || tr.IsComputed || tr.IsUdf || tr.Alias != null)
{
tablekey = tr.Alias;
}
else
{
// If no alias is used then use table name
tablekey = tr.DatabaseObjectName;
}
// Make sure that table key is used only once
if (qs.SourceTableReferences.ContainsKey(tablekey))
{
throw CreateException(ExceptionMessages.DuplicateTableAlias, null, tablekey, tr.Node);
}
else
{
var ntr = new TableReference(tr);
if (!ntr.IsSubquery && !ntr.IsComputed)
{
// Load table description from underlying schema
// Attempt to load dataset and throw exception of name cannot be resolved
DatasetBase ds;
try
{
ds = schemaManager.Datasets[ntr.DatasetName];
}
catch (KeyNotFoundException ex)
{
throw CreateException(ExceptionMessages.UnresolvableDatasetReference, ex, ntr.DatasetName, ntr.Node);
}
catch (SchemaException ex)
{
throw CreateException(ExceptionMessages.UnresolvableDatasetReference, ex, ntr.DatasetName, ntr.Node);
}
ntr.DatabaseObject = ds.GetObject(ntr.DatabaseName, ntr.SchemaName, ntr.DatabaseObjectName);
// Load column descriptions for the table
ntr.LoadColumnReferences(schemaManager);
}
qs.SourceTableReferences.Add(tablekey, ntr);
}
}
}
/// <summary>
/// Enumerates the terms of an expression tree that are specific to a table.
/// </summary>
/// <param name="node"></param>
/// <param name="table"></param>
/// <returns></returns>
/// <remarks>The expression must be in CNF</remarks>
private static IEnumerable<LogicalExpressions.Expression> EnumerateCnfTermsSpecificToTable(LogicalExpressions.Expression node, TableReference table)
{
foreach (var term in EnumerateCnfTerms(node))
{
if (term is LogicalExpressions.OperatorOr)
{
// A term is only specific to a table if it contains predicates
// only specific to the particular table
var specifictotable = true;
foreach (var exp in EnumerateCnfTermPredicates(term))
{
if (!GetCnfLiteralPredicate(exp).IsSpecificToTable(table))
{
specifictotable = false;
break;
}
}
if (specifictotable)
{
yield return term;
}
}
else
{
if (GetCnfLiteralPredicate(term).IsSpecificToTable(table))
{
yield return term;
}
}
}
}
public bool Compare(TableReference other)
{
bool res = true;
// **** verify this or delete
//res &= (!this.isUdf && !other.isUdf) ||
// (this.isUdf && StringComparer.CurrentCultureIgnoreCase.Compare(this.alias, other.tableName) == 0) ||
// (other.isUdf && StringComparer.CurrentCultureIgnoreCase.Compare(other.alias, this.tableName) == 0) ||
// (this.isUdf && other.isUdf && StringComparer.CurrentCultureIgnoreCase.Compare(this.alias, other.alias) == 0);
res &= (this.datasetName == null || other.datasetName == null ||
SchemaManager.Comparer.Compare(this.datasetName, other.datasetName) == 0);
res &= (this.databaseName == null || other.databaseName == null ||
SchemaManager.Comparer.Compare(this.databaseName, other.databaseName) == 0);
res &= (this.schemaName == null || other.schemaName == null ||
SchemaManager.Comparer.Compare(this.schemaName, other.schemaName) == 0);
res &= (this.databaseObjectName == null || other.databaseObjectName == null ||
SchemaManager.Comparer.Compare(this.databaseObjectName, other.databaseObjectName) == 0);
res &= (this.alias == null || other.alias == null ||
SchemaManager.Comparer.Compare(this.alias, other.alias) == 0);
return res;
}
private void CopyMembers(QuerySpecification old)
{
this.sourceTableReferences = new Dictionary<string, TableReference>(old.sourceTableReferences);
this.resultsTableReference = new TableReference(old.resultsTableReference);
}
public TableReference(TableReference old)
{
CopyMembers(old);
}
public static TableOrViewName Create(TableReference tr)
{
var res = new TableOrViewName();
res.tableReference = tr;
return res;
}
private void CopyMembers(TableReference old)
{
this.node = old.node;
this.databaseObject = old.databaseObject;
this.datasetName = old.datasetName;
this.databaseName = old.databaseName;
this.schemaName = old.schemaName;
this.databaseObjectName = old.databaseObjectName;
this.alias = old.alias;
this.isTableOrView = old.isTableOrView;
this.isUdf = old.isUdf;
this.isSubquery = old.isSubquery;
this.isComputed = old.isComputed;
// Deep copy of column references
this.columnReferences = new List<ColumnReference>();
foreach (var cr in old.columnReferences)
{
var ncr = new ColumnReference(cr)
{
TableReference = this
};
this.columnReferences.Add(ncr);
}
//this.conditionReferences = new List<SearchConditionReference>(old.conditionReferences);
this.statistics = old.statistics == null ? null : new TableStatistics(old.statistics);
}
private void InitializeMembers()
{
this.tableReference = null;
}
private void InitializeMembers()
{
this.sourceTableReferences = new Dictionary <string, TableReference>(Schema.SchemaManager.Comparer);
this.resultsTableReference = new TableReference(this);
}
