public EntityChange(IEntityInfo entityInfo)
: this()
{
_entityInfo = entityInfo;
EntityName = entityInfo.GetNameInStore();
HasAutoIncrement = entityInfo.PrimaryKey.KeyScheme == KeyScheme.Identity;
}
public SolvableEntityConflict(IEntityInfo entityInfo, ISyncSessionInfo syncSessionInfo)
: this()
{
_entityInfo = entityInfo;
_syncSessionInfo = syncSessionInfo;
EntityName = entityInfo.GetNameInStore();
}
public IDbCommand ToUpdateCommand(IEntityInfo entity, object item)
{
const string sqlCommandText = "UPDATE [{0}] SET {1} WHERE {2}";
StringBuilder value = null;
StringBuilder where = null;
var @params = new List <IDataParameter>();
var sqlFactory = _datastore.SqlFactory;
foreach (var field in entity.Fields)
{
var fieldValue = field.ToSqlValue(item);
var paramName = sqlFactory.AddParam(fieldValue, @params);
if (field.IsPrimaryKey)
{
where = AddWhere(where, string.Format("{0} = {1}", field.FieldName, paramName));
continue;
}
value = AddValue(value, string.Format("{0} = {1}", field.FieldName, paramName));
}
var connection = _datastore.GetConnection();
var update = connection.CreateCommand();
update.CommandText = string.Format(sqlCommandText, entity.GetNameInStore(), value, where);
SetCommandParam(@params, update);
return(update);
}
private IDbCommand ToInsertCommand(IEntityInfo entity, object item)
{
const string sqlCommandText = "INSERT INTO [{0}] ({1}) VALUES ({2})";
StringBuilder key = null;
StringBuilder value = null;
var @params = new List <IDataParameter>();
var sqlFactory = _datastore.SqlFactory;
foreach (var field in entity.Fields)
{
if (field.IsPrimaryKey && ((PrimaryKey)field).KeyScheme == KeyScheme.Identity)
{
continue;
}
var fieldValue = field.ToSqlValue(item);
var paramName = sqlFactory.AddParam(fieldValue, @params);
key = AddValue(key, field.ToInsertStatement());
value = AddValue(value, paramName);
}
var connection = _datastore.GetWriteConnection();
var insert = connection.CreateCommand();
insert.CommandText = string.Format(sqlCommandText, entity.GetNameInStore(), key, value);
SetCommandParam(@params, insert);
return(insert);
}
public IDbCommand ToDeleteCommand(IEntityInfo entity, object item)
{
const string sqlCommandText = "DELETE FROM [{0}] WHERE {1}";
StringBuilder where = null;
var @params = new List <IDataParameter>();
var sqlFactory = _datastore.SqlFactory;
foreach (var field in entity.Fields)
{
var fieldValue = field.ToSqlValue(item);
var paramName = sqlFactory.AddParam(fieldValue, @params);
if (!field.IsPrimaryKey)
{
continue;
}
where = AddWhere(where, $"{field.FieldName} = {paramName}");
}
var connection = _datastore.GetWriteConnection();
var delete = connection.CreateCommand();
delete.CommandText = string.Format(sqlCommandText, entity.GetNameInStore(), where);
SetCommandParam(@params, delete);
return(delete);
}
public static EntityChangeset Create(ISqlDataStore dataStore, IEntityInfo syncEntity, ISyncSessionInfo syncSessionInfo)
{
var entityName = syncEntity.GetNameInStore();
var result = new EntityChangeset(entityName)
{
_syncSession = syncSessionInfo
};
result.SetDatastore(dataStore);
return(result);
}
public void ValidateTable(IEntityInfo entity)
{
var entityName = entity.GetNameInStore();
var connection = _datastore.GetConnection();
// first make sure the table exists
if (_datastore.TableExists(entityName))
{
return;
}
_datastore.CreateTable(connection, entity);
}
private void EnsureCompatibility(IDbConnection connection, IEntityInfo entity)
{
var tableName = entity.GetNameInStore();
if (!TableExists(tableName))
{
CreateTable(connection, entity);
}
else
{
ValidateTable(entity);
}
}
public Field(IEntityInfo entity, PropertyInfo prop, FieldAttribute fieldAttribute)
{
Entity = entity;
PropertyInfo = prop;
if (fieldAttribute != null)
{
RequireUniqueValue = fieldAttribute.RequireUniqueValue;
SearchOrder = fieldAttribute.SearchOrder;
FieldName = fieldAttribute.FieldName ?? prop.Name;
FullFieldName = string.Format("[{0}].[{1}]", Entity.GetNameInStore(), FieldName);
AliasFieldName = string.Format("{0}{1}", Entity.GetNameInStore(), FieldName);
IsCreationTracking = fieldAttribute.IsCreationTracking;
IsUpdateTracking = fieldAttribute.IsUpdateTracking;
IsDeletionTracking = fieldAttribute.IsDeletionTracking;
IsLastSyncTracking = fieldAttribute.IsLastSyncTracking;
}
if (prop != null)
{
FieldProperties = FieldPropertyFactory.Create(prop.PropertyType, fieldAttribute);
}
}
public IDbCommand FindExisting(ISqlDataStore dataStore, EntityChange entityChange)
{
const string sqlCommandText = "SELECT * FROM [{0}] WHERE {1}";
var @params = new List <IDataParameter>();
var sqlFactory = dataStore.SqlFactory;
var where = BuildWhereIdentity(entityChange, _entityInfo, sqlFactory, @params);
var select = sqlFactory.CreateCommand();
select.CommandText = string.Format(sqlCommandText, _entityInfo.GetNameInStore(), where);
SetCommandParam(@params, select);
return(select);
}
public string CreateTable(IEntityInfo entity)
{
var sql = new StringBuilder();
sql.AppendFormat("CREATE TABLE [{0}] (", entity.GetNameInStore());
var first = true;
foreach (var field in entity.Fields)
{
if (first)
{
first = false;
}
else
{
sql.Append(", ");
}
sql.AppendFormat(field.GetFieldDefinition());
}
foreach (var field in entity.Fields)
{
var constraint = field.GetFieldConstraint();
if (string.IsNullOrEmpty(constraint))
{
continue;
}
sql.AppendFormat(", {0}", constraint);
}
sql.Append(")");
OrmDebug.Info(sql.ToString());
return(sql.ToString());
}
private string BuildJoin()
{
return(string.Format("{0} [{1}]", _joinClause, _entityJoin.GetNameInStore()));
}
public void CreateTable(IDbConnection connection, IEntityInfo entity)
{
var sql = new StringBuilder();
var entityNameInStore = entity.GetNameInStore();
if (ReservedWords.Contains(entityNameInStore, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(entityNameInStore);
}
sql.AppendFormat("CREATE TABLE [{0}] (", entityNameInStore);
var first = true;
foreach (var field in entity.Fields)
{
if (ReservedWords.Contains(field.FieldName, StringComparer.InvariantCultureIgnoreCase))
{
throw new ReservedWordException(field.FieldName);
}
if (first)
{
first = false;
}
else
{
sql.Append(", ");
}
sql.AppendFormat(field.GetFieldDefinitionSqlQuery());
}
foreach (var foreignKey in entity.ForeignKeys)
{
sql.Append(", ");
sql.AppendFormat(foreignKey.GetTableCreateSqlQuery());
}
sql.Append(")");
OrmDebug.Info(sql.ToString());
using (var command = SqlFactory.CreateCommand())
{
command.CommandText = sql.ToString();
command.Connection = connection;
command.Transaction = CurrentTransaction;
command.ExecuteNonQuery();
}
VerifiyPrimaryKey(entity.PrimaryKey);
foreach (var foreignKey in entity.ForeignKeys)
{
VerifyForeignKey(foreignKey);
}
foreach (var index in entity.Indexes)
{
VerifyIndex(index);
}
}
public void ValidateTable(IEntityInfo entity)
{
var entityName = entity.GetNameInStore();
var connection = _datastore.GetConnection();
// first make sure the table exists
if (!_datastore.TableExists(entityName))
{
_datastore.CreateTable(connection, entity);
return;
}
using (var command = new SqlCeCommand())
{
command.Transaction = _datastore.CurrentTransaction as SqlCeTransaction;
command.Connection = connection as SqlCeConnection;
foreach (var field in entity.Fields)
{
// yes, I realize hard-coded ordinals are not a good practice, but the SQL isn't changing, it's method specific
var sql = string.Format("SELECT column_name, " // 0
+ "data_type, " // 1
+ "character_maximum_length, " // 2
+ "numeric_precision, " // 3
+ "numeric_scale, " // 4
+ "is_nullable "
+ "FROM information_schema.columns "
+ "WHERE (table_name = '{0}' AND column_name = '{1}')",
entityName, field.FieldName);
command.CommandText = sql;
using (var reader = command.ExecuteReader())
{
if (!reader.Read())
{
// field doesn't exist - we must create it
var alter = new StringBuilder(string.Format("ALTER TABLE [{0}] ", entity.GetNameInStore()));
alter.Append(string.Format("ADD {0}", field.GetFieldDefinitionSqlQuery()));
using (var altercmd = new SqlCeCommand(alter.ToString(), connection as SqlCeConnection))
{
altercmd.ExecuteNonQuery();
}
}
}
}
_datastore.VerifiyPrimaryKey(entity.PrimaryKey);
foreach (var foreignKey in entity.ForeignKeys)
{
_datastore.VerifyForeignKey(foreignKey);
}
foreach (var index in entity.Indexes)
{
_datastore.VerifyIndex(index);
}
}
}
/// <summary>
/// Get entity name in store
/// </summary>
public string GetNameInStore()
{
return(_syncEntity.GetNameInStore());
}
/// <summary>
/// Convert part to sql string equivalent
/// </summary>
/// <param name="params">existing param list to populate in case of part object value</param>
/// <returns>Sql string representation</returns>
public string ToStatement(List <IDataParameter> @params)
{
return(string.Concat("[", _entity.GetNameInStore(), "]", ".", "[", _columnName, "]"));
}
private string BuildJoin()
{
return($"{_joinClause} [{_entityJoin.GetNameInStore()}]");
}
