/// <summary>
/// Sets identity for table function
/// </summary>
/// <param name="tableFunction"></param>
/// <param name="dictionary">Dictionary from data reader</param>
protected virtual void SetIdentity(TableFunction tableFunction, IDictionary<string, object> dictionary)
{
var identity = string.Concat(dictionary["Identity"]);
if (string.Compare(identity, "No identity column defined.", true) != 0)
tableFunction.Identity = new Identity(identity, Convert.ToInt32(dictionary["Seed"]), Convert.ToInt32(dictionary["Increment"]));
}
/// <summary>
/// Adds a column in table function from row dictionary
/// </summary>
/// <param name="tableFunction">Instance of <see cref="TableFunction"/> class</param>
/// <param name="dictionary">Dictionary from data reader</param>
protected virtual void AddColumn(TableFunction tableFunction, IDictionary<string, object> dictionary)
{
var column = SqlServerDatabaseFactoryHelper.GetColumn(dictionary);
if (!DatabaseImportSettings.ExclusionTypes.Contains(column.Type))
tableFunction.Columns.Add(column);
}
public InletFlux(BoundaryCondition BC, TableFunction _flux, GetBetaFunction getElasticBeta)
: base(BC.core_node, BC.current_time)
{
this.previous_velocity = 0;
base_flux_on_time = _flux;
flux_on_time = _flux;
// Artery lumen of terminal and previous nodes are set the same
core_node.lumen_sq_0 = neighbour_node.lumen_sq_0;
core_node.lumen_sq = core_node.lumen_sq_0;
double R0 = Math.Sqrt(core_node.lumen_sq_0 / Math.PI);
beta_1 = getElasticBeta(R0, core_node.elasticity) / core_node.lumen_sq_0;
flux_function = delegate(double A)
{
return(A * chrt_back + 4 * Math.Pow(A, 1.25f) * Math.Sqrt(beta_1 / 2.0 / GlobalDefs.BLOOD_DENSITY) - flux_on_time(current_time));
};
this.chrt_back = -4 * Math.Pow(core_node.lumen_sq_0, 0.25f) * Math.Sqrt(beta_1 / 2.0f / GlobalDefs.BLOOD_DENSITY);
}
//---------------------------------------------------------------------------
void CalcIncidentRadns()
{
List <double> ios = new List <double>();
//List<double> ets = new List<double>();
List <double> time = new List <double>();
int preDawn = (int)Math.Floor(12 - DayLength / 2.0);
int postDusk = (int)Math.Ceiling(12 + DayLength / 2.0);
for (int i = 0; i < 24; i++)
{
time.Add(i);
//ios.Add(ETs.value(i) * ratios.value(i));
if (i > preDawn && i < postDusk)
{
ios.Add(Math.Max(CalcInstantaneousIncidentRadiation(i), 0));
}
else
{
ios.Add(0);
}
//ets.Add(ios[i] / 0.75);
}
Ios = new TableFunction(time.ToArray(), ios.ToArray(), false);
//ETs = new TableFunction(time.ToArray(), ets.ToArray(), false);
}
/// <summary>
/// Gets table functions from database connection
/// </summary>
/// <param name="connection">Instance of <see cref="DbConnection"/> class</param>
/// <param name="tableFunctions">Sequence of table functions</param>
/// <returns>A sequence of <see cref="TableFunction"/> that represents existing views in database</returns>
protected virtual IEnumerable<TableFunction> GetTableFunctions(DbConnection connection, IEnumerable<DbObject> tableFunctions)
{
foreach (var dbObject in tableFunctions)
{
using (var command = connection.CreateCommand())
{
var tableFunction = new TableFunction
{
Schema = dbObject.Schema,
Name = dbObject.Name
};
command.Connection = connection;
command.CommandText = string.Format("sp_help '{0}'", dbObject.FullName);
var queryResults = new List<QueryResult>();
using (var dataReader = command.ExecuteReader())
{
while (dataReader.NextResult())
{
var queryResult = new QueryResult();
while (dataReader.Read())
{
var names = SqlServerDatabaseFactoryHelper.GetNames(dataReader).ToList();
var row = new Dictionary<string, object>();
for (var i = 0; i < names.Count; i++)
row.Add(names[i], dataReader.GetValue(i));
queryResult.Items.Add(row);
}
queryResults.Add(queryResult);
}
foreach (var result in queryResults)
{
foreach (var item in result.Items)
{
if (item.ContainsKey("Column_name"))
AddColumn(tableFunction, item);
else if (item.ContainsKey("Identity"))
SetIdentity(tableFunction, item);
else if (item.ContainsKey("Parameter_name"))
AddParameter(tableFunction, item);
}
}
yield return tableFunction;
}
}
}
}
private void ImportDescription(DbConnection connection, TableFunction tableFunction)
{
if (ImportSettings.ImportMSDescription)
{
foreach (var extendProperty in connection.GetMsDescriptionForDbObject(tableFunction))
{
tableFunction.Description = string.Concat(extendProperty.Value);
}
}
}
public virtual TableFunction VisitTableFunction(TableFunction tf)
{
if (tf == null)
return null;
foreach (TableFunctionParameter parameter in tf.Arguments)
{
VisitTableFunctionParameter(parameter);
}
VisitTableFunctionReturn(tf.Return);
return tf;
}
public void CalcRatios()
{
double[] times = new double[24];
for (int i = 0; i < 23; i++)
{
times[i] = i;
}
Ratios = new TableFunction(times, _ratios_);
}
private void ImportExtendedProperties(DbConnection connection, TableFunction tableFunction)
{
foreach (var name in DatabaseImportSettings.ExtendedProperties)
{
foreach (var extendedProperty in connection.GetExtendedProperties(tableFunction, name))
{
// todo: Remove this token
if (name == "MS_Description")
tableFunction.Description = extendedProperty.Value;
}
}
}
//---------------------------------------------------------------------------
void CalcDirectRadns()
{
List <double> dirs = new List <double>();
List <double> time = new List <double>();
for (int i = 0; i < 24; i++)
{
time.Add(i);
dirs.Add(Ios.Value(i) - Idiffs.Value(i));
}
Idirs = new TableFunction(time.ToArray(), dirs.ToArray(), false);
}
//------------------------------------------------------------------------------------------------
protected void CalcSVPs()
{
// calculates SVP at the air temperature
List <double> svp = new List <double>();
List <double> time = new List <double>();
for (int i = 0; i < 24; i++)
{
svp.Add(CalcSVP(Temps.YVals[i]));
time.Add(i);
}
SVPs = new TableFunction(time.ToArray(), svp.ToArray(), false);
}
public virtual TableFunction VisitTableFunction(TableFunction tf)
{
if (tf == null)
{
return(null);
}
foreach (TableFunctionParameter parameter in tf.Arguments)
{
VisitTableFunctionParameter(parameter);
}
VisitTableFunctionReturn(tf.Return);
return(tf);
}
public FunctionNode(TableFunction function) : base(function.Name)
{
TableFunction = function;
ImageKey = "table-function";
SelectedImageKey = "table-function";
Columns = function.Columns.Select(col => new ColumnNode(col)).ToList();
var folder = new FolderNode("Parameters", function.Arguments.Count());
Nodes.Add(folder);
folder.Nodes.AddRange(function.Arguments.Select(p => new ParameterNode(p)).ToArray());
}
public static double[] Test2()
{
var frame3 = Generators.InpulseSignal(1024, 128, 10);
var frame2 = Generators.Sin(1024, 4, 1);
var frame = Generators.Sin(1024, 64, 1);
//for (var i = 0; i < frame.Length; i++)
//{
// frame[i] += frame2[i];// + frame3[i];
//}
var func = Correlation.AutoCorrelation(TableFunction.TableToFunction(frame, 1, 0, 1024), 1, 0, 1024);
return(func);
}
public InletPressure(BoundaryCondition BC, TableFunction _pressure, GetBetaFunction getElasticBeta)
: base(BC.core_node, BC.current_time)
{
pressure_on_time = _pressure;
double R0 = Math.Sqrt(core_node.lumen_sq_0 / Math.PI);
beta_1 = getElasticBeta(R0, core_node.elasticity) / core_node.lumen_sq_0;
core_node.lumen_sq_0 = neighbour_node.lumen_sq_0;
core_node.lumen_sq = neighbour_node.lumen_sq_0;
chrt = 4 * Math.Pow(core_node.lumen_sq_0, 0.25f) * Math.Sqrt(beta_1 / 2.0f / GlobalDefs.BLOOD_DENSITY);
}
protected virtual IEnumerable <TableFunction> GetTableFunctions(DbConnection connection, IEnumerable <DbObject> tableFunctions)
{
foreach (var item in tableFunctions)
{
using (var command = connection.CreateCommand())
{
command.Connection = connection;
command.CommandText = string.Format("sp_help '{0}'", item.FullName);
using (var dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
var tableFunction = new TableFunction
{
Schema = item.Schema,
Name = item.Name
};
dataReader.NextResult();
while (dataReader.Read())
{
var column = new Column();
column.Name = string.Concat(dataReader["Column_name"]);
column.Type = string.Concat(dataReader["Type"]);
column.Length = int.Parse(string.Concat(dataReader["Length"]));
column.Prec = string.Concat(dataReader["Prec"]).Trim().Length == 0 ? default(short) : short.Parse(string.Concat(dataReader["Prec"]));
column.Scale = string.Concat(dataReader["Scale"]).Trim().Length == 0 ? default(short) : short.Parse(string.Concat(dataReader["Scale"]));
column.Nullable = string.Compare(string.Concat(dataReader["Nullable"]), "yes", true) == 0 ? true : false;
column.Collation = string.Concat(dataReader["Collation"]);
if (ImportSettings.ExclusionTypes.Contains(column.Type))
{
continue;
}
tableFunction.Columns.Add(column);
}
yield return(tableFunction);
}
}
}
}
}
//------------------------------------------------------------------------------------------------
protected void CalcVPDs()
{
List <double> time = new List <double>();
List <double> vpd = new List <double>();
double AVP = CalcSVP(MinT); // Actual vapour pressure
for (int i = 0; i < 24; i++)
{
//AD - Have checked. This formula is equivalent to above
//vpd.Add((1 - (rhs.yVals[i] / 100)) * svps.yVals[i]);
vpd.Add(SVPs.YVals[i] - AVP);
time.Add(i);
}
VPDs = new TableFunction(time.ToArray(), vpd.ToArray(), false);
}
public void setInletBC(string inlet_data, int node_number, InletType type)
{
TableFunction inlet_function = null;
IO_Module.LoadTableFunctionFromString(inlet_data, out inlet_function);
int id = v_net.bounds.FindIndex(x => x.core_node.id == node_number);
if (type == InletType.FLUX)
{
v_net.bounds[id] = new InletFlux(v_net.bounds[id], inlet_function, GlobalDefs.getBoileauBeta);
}
if (type == InletType.PRESSURE)
{
v_net.bounds[id] = new InletPressure(v_net.bounds[id], inlet_function, GlobalDefs.getBoileauBeta);
}
}
//------------------------------------------------------------------------------------------------
public void CalcTemps()
{
List <double> hours = new List <double>();
List <double> temperatures = new List <double>();
Angle aDelt = new Angle(23.45 * Math.Sin(2 * Math.PI * (284 + _DOY) / 365), AngleType.Deg);
Angle temp2 = new Angle(Math.Acos(-Math.Tan(Latitude.Rad) * Math.Tan(aDelt.Rad)), AngleType.Rad);
double dayLength = (temp2.Deg / 15) * 2;
double nightLength = (24.0 - dayLength); // night hours
// determine if the hour is during the day or night
double t_mint = 12.0 - dayLength / 2.0 + ZLag; // corrected dawn - GmcL
//time of Tmin ??
double t_suns = 12.0 + dayLength / 2.0; // sundown
for (int t = 1; t <= 24; t++)
{
double hr = t;
double temperature;
if (hr >= t_mint && hr < t_suns) //day
{
double m = 0;
m = hr - t_mint;
temperature = (MaxT - MinT) * Math.Sin((Math.PI * m) / (dayLength + 2 * XLag)) + MinT;
}
else // night
{
double n = 0;
if (hr > t_suns)
{
n = hr - t_suns;
}
if (hr < t_mint)
{
n = (24.0 - t_suns) + hr;
}
double m_suns = dayLength - ZLag;
double T_suns = (MaxT - MinT) * Math.Sin((Math.PI * m_suns) / (dayLength + 2 * XLag)) + MinT;
temperature = MinT + (T_suns - MinT) * Math.Exp(-YLag * n / nightLength);
}
hours.Add(hr - 1);
temperatures.Add(temperature);
}
Temps = new TableFunction(hours.ToArray(), temperatures.ToArray(), false);
}
/// <summary>
/// Generates table function model from schema data.
/// </summary>
/// <param name="dataContext">Data context model.</param>
/// <param name="func">Function schema.</param>
/// <param name="defaultSchemas">List of default database schema names.</param>
private void BuildTableFunction(DataContextModel dataContext, TableFunction func, ISet <string> defaultSchemas)
{
var(name, isNonDefaultSchema) = ProcessObjectName(func.Name, defaultSchemas);
var method = new MethodModel(
_namingServices.NormalizeIdentifier(_options.DataModel.ProcedureNameOptions,
(func.Name.Package != null ? $"{func.Name.Package}_" : null) + name.Name))
{
Modifiers = Modifiers.Public,
Summary = func.Description
};
var metadata = new TableFunctionMetadata()
{
Name = name
};
var funcModel = new TableFunctionModel(
name,
method,
metadata,
_namingServices.NormalizeIdentifier(_options.DataModel.TableFunctionMethodInfoFieldNameOptions, func.Name.Name))
{
Error = func.SchemaError?.Message
};
BuildParameters(func.Parameters, funcModel.Parameters);
if (func.Result != null)
{
funcModel.Result = PrepareResultSetModel(func.Name, func.Result);
}
_interceptors.PreprocessTableFunction(_languageProvider.TypeParser, funcModel);
if (isNonDefaultSchema && _options.DataModel.GenerateSchemaAsType)
{
GetOrAddAdditionalSchema(dataContext, func.Name.Schema !).TableFunctions.Add(funcModel);
}
else
{
dataContext.TableFunctions.Add(funcModel);
}
}
//---------------------------------------------------------------------------
private void ConvertRadiationsToPAR()
{
List <double> io_par = new List <double>();
List <double> idiff_par = new List <double>();
List <double> idir_par = new List <double>();
List <double> time = new List <double>();
for (int i = 0; i < 24; i++)
{
time.Add(i);
idiff_par.Add(Idiffs.Value(i) * RPAR * 4.25 * 1E6);
idir_par.Add(Idirs.Value(i) * (1 - RPAR) * 4.56 * 1E6);
io_par.Add(idiff_par[i] + idir_par[i]);
}
Ios_PAR = new TableFunction(time.ToArray(), io_par.ToArray(), false);
Idiffs_PAR = new TableFunction(time.ToArray(), idiff_par.ToArray(), false);
Idirs_PAR = new TableFunction(time.ToArray(), idir_par.ToArray(), false);
}
static public TableFunction makeTableFunction(double[,] table_function_0)
{
double period = table_function_0[table_function_0.GetLength(0) - 1, 0] - table_function_0[0, 0];
TableFunction t_f = delegate(double time)
{
double value = 0;
int l_ind = 0;
int r_ind = table_function_0.GetLength(0) - 1;
time = time - period * Math.Floor(time / period);
{
while ((r_ind - l_ind) > 1)
{
int cur_ind = l_ind + (r_ind - l_ind) / 2;
if (table_function_0[cur_ind, 0] > time)
{
r_ind = cur_ind;
}
else
{
l_ind = cur_ind;
}
}
double l_time = table_function_0[l_ind, 0];
double r_time = table_function_0[r_ind, 0];
double l_value = table_function_0[l_ind, 1];
double r_value = table_function_0[r_ind, 1];
value = l_value + (time - l_time) / (r_time - l_time) * (r_value - l_value);
}
return(value);
};
return(t_f);
}
private IList <Column> queryForFunctionColumns(TableFunction func)
{
var sql = new Sql(@"SELECT
C.name AS ColumnName
, Y.[name] AS BaseDataTypeName
, C.is_nullable AS AllowNull
FROM sys.objects AS T
INNER JOIN sys.schemas AS S
ON ( T.schema_id = S.schema_id )
INNER JOIN sys.columns AS C
ON ( T.object_id = C.object_id )
INNER JOIN sys.types AS Y
ON ( Y.user_type_id = C.user_type_id )
WHERE T.object_id = @0
AND T.type = 'TF'
ORDER BY C.column_id, C.name;", func.FunctionId);
return(this.peta.Fetch <Column>(sql));
}
//---------------------------------------------------------------------------
void CalcDiffuseRadns()
{
List <double> diffs = new List <double>();
List <double> ets = new List <double>();
List <double> time = new List <double>();
for (int i = 0; i < 24; i++)
{
time.Add(i);
CalcSolarGeometryTimestep(i);
diffs.Add(Math.Max(FracDiffuseATM * SolarConstant * Math.Sin(SunAngle.Rad) / 1000000, 0));
// ets.Add(diffs[i] / fracDiffuseATM);
if (diffs[i] > Ios.Value(i))
{
diffs[i] = Ios.Value(i);
}
}
Idiffs = new TableFunction(time.ToArray(), diffs.ToArray(), false);
// ETs = new TableFunction(time.ToArray(), ets.ToArray(), false);
}
public static EntityClassDefinition CreateView(this DapperProject project, TableFunction tableFunction)
{
var definition = new EntityClassDefinition();
definition.Namespaces.Add("System");
definition.Namespace = tableFunction.HasDefaultSchema() ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(tableFunction.Schema);
definition.Name = tableFunction.GetEntityName();
definition.Constructors.Add(new ClassConstructorDefinition());
if (!string.IsNullOrEmpty(tableFunction.Description))
{
definition.Documentation.Summary = tableFunction.Description;
}
var selection = project.GetSelection(tableFunction);
foreach (var column in tableFunction.Columns)
{
definition.Properties.Add(new PropertyDefinition(project.Database.ResolveType(column), column.GetPropertyName()));
//if (selection.Settings.UseAutomaticPropertiesForEntities)
// definition.Properties.Add(new PropertyDefinition(project.Database.ResolveType(column), tableFunction.GetPropertyNameHack(column)));
//else
// definition.AddPropertyWithField(project.Database.ResolveType(column), tableFunction.GetPropertyNameHack(column));
}
definition.Implements.Add("IEntity");
if (selection.Settings.SimplifyDataTypes)
{
definition.SimplifyDataTypes();
}
return(definition);
}
//------------------------------------------------------------------------------------------------
protected void CalcRHs()
{
List <double> time = new List <double>();
List <double> rh = new List <double>();
// calculate relative humidity
double wP;
if (MaxRH < 0.0 || MinRH < 0.0)
{
wP = CalcSVP(_minT) / 100 * 1000 * 90; // svp at Tmin
}
else
{
wP = (CalcSVP(_minT) / 100 * 1000 * MaxRH + CalcSVP(_maxT) / 100 * 1000 * MinRH) / 2.0;
}
for (int i = 0; i < 24; i++)
{
rh.Add(wP / (10 * SVPs.YVals[i]));
}
RHs = new TableFunction(time.ToArray(), rh.ToArray(), false);
}
protected virtual IEnumerable <TableFunction> GetTableFunctions(DbConnection connection, IEnumerable <DbObject> tableFunctions)
{
foreach (var item in tableFunctions)
{
using (var command = connection.CreateCommand())
{
command.Connection = connection;
command.CommandText = string.Format("sp_help '{0}'", item.FullName);
using (var dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
var tableFunction = new TableFunction
{
Schema = item.Schema,
Name = item.Name
};
dataReader.NextResult();
if (dataReader.HasRows && dataReader.GetName(0) == "Column_name")
{
while (dataReader.Read())
{
var column = new Column();
column.Name = string.Concat(dataReader["Column_name"]);
column.Type = string.Concat(dataReader["Type"]);
column.Length = int.Parse(string.Concat(dataReader["Length"]));
column.Prec = string.Concat(dataReader["Prec"]).Trim().Length == 0 ? default(short) : short.Parse(string.Concat(dataReader["Prec"]));
column.Scale = string.Concat(dataReader["Scale"]).Trim().Length == 0 ? default(short) : short.Parse(string.Concat(dataReader["Scale"]));
column.Nullable = string.Compare(string.Concat(dataReader["Nullable"]), "yes", true) == 0 ? true : false;
column.Collation = string.Concat(dataReader["Collation"]);
if (ImportSettings.ExclusionTypes.Contains(column.Type))
{
continue;
}
tableFunction.Columns.Add(column);
}
}
dataReader.NextResult();
if (dataReader.HasRows && dataReader.GetName(0) == "Identity")
{
// todo: Add code to set identity
}
dataReader.NextResult();
if (dataReader.HasRows && dataReader.GetName(0) == "RowGuidCol")
{
// todo: Add code to set row guid col
}
dataReader.NextResult();
if (dataReader.HasRows && dataReader.GetName(0) == "Parameter_name")
{
while (dataReader.Read())
{
var parameter = new Parameter();
parameter.Name = string.Concat(dataReader["Parameter_name"]);
parameter.Type = string.Concat(dataReader["Type"]);
parameter.Length = short.Parse(string.Concat(dataReader["Length"]));
parameter.Prec = string.Concat(dataReader["Prec"]).Trim().Length == 0 ? default(int) : int.Parse(string.Concat(dataReader["Prec"]));
parameter.ParamOrder = string.Concat(dataReader["Param_order"]).Trim().Length == 0 ? default(int) : int.Parse(string.Concat(dataReader["Param_order"]));
parameter.Collation = string.Concat(dataReader["Collation"]);
tableFunction.Parameters.Add(parameter);
}
}
yield return(tableFunction);
}
}
}
}
}
public static string GetColumnName(this TableFunction tableFunction, Column column)
=> string.Format("[{0}].[{1}].[{2}]", tableFunction.Schema, tableFunction.Name, column.Name);
public static string GetColumnName(this Database database, TableFunction tableFunction, IColumn column) => database.NamingConvention.GetObjectName(tableFunction.Schema, tableFunction.Name, column.Name);
public static SongParametrs Detector(SongData data)
{
var parametrs = new SongParametrs();
parametrs.Song = data;
double[] signal = new double[data.leng];
//Объединение сигналов
for (int i = 0; i < data.leng; i++)
{
signal[i] = data.Left[i] + data.Right[i];
}
int st = 10;
int frameSize = 1 << st;
int sst = 0;
int s = 1 << sst;
int step = 1;
int HiFilter = 1 << 3;
//Преобразование фурье
parametrs.TransformSong = FastFourierTransform.WindowFFTParalell(signal, frameSize, step, s, st - sst);
//Диффирационный фильтр
List <double[]> FrequencyFunctions = new List <double[]>();
for (int i = 0; i < frameSize / HiFilter; i++)
{
double[] func = new double[data.leng / step];
for (int j = 0; j < data.leng / step; j++)
{
func[j] = parametrs.TransformSong[j, i];
}
func = Filters.Differentiator5(func);
FrequencyFunctions.Add(func);
}
ppp = FrequencyFunctions;
//Суммирование
parametrs.BeatFunction = new double[data.leng / step];
for (int i = 0; i < data.leng / step; i++)
{
parametrs.BeatFunction[i] = 0;
for (int j = 1; j < frameSize / HiFilter; j++)
{
parametrs.BeatFunction[i] += Math.Abs(FrequencyFunctions[j][i]);
}
}
var f = Filters.DellShum(parametrs.BeatFunction);
var cor = Correlation.Easy(TableFunction.TableToFunction(f, 1, 0, parametrs.BeatFunction.Length), 1, 0, parametrs.BeatFunction.Length / 3);
var Max = MaxAssistance.LocalMax2(MaxAssistance.LocalMax(MaxAssistance.CompressFunc(cor, 1, 0), 220), 10);
var BeatMax = MaxAssistance.LocalMax2(MaxAssistance.LocalMax(parametrs.BeatFunction, 220), 10);
double BPMd = Max[1].Item1 * 1 * step;
int sd = (int)BeatMax[0].Item1 * step;
parametrs.Temp = 60 * 44100 / BPMd;
parametrs.TempD = (int)BPMd;
parametrs.StartBeat = sd;
return(parametrs);
}
private static MethodDefinition GetGetAllMethod(ProjectFeature <DapperProjectSettings> projectFeature, TableFunction tableFunction)
{
var lines = new List <ILine>();
lines.Add(new CommentLine(" Create connection instance"));
lines.Add(new CodeLine("using (var connection = new SqlConnection(ConnectionString))"));
lines.Add(new CodeLine("{"));
var selection = projectFeature.GetDapperProject().GetSelection(tableFunction);
if (selection.Settings.UseStringBuilderForQueries)
{
lines.Add(new CommentLine(1, " Create string builder for query"));
lines.Add(new CodeLine(1, "var query = new StringBuilder();"));
lines.Add(new CodeLine());
lines.Add(new CommentLine(1, " Create sql statement"));
lines.Add(new CodeLine(1, "query.Append(\" select \");"));
for (var i = 0; i < tableFunction.Columns.Count; i++)
{
var column = tableFunction.Columns[i];
lines.Add(new CodeLine(1, "query.Append(\" {0}{1} \");", tableFunction.GetColumnName(column), i < tableFunction.Columns.Count - 1 ? "," : string.Empty));
}
var selectParameters = tableFunction.Parameters.Count == 0 ? string.Empty : string.Join(", ", tableFunction.Parameters.Select(item => item.Name));
lines.Add(new CodeLine(1, "query.Append(\" from \");"));
lines.Add(new CodeLine(1, "query.Append(\" {0}({1}) \");", tableFunction.GetFullName(), selectParameters));
lines.Add(new CodeLine());
}
else
{
lines.Add(new CommentLine(1, " Create sql statement"));
lines.Add(new CodeLine(1, "var query = @\" select "));
for (var i = 0; i < tableFunction.Columns.Count; i++)
{
var column = tableFunction.Columns[i];
lines.Add(new CodeLine(1, " {0}{1} ", tableFunction.GetColumnName(column), i < tableFunction.Columns.Count - 1 ? "," : string.Empty));
}
var selectParameters = tableFunction.Parameters.Count == 0 ? string.Empty : string.Join(", ", tableFunction.Parameters.Select(item => item.Name));
lines.Add(new CodeLine(1, " from "));
lines.Add(new CodeLine(1, " {0}({1}) ", tableFunction.GetFullName(), selectParameters));
lines.Add(new CodeLine(1, " \";"));
lines.Add(new CodeLine());
}
if (tableFunction.Parameters.Count > 0)
{
lines.Add(new CommentLine(1, " Create parameters collection"));
lines.Add(new CodeLine(1, "var parameters = new DynamicParameters();"));
lines.Add(new CodeLine());
lines.Add(new CommentLine(1, " Add parameters to collection"));
foreach (var parameter in tableFunction.Parameters)
{
lines.Add(new CodeLine(1, "parameters.Add(\"{0}\", {1});", parameter.Name, NamingConvention.GetCamelCase(parameter.Name.Replace("@", ""))));
}
lines.Add(new CodeLine());
}
lines.Add(new CommentLine(1, " Retrieve result from database and convert to typed list"));
if (tableFunction.Parameters.Count == 0)
{
lines.Add(new CodeLine(1, "return await connection.QueryAsync<{0}>(query.ToString());", tableFunction.GetEntityName()));
}
else
{
lines.Add(new CodeLine(1, "return await connection.QueryAsync<{0}>(query.ToString(), parameters);", tableFunction.GetEntityName()));
}
lines.Add(new CodeLine("}"));
var parameters = new List <ParameterDefinition>();
foreach (var parameter in tableFunction.Parameters)
{
parameters.Add(new ParameterDefinition(projectFeature.Project.Database.ResolveType(parameter.Type).ClrAliasType, NamingConvention.GetCamelCase(parameter.Name.Replace("@", ""))));
}
return(new MethodDefinition(string.Format("Task<IEnumerable<{0}>>", tableFunction.GetEntityName()), tableFunction.GetGetAllRepositoryMethodName(), parameters.ToArray())
{
IsAsync = true,
Lines = lines
});
}
