private void LoadAllVariableMetadata(string sql, DatabaseObject databaseObject, IDictionary variables)
{
foreach (Variable v in variables.Values)
{
v.Metadata = new VariableMetadata();
}
using (var cn = OpenConnection())
{
using (var cmd = new NpgsqlCommand(sql, cn))
{
cmd.Parameters.Add("@schemaName", NpgsqlTypes.NpgsqlDbType.Varchar).Value = databaseObject.SchemaName;
cmd.Parameters.Add("@objectName", NpgsqlTypes.NpgsqlDbType.Varchar).Value = databaseObject.ObjectName;
using (var dr = cmd.ExecuteReader())
{
string variablename = null;
VariableMetadata meta = null;
while (dr.Read())
{
string name = dr.GetString(0);
string value = dr.GetString(1);
if (name != variablename)
{
meta = (VariableMetadata)((Variable)variables[name]).Metadata;
variablename = name;
}
meta.Summary = value;
}
}
}
}
}
/// <summary>
/// Adds the replacement <paramref name="expression" /> for the <paramref name="variable" />, causing the
/// <paramref name="variable" /> to be replaced by <paramref name="expression" /> in all future replacement operations.
/// </summary>
/// <param name="variable">The variable that should be replaced by <paramref name="expression" />.</param>
/// <param name="expression">The expression that <paramref name="variable" /> should be replaced with.</param>
public void AddVariableReplacement(VariableMetadata variable, Expression expression)
{
Requires.NotNull(variable, () => variable);
Requires.NotNull(expression, () => expression);
Requires.That(!_replacedVariables.ContainsKey(variable), () => variable, "The variable has already been added.");
_replacedVariables.Add(variable, expression);
}
private void LoadAllVariableMetadata(string sql, DatabaseObject databaseObject, IDictionary variables)
{
// Make sure all will be marked as loaded
foreach (Variable v in variables.Values)
{
v.Metadata = new VariableMetadata();
}
using (var cn = OpenConnection())
{
using (var cmd = new SqlCommand(sql, cn))
{
cmd.Parameters.Add("@schemaName", SqlDbType.NVarChar).Value = databaseObject.SchemaName;
cmd.Parameters.Add("@objectName", SqlDbType.NVarChar).Value = databaseObject.ObjectName;
using (var dr = cmd.ExecuteReader())
{
string variablename = null;
VariableMetadata meta = null;
while (dr.Read())
{
string name = dr.GetString(0);
string metaname = dr.GetString(1);
string value = dr.GetString(2);
if (name != variablename)
{
meta = (VariableMetadata)((Variable)variables[name]).Metadata;
variablename = name;
}
switch (metaname)
{
case Constants.MetaSummary:
meta.Summary = value;
break;
case Constants.MetaContent:
meta.Content = value;
break;
case Constants.MetaUnit:
meta.Unit = value;
break;
default:
break;
}
}
}
}
}
}
/// <summary>
/// Classifies the operations performed on the <paramref name="variable" /> within the <paramref name="node" />.
/// </summary>
/// <param name="node">The node of a bound tree the <paramref name="variable" /> should be classified for.</param>
/// <param name="variable">The variable that should be classified.</param>
public static VariableOperations Classify(BoundNode node, VariableMetadata variable)
{
Requires.NotNull(node, () => node);
Requires.NotNull(variable, () => variable);
_instance._writeContext = 0;
_instance._operations = VariableOperations.None;
_instance._variable = variable;
_instance.Visit(node);
Assert.That(_instance._writeContext == 0, "Unbalanced write context operations.");
return _instance._operations;
}
/// <summary>
/// Gets specified version of the schema for the variable describing its structure.
/// </summary>
public override VariableSchema GetSchema(SchemaVersion version)
{
if (HasChanges)
{
if (version == SchemaVersion.Committed)
{
return(changes.InitialSchema);
}
// Making a schema for proposed version of the variable
string name = changes.Name == null ? this.name : changes.Name;
ReadOnlyDimensionList roDims = new ReadOnlyDimensionList(changes.Dimensions == null ? dims : changes.Dimensions);
VariableMetadata metadata = this.metadata.Clone();
CoordinateSystemCollection cs = changes.Cs == null ? csystems : changes.Cs;
CoordinateSystemSchema[] csSchemas = new CoordinateSystemSchema[cs.Count];
for (int i = 0; i < csSchemas.Length; i++)
{
csSchemas[i] = cs[i].GetSchema();
}
VariableSchema schema = new VariableSchema(name,
TypeOfData,
roDims,
csSchemas,
metadata);
return(schema);
}
else
{
if (version == SchemaVersion.Proposed)
{
throw new Exception("Variable is commited and has no changes.");
}
CoordinateSystemSchema[] csSchemas = new CoordinateSystemSchema[csystems.Count];
for (int i = 0; i < csSchemas.Length; i++)
{
csSchemas[i] = csystems[i].GetSchema();
}
VariableSchema schema = new VariableSchema(
name, TypeOfData,
new ReadOnlyDimensionList(dimensions),
csSchemas,
metadata.Clone());
return(schema);
}
}
protected override void LoadAllParameterMetadata(DatabaseObject databaseObject)
{
var sql = @"SELECT pgd.description,proargnames
FROM pg_catalog.pg_namespace n
INNER JOIN pg_catalog.pg_proc p ON p.pronamespace = n.oid
INNER JOIN pg_catalog.pg_description pgd ON (pgd.objoid=p.oid)
WHERE nspname = @schemaName and proname= @objectName;";
var variables = ((IParameters)databaseObject).Parameters;
foreach (Variable v in variables.Values)
{
v.Metadata = new VariableMetadata();
}
using (var cn = OpenConnection())
{
using (var cmd = new NpgsqlCommand(sql, cn))
{
cmd.Parameters.Add("@schemaName", NpgsqlTypes.NpgsqlDbType.Varchar).Value = databaseObject.SchemaName;
cmd.Parameters.Add("@objectName", NpgsqlTypes.NpgsqlDbType.Varchar).Value = databaseObject.ObjectName;
using (var dr = cmd.ExecuteReader())
{
VariableMetadata meta = null;
while (dr.Read())
{
string value = dr.GetString(0);
var paramname = dr.GetValue(1) as string[];
if (paramname.Count() > 0)
{
var paramlist = paramname;
foreach (var v in paramlist)
{
meta = (VariableMetadata)((Variable)variables[v]).Metadata;
meta.Summary = value;
}
}
}
}
}
}
}
/// <summary>
/// Transforms the <paramref name="variable" />.
/// </summary>
private static Ssm.Var Transform(VariableMetadata variable)
{
return Ssm.Var.NewLocal(variable.Name, Transform(variable.Type));
}
/// <summary>
/// Generates a new, uniquely-named local replacement variable for <paramref name="variable" />.
/// </summary>
private VariableMetadata ReplaceWithNewLocalVariable(VariableMetadata variable)
{
var uniqueName = _nameScope.MakeUnique(variable.Name);
var replacingVariable = new VariableMetadata(uniqueName, variable.Type, isParameter: false);
_localVariables.Add(replacingVariable);
_variableReplacer.AddVariableReplacement(variable, new VariableExpression(replacingVariable));
return replacingVariable;
}
