public void ExecuteReader_Read_dynamically_and_unmapped_entity()
{
string tableName = "tst_SCR_01";
string createTableFormat = "create table {0}(Id integer primary key autoincrement not null, Prop1 nvarchar(50) not null, Prop2 datetime);";
string insertStatementFormat = "Insert into {0}(Prop1, Prop2) Values($prop1, $prop2);";
var transaction = session.BeginTransaction();
var dbConn = session.ConnectionManager.OpenConnection();
session.DataAccess.ExecuteNonQuery(dbConn, transaction, string.Format(createTableFormat, tableName));
for (int i = 1; i < 6; i++)
{
session.DataAccess.ExecuteNonQuery(dbConn, transaction, string.Format(insertStatementFormat, tableName), new QueryParam("prop1", DbType.String)
{
Value = string.Format("val{0}", i)
}, new QueryParam("prop2", DbType.DateTime)
{
Value = DateTime.Now.AddDays(i)
});
}
session.CommitTransaction();
string query = "select Id, Prop1, Prop2 from " + tableName + " where Prop1 = 'val2'";
DynamicEntityMap dmap = new DynamicEntityMap(null, tableName, typeof(SqlCommandRunnerTestsFake1));
SqlCommandRunner runner = new SqlCommandRunner();
SqlCommandRunnerTestsFake1 ent1 = runner.ExecuteReader <SqlCommandRunnerTestsFake1>(dmap, dbConn, session, query, null).FirstOrDefault();
Assert.AreEqual("val2", ent1.Prop1);
}
public void Ctor_Load_Properties_as_column()
{
DynamicEntityMap dmap = new DynamicEntityMap("tb", "tableFake", typeof(DynamicEntityFake));
Assert.AreEqual(4, dmap.Properties.Count);
Assert.AreEqual("tb", dmap.TableAlias);
Assert.AreEqual("tableFake", dmap.TableName);
Assert.AreEqual("Name", dmap["Name"].ColumnName);
Assert.AreEqual("Prop3", dmap["Prop3"].ColumnName);
}
public void Create_proxy_with_valid_entity_map_and_null_proxyhadrator_with_implement_ITrackable_true_should_return_trackable_entity()
{
Type fakeType = typeof(ProxyFakeClassTest);
var entMap = new DynamicEntityMap("faket", "faketable", fakeType);
var obj = fakeType.CreateProxy(entMap, true);
Assert.IsNotNull(obj);
Assert.IsNotAssignableFrom(fakeType, obj);
var trackable = (ITrackable)obj;
Assert.IsFalse(trackable.IsDirty);
//Assert.IsNotNull(trackable);
}
public void Create_proxy_with_valid_entity_map_and_null_proxyhadrator_should_create_a_proxy_already_loaded()
{
Type fakeType = typeof(ProxyFakeClassTest);
var entMap = new DynamicEntityMap("faket", "faketable", fakeType);
var obj = fakeType.CreateProxy(entMap, false);
Assert.IsNotNull(obj);
Assert.IsNotAssignableFrom(fakeType, obj);
var lazyObj = (ILazyObject)obj;
Assert.IsTrue(lazyObj.IsProxyLoaded);
Assert.AreEqual(fakeType, lazyObj.ProxyOf);
}
StatementMap PrepareStatement <T>(ISession session, string statementName, params QueryParam[] paramArray)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
StatementMap statement;
if (!session.SessionFactory.DbSettings.Map.MappedStatements.TryGetValue(statementName, out statement))
{
throw new MappingException("Statement " + statementName + " was not found. Verified if it is mapped properly.");
}
if (string.IsNullOrWhiteSpace(statement.Body))
{
throw new MappingException("Statement " + statementName + " body's was null or empty. Cannot run a mapped statement without SQL.");
}
//does the statement needs to be parsed?
//does the statement has input parameter and db parameters?
bool parse = statement.IsParsingRequired;
if (!parse)
{
parse = ((statement.DbParametersMap.Count > 0) || (statement.InputParametersMap.Count > 0));
}
if (parse && !statement.IsReady)
{
//parse it
if (statement.InputParametersMap.Count > 1)
{
throw new GoliathDataException(string.Format("{0} requires {1} input paremeters. None were provided.", statement.Name, statement.InputParametersMap.Count));
}
EntityMap entityMap;
var type = typeof(T);
if (!session.SessionFactory.DbSettings.Map.EntityConfigs.TryGetValue(type.FullName, out entityMap))
{
entityMap = new DynamicEntityMap(type);
}
var compiledStatement = statementParser.Parse(session.SessionFactory.DbSettings.SqlDialect, entityMap, statement.Body.Trim(), null, paramArray);
ProcessCompiledStatement(compiledStatement, statement);
}
return(statement);
}
/// <summary>
/// Parses the specified text.
/// </summary>
/// <param name="dialect">The mapper.</param>
/// <param name="config">The config.</param>
/// <param name="inputParams">The input params.</param>
/// <param name="text">The text.</param>
/// <param name="dbParameters">The db parameters.</param>
/// <returns></returns>
public CompiledStatement Parse(SqlDialect dialect, MapConfig config, IDictionary <string, StatementInputParam> inputParams, string text, params QueryParam[] dbParameters)
{
if (inputParams == null)
{
inputParams = new Dictionary <string, StatementInputParam>()
{
};
}
foreach (var stat in inputParams.Values)
{
EntityMap entMap;
if (!config.EntityConfigs.TryGetValue(stat.Type, out entMap))
{
if (stat.ClrType == null)
{
stat.ClrType = Type.GetType(stat.Type);
}
entMap = new DynamicEntityMap(stat.ClrType);
}
else
{
stat.IsMapped = true;
stat.Type = entMap.FullName;
if (stat.Type == null)
{
stat.ClrType = Type.GetType(entMap.FullName);
}
}
stat.Map = entMap;
}
if (inputParams.Count == 1)
{
return(Parse(dialect, inputParams.Values.First().Map, text, inputParams.Values.First(), dbParameters));
}
text = ParseColumnTag(dialect, config, inputParams, text);
var statement = ParseObjectPropertyTag(dialect, config, inputParams, text);
ParseDbParameters(dialect, statement, dbParameters);
statement.Body = ParseEntityMapAllowedProperties(config, inputParams, statement.Body);
return(statement);
}
public DeleteSqlBuilder <T> Delete <T>(string tableName, T entity)
{
var entityMap = new DynamicEntityMap(tableName, tableName, typeof(T));
return(DeleteInternal(entityMap, entity));
}
public int Insert <T>(string tableName, T entity)
{
var entityMap = new DynamicEntityMap(tableName, tableName, typeof(T));
return(Insert(entityMap, entity));
}
/// <summary>
/// Runs the statement.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="session">The session.</param>
/// <param name="sql">The SQL.</param>
/// <param name="paramArray">The param array.</param>
/// <returns></returns>
public IList <T> RunList <T>(ISession session, string sql, TableQueryMap queryMap, params QueryParam[] paramArray)
{
Type instanceType = typeof(T);
//bool ownTransaction = false;
var dbConn = session.ConnectionManager.OpenConnection();
IList <T> list = new List <T>();
try
{
//if ((session.CurrentTransaction == null) || !session.CurrentTransaction.IsStarted)
//{
// ownTransaction = true;
// session.BeginTransaction();
//}
if (instanceType.IsPrimitive || typeof(string) == instanceType || typeof(Guid) == instanceType || typeof(DateTime) == instanceType || typeof(DateTimeOffset) == instanceType)
{
list = ExecuteReaderPrimitive <T>(dbConn, session, sql, paramArray);
}
else
{
MapConfig map = session.SessionFactory.DbSettings.Map;
EntityMap entMap;
ComplexType complexType;
if (map.EntityConfigs.TryGetValue(instanceType.FullName, out entMap))
{
if (queryMap == null)
{
int iteration = 0;
int recursion = 0;
queryMap = new TableQueryMap(entMap.TableName, ref recursion, ref iteration);
queryMap.Prefix = entMap.TableAlias;
}
list = ExecuteReader <T>(entMap, dbConn, session, sql, queryMap, paramArray);
}
else if (map.ComplexTypes.TryGetValue(instanceType.FullName, out complexType))
{
list = ExecuteReader <T>(complexType, dbConn, session, sql, queryMap, paramArray);
}
else
{
//Build a dynamic entity
DynamicEntityMap dynEntMap = new DynamicEntityMap(instanceType);
list = ExecuteReader <T>(dynEntMap, dbConn, session, sql, null, paramArray);
}
}
//if (ownTransaction)
// session.CommitTransaction();
return(list);
}
catch (GoliathDataException ex)
{
//if (ownTransaction)
// session.RollbackTransaction();
logger.Log(LogLevel.Debug, string.Format("Goliath Exception found {0} ", ex.Message));
throw;
}
catch (Exception ex)
{
//if (ownTransaction)
// session.RollbackTransaction();
throw new GoliathDataException(string.Format("Exception while running sql command: {0}", sql), ex);
}
}
/// <summary>
/// Runs the statement.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="session">The session.</param>
/// <param name="sql">The SQL.</param>
/// <param name="limit">The limit.</param>
/// <param name="offset">The offset.</param>
/// <param name="paramArray">The param array.</param>
/// <returns></returns>
/// <exception cref="GoliathDataException"></exception>
public IList <T> RunList <T>(ISession session, SqlQueryBody sql, int limit, int offset, params QueryParam[] paramArray)
{
Type instanceType = typeof(T);
//bool ownTransaction = false;
var dbConn = session.ConnectionManager.OpenConnection();
IList <T> list = new List <T>();
var dialect = session.SessionFactory.DbSettings.SqlDialect;
//var serializer = session.SessionFactory.DataSerializer;
try
{
//if ((session.CurrentTransaction == null) || !session.CurrentTransaction.IsStarted)
//{
// ownTransaction = true;
// session.BeginTransaction();
//}
if (instanceType.IsPrimitive || typeof(string) == instanceType || typeof(Guid) == instanceType || typeof(DateTime) == instanceType || typeof(DateTimeOffset) == instanceType)
{
list = ExecuteReaderPrimitive <T>(dbConn, session, sql.ToString(dialect, new PagingInfo()
{
Limit = limit, Offset = offset
}), paramArray);
}
else
{
MapConfig map = session.SessionFactory.DbSettings.Map;
EntityMap entMap;
ComplexType complexType;
if (map.EntityConfigs.TryGetValue(instanceType.FullName, out entMap))
{
list = ExecuteReader <T>(entMap, dbConn, session, sql, limit, offset, paramArray);
}
else if (map.ComplexTypes.TryGetValue(instanceType.FullName, out complexType))
{
list = ExecuteReader <T>(complexType, dbConn, session, sql, limit, offset, paramArray);
}
else
{
//Build a dynamic entity
DynamicEntityMap dynEntMap = new DynamicEntityMap(instanceType);
list = ExecuteReader <T>(dynEntMap, dbConn, session, sql, limit, offset, paramArray);
}
}
//if (ownTransaction)
// session.CommitTransaction();
return(list);
}
catch (GoliathDataException ex)
{
//if (ownTransaction)
// session.RollbackTransaction();
logger.Log(LogLevel.Debug, string.Format("Goliath Exception found {0} ", ex.Message));
throw;
}
catch (Exception ex)
{
//if (ownTransaction)
// session.RollbackTransaction();
throw new GoliathDataException(string.Format("Exception while running sql command: {0}", sql), ex);
}
}
