internal override string GetInsertCommand(InsertExpression expression)
{
StringBuilder stringBuilder = new StringBuilder();
StringBuilder columnString = new StringBuilder();
StringBuilder valueString = new StringBuilder();
foreach (var setting in expression.SettingList)
{
columnString.Append(setting.ColumnName);
if (setting.Value.GetType() == DateTime.Now.GetType())
{
valueString.Append($"'{((DateTime)setting.Value).ToString("yyyy-MM-dd")}'");
}
else
{
valueString.Append($"'{setting.Value}'");
}
if (setting != expression.SettingList.Last())
{
columnString.Append(",");
valueString.Append(",");
}
}
stringBuilder.Append($"INSERT INTO {expression.TableName} ({columnString.ToString()}) VALUES ({valueString.ToString()});");
return(stringBuilder.ToString());
}
public virtual void InsertMigrationFingerPrint(string id, string description)
{
var cmd = new InsertExpression(this.MigrationTableName)
.Parameter("Id", id)
.Parameter("Description", description)
.FunctionParameter("Executed", FunctionType.CurrentDateTime);
this.DatabaseContext.InsertRow(cmd);
}
protected InsertExpression CreateInsertExpression(object entity, TableAttribute table, IColumnInfoCollection columns)
{
var values = new ValuesExpression();
var insert = new InsertExpression(new TableExpression(table))
{
Values = values
};
var type = entity.GetType();
if (type.Module.ScopeName == "FooBar")
{
type = type.BaseType;
}
var discriminator = columns.SingleOrDefault(c => c.IsDiscriminatorColumn);
if (discriminator != null)
{
values.AddColumn(discriminator.ToColumnExpression());
values.AddValue(Expression.Constant(type.FullName));
}
foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
try
{
var column = columns.SingleOrDefault(c => c.DescribesProperty(pi));
if (column == null)
{
continue;
}
var value = pi.GetValue(entity);
if (column.IsIdentity)
{
var defaultValue = Activator.CreateInstance(pi.PropertyType);
if (!value.Equals(defaultValue))
{
insert.IsIdentityInsertEnabled = true;
}
else
{
continue;
}
}
values.AddColumn(column.ToColumnExpression());
values.AddValue(Expression.Constant(value));
}
catch (Exception ex)
{
Debugger.Break();
}
}
return(insert);
}
public virtual void CopyValues(TableAttribute fromTable, TableAttribute toTable, IEnumerable <ColumnInfo> columns)
{
var select = new SelectExpression(new TableExpression(fromTable));
var insert = new InsertExpression(new TableExpression(toTable))
{
Select = select
};
foreach (var column in columns)
{
if (column.IsIdentity)
{
insert.IsIdentityInsertEnabled = true;
}
select.AddSelection(column.ToColumnExpression());
}
ExecuteNonQuery(insert);
}
public virtual DatabaseCommand GenerateInsert(InsertExpression model)
{
string names = string.Join(",", model.Parameters.Select(p => p.Name));
string values = string.Join(",", model.Parameters.Select(p =>
!p.IsFunction?"@" + p.Name:this.TypeMapper.MapFunctionType(p.Function)));
string cmd = string.Format(InsertDataFormat,
model.TableName,
names,
values);
DatabaseCommand ret = new DatabaseCommand(cmd);
foreach (var p in model.Parameters)
{
if (!p.IsFunction)
{
ret.Parameters.Add(p.Name, p.Value);
}
}
return(ret);
}
/// <summary>
/// Inserts obejcts without reading them into the cache
/// only used for manytomany table entries
/// </summary>
/// <param name="stmt"></param>
/// <typeparam name="T"></typeparam>
public void InsertStatement <T>(InsertExpression <T> stmt)
{
var conn = _connection;
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using var cmd = conn.CreateCommand();
cmd.CommandText = stmt.AsSqlString();
cmd.Transaction = _transaction;
foreach (var(type, id, value) in stmt.GetParameters())
{
var param = cmd.CreateParameter();
param.Value = value ?? DBNull.Value;
param.DbType = type;
param.ParameterName = id;
cmd.Parameters.Add(param);
}
using var result = cmd.ExecuteReader();
}
/// <summary>
/// Executes the given InsertStatement and maps returned values back into entities
/// objects created like this are add into the cache as managed entities
/// </summary>
/// <param name="stmt"></param>
/// <typeparam name="TEntity"></typeparam>
/// <exception cref="Exception"></exception>
public void Insert <TEntity>(InsertExpression <TEntity> stmt)
{
var conn = _connection;
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
using var cmd = conn.CreateCommand();
cmd.CommandText = stmt.AsSqlString();
cmd.Transaction = _transaction;
// set all prepared stmt placeholders
foreach (var(type, id, value) in stmt.GetParameters())
{
var param = cmd.CreateParameter();
param.Value = value ?? DBNull.Value;
param.DbType = type;
param.ParameterName = id;
cmd.Parameters.Add(param);
}
using var reader = new CachedDataReader(
_ctx.Cache,
stmt.Entity,
cmd.ExecuteReader(),
_ctx
);
//reader reads objects into Cache
var entries = reader
.ReadAllInto(stmt.InsertedObjects.Cast <object>())
.ToList();
//register lazyloaders on newly created objects
foreach (var cacheEntry in entries)
{
RegisterLazyLoader(cacheEntry.Object, cacheEntry.Entity, cacheEntry);
}
}
public void AddManyToMany(Entity manyToManyEntity, InsertExpression <Dictionary <string, object> > manyToManyInsert)
{
_newManyToManys.GetOrInsert(manyToManyEntity, new List <InsertExpression <Dictionary <string, object> > >())
.Add(manyToManyInsert);
}
public virtual int InsertRow(InsertExpression model)
{
return(exec(Factory.GenerateInsert(model)));
}
public InsertExpression InsertRow(string tableName)
{
var insert = new InsertExpression(tableName);
return(insert);
}
internal abstract string GetInsertCommand(InsertExpression expression);
