private void DeleteQuotaRow(TenantQuotaRow row)
{
var d = new SqlDelete(DbQuotaService.tenants_quotarow).Where("tenant", row.Tenant).Where("path", row.Path);
using var dbManager = new DbManager("core");
dbManager.ExecuteNonQuery(d);
}
public void SetState(int id, MailSendingState result)
{
using var scope = ServiceProvider.CreateScope();
using var db = scope.ServiceProvider.GetService <DbOptionsManager>().Get(dbid);
using var tx = db.BeginTransaction();
if (result == MailSendingState.Sended)
{
var d = new SqlDelete("notify_info").Where("notify_id", id);
db.ExecuteNonQuery(d);
}
else
{
if (result == MailSendingState.Error)
{
var q = new SqlQuery("notify_info").Select("attempts").Where("notify_id", id);
var attempts = db.ExecuteScalar <int>(q);
if (NotifyServiceCfg.Process.MaxAttempts <= attempts + 1)
{
result = MailSendingState.FatalError;
}
}
var u = new SqlUpdate("notify_info")
.Set("state", (int)result)
.Set("attempts = attempts + 1")
.Set("modify_date", DateTime.UtcNow)
.Where("notify_id", id);
db.ExecuteNonQuery(u);
}
tx.Commit();
}
public void Where(SqlDelete sql, T item)
{
IEnumerable <KeyValuePair <DbColumnAttribute, PropertyInfo> > keyed =
_mappedColumn.Where(x => x.Key.IsKey || x.Key.IsIdentity);
InvokeAction(keyed, (name, value) => sql.Where(name, value), item);
}
public void DeleteMailbox(int mailbox_id, DbManager db)
{
if (mailbox_id < 0)
{
throw new ArgumentException("Argument mailbox_id less then zero.", "mailbox_id");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
var mailbox_manager = GetMailboxManager();
var mailbox = mailbox_manager.GetServerMailBox(tenant_id, mailbox_id, db);
if (mailbox != null)
{
if (!mailbox.IsTeamlab)
{
throw new ArgumentException("Mailbox is not teamlab and it can't be deleted.");
}
var quota_size_for_clean = mailbox_manager.RemoveMailBox(mailbox, db);
//TODO: Maybe cleaning of quota need to move into RemoveMailBox?
mailbox_manager.QuotaUsedDelete(mailbox.TenantId, quota_size_for_clean);
}
var delete_addresses_query = new SqlDelete(AddressTable.name)
.Where(AddressTable.Columns.id_mailbox, mailbox_id);
db.ExecuteNonQuery(delete_addresses_query);
}
private void DeleteQuotaRow(TenantQuotaRow row)
{
var d = new SqlDelete(DbQuotaService.tenants_quotarow).Where("tenant", row.Tenant).Where("path", row.Path);
var dbManager = DbOptionsManager.Value;
dbManager.ExecuteNonQuery(d);
}
private void GetOldEvents(string table, string settings)
{
var sqlQueryLimit = string.Format("(IFNULL((SELECT JSON_EXTRACT(`Data`, '$.{0}') from webstudio_settings where tt.id = TenantID and id='{1}'), {2})) as tout", settings, TenantAuditSettings.Guid, TenantAuditSettings.MaxLifeTime);
var query = new SqlQuery(table + " t1")
.Select("t1.id")
.Select(sqlQueryLimit)
.Select("t1.`date` AS dout")
.InnerJoin("tenants_tenants tt", Exp.EqColumns("tt.id", "t1.tenant_id"))
.Having(Exp.Sql("dout < ADDDATE(UTC_DATE(), INTERVAL -tout DAY)"))
.SetMaxResults(1000);
List <int> ids;
do
{
using var scope = ServiceProvider.CreateScope();
var dbManager = scope.ServiceProvider.GetService <DbOptionsManager>().Get("messages");
ids = dbManager.ExecuteList(query).ConvertAll(r => Convert.ToInt32(r[0]));
if (!ids.Any())
{
return;
}
var deleteQuery = new SqlDelete(table).Where(Exp.In("id", ids));
dbManager.ExecuteNonQuery(deleteQuery);
} while (ids.Any());
}
public void DeleteMailContacts(int tenant, string user, List <int> ids)
{
if (!ids.Any())
{
throw new ArgumentNullException("ids");
}
using (var db = GetDb())
{
using (var tx = db.BeginTransaction())
{
var deleteContactInfo = new SqlDelete(ContactInfoTable.Name)
.Where(Exp.In(ContactInfoTable.Columns.ContactId, ids))
.Where(GetUserWhere(user, tenant));
db.ExecuteNonQuery(deleteContactInfo);
var deleteContact = new SqlDelete(ContactsTable.Name)
.Where(Exp.In(ContactsTable.Columns.Id, ids))
.Where(GetUserWhere(user, tenant));
db.ExecuteNonQuery(deleteContact);
tx.Commit();
}
}
}
public virtual void RemoveProviderInfo(int linkId)
{
using (var db = GetDb())
using (var tx = db.BeginTransaction())
{
var folderId = GetProviderInfo(linkId).RootFolderId.ToString();
var entryIDs = db.ExecuteList(new SqlQuery("files_thirdparty_id_mapping")
.Select("hash_id")
.Where(Exp.Eq("tenant_id", TenantID) &
Exp.Like("id", folderId, SqlLike.StartWith)))
.ConvertAll(x => x[0]);
db.ExecuteNonQuery(new SqlDelete("files_security")
.Where(
Exp.Eq("tenant_id", TenantID) &
Exp.In("entry_id", entryIDs)));
var sqlQuery = new SqlDelete("files_tag_link")
.Where(Exp.Eq("tenant_id", TenantID) & Exp.In("entry_id", entryIDs));
db.ExecuteNonQuery(sqlQuery);
sqlQuery = new SqlDelete(TableTitle)
.Where("id", linkId)
.Where("tenant_id", TenantID);
db.ExecuteNonQuery(sqlQuery);
tx.Commit();
}
}
public void CleanupMailboxData(MailBoxData mailbox, bool totalRemove)
{
if (!mailbox.IsRemoved)
{
throw new Exception("Mailbox is not removed.");
}
var deleteMailboxMessagesQuery = new SqlDelete(MailTable.TABLE_NAME)
.Where(MailTable.Columns.MailboxId, mailbox.MailBoxId)
.Where(MailTable.Columns.Tenant, mailbox.TenantId)
.Where(MailTable.Columns.User, mailbox.UserId);
var deleteMailboxAttachmentsQuery = new SqlDelete(AttachmentTable.TABLE_NAME)
.Where(AttachmentTable.Columns.MailboxId, mailbox.MailBoxId)
.Where(AttachmentTable.Columns.Tenant, mailbox.TenantId);
using (var db = GetDb())
{
using (var tx = db.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var daoFactory = new DaoFactory(db);
var daoMailbox = daoFactory.CreateMailboxDao();
var mb = daoMailbox.GetMailBox(
new СoncreteUserMailboxExp(mailbox.MailBoxId, mailbox.TenantId, mailbox.UserId, true));
db.ExecuteNonQuery(deleteMailboxAttachmentsQuery);
db.ExecuteNonQuery(deleteMailboxMessagesQuery);
daoFactory.CreateMailboxDao().RemoveMailbox(mb);
if (totalRemove)
{
daoFactory.CreateFolderDao(mailbox.TenantId, mailbox.UserId).Delete();
var deleteContactInfoQuery = new SqlDelete(ContactInfoTable.TABLE_NAME)
.Where(ContactInfoTable.Columns.User, mailbox.UserId)
.Where(ContactInfoTable.Columns.Tenant, mailbox.TenantId);
db.ExecuteNonQuery(deleteContactInfoQuery);
var deleteContactsQuery = new SqlDelete(ContactsTable.TABLE_NAME)
.Where(ContactsTable.Columns.User, mailbox.UserId)
.Where(ContactsTable.Columns.Tenant, mailbox.TenantId);
db.ExecuteNonQuery(deleteContactsQuery);
var deleteDisplayImagesQuery = new SqlDelete(DisplayImagesTable.TABLE_NAME)
.Where(DisplayImagesTable.Columns.User, mailbox.UserId)
.Where(DisplayImagesTable.Columns.Tenant, mailbox.TenantId);
db.ExecuteNonQuery(deleteDisplayImagesQuery);
}
tx.Commit();
}
}
}
private static void GetOldEvents(string table, string settings)
{
var sqlQueryLimit = string.Format("(IFNULL((SELECT JSON_EXTRACT(`Data`, '$.{0}') from webstudio_settings where tt.id = TenantID and id='{1}'), {2})) as tout", settings, TenantAuditSettings.LoadForDefaultTenant().ID, TenantAuditSettings.MaxLifeTime);
var query = new SqlQuery(table + " t1")
.Select("t1.id")
.Select(sqlQueryLimit)
.Select("t1.`date` AS dout")
.InnerJoin("tenants_tenants tt", Exp.EqColumns("tt.id", "t1.tenant_id"))
.Having(Exp.Sql("dout < ADDDATE(UTC_DATE(), INTERVAL -tout DAY)"))
.SetMaxResults(1000);
List <int> ids;
do
{
using (var dbManager = DbManager.FromHttpContext(MessagesDbId, 180000))
{
ids = dbManager.ExecuteList(query).ConvertAll(r => Convert.ToInt32(r[0]));
if (!ids.Any())
{
return;
}
var deleteQuery = new SqlDelete(table).Where(Exp.In("id", ids));
dbManager.ExecuteNonQuery(deleteQuery);
}
} while (ids.Any());
}
public int DelteServer(int id)
{
var query = new SqlDelete(MailboxServerTable.TABLE_NAME)
.Where(MailboxServerTable.Columns.Id, id);
return(Db.ExecuteNonQuery(query));
}
public void DeleteAddressFromMailGroup(int groupId, int addressId, DbManager db)
{
if (groupId < 0)
{
throw new ArgumentException("Argument group_id less then zero.", "groupId");
}
if (addressId < 0)
{
throw new ArgumentException("Argument address_id less then zero.", "addressId");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
var deleteAddressFromMailgroupQuery = new SqlDelete(MailGroupXAddressesTable.name)
.Where(MailGroupXAddressesTable.Columns.id_address, addressId)
.Where(MailGroupXAddressesTable.Columns.id_mail_group, groupId);
var deletedRowsCount = db.ExecuteNonQuery(deleteAddressFromMailgroupQuery);
if (deletedRowsCount > 1)
{
throw new InvalidOperationException(String.Format("Problem deleting address. GroupId: {0}, AddressId: {1}", groupId, addressId));
}
}
protected void SetRelative(int[] contactID, EntityType entityType, int entityID)
{
if (entityID == 0)
throw new ArgumentException();
using (var tx = Db.BeginTransaction())
{
var sqlQuery = new SqlQuery("crm_entity_contact")
.Select("contact_id")
.Where(Exp.Eq("entity_type", entityType) & Exp.Eq("entity_id", entityID));
var exists = Db.ExecuteList(sqlQuery).Select(row => Convert.ToInt32(row[0])).ToList();
foreach (var existContact in exists)
{
var sqlDelete = new SqlDelete("crm_entity_contact").Where(Exp.Eq("entity_type", entityType) & Exp.Eq("entity_id", entityID) & Exp.Eq("contact_id", existContact));
Db.ExecuteNonQuery(sqlDelete);
}
if (!(contactID == null || contactID.Length == 0))
foreach (var id in contactID)
SetRelative(id, entityType, entityID);
tx.Commit();
}
}
public void SetShare(FileShareRecord r)
{
using (var DbManager = GetDb())
{
if (r.Share == FileShare.None)
{
using (var tx = DbManager.BeginTransaction())
{
var files = new List <object>();
if (r.EntryType == FileEntryType.Folder)
{
var folders =
DbManager.ExecuteList(new SqlQuery("files_folder_tree").Select("folder_id").Where("parent_id", r.EntryId))
.ConvertAll(o => (int)o[0]);
files.AddRange(DbManager.ExecuteList(Query("files_file").Select("id").Where(Exp.In("folder_id", folders))).
ConvertAll(o => o[0]));
var d1 = new SqlDelete("files_security")
.Where("tenant_id", r.Tenant)
.Where(Exp.In("entry_id", folders))
.Where("entry_type", (int)FileEntryType.Folder)
.Where("subject", r.Subject.ToString());
DbManager.ExecuteNonQuery(d1);
}
else
{
files.Add(r.EntryId);
}
if (0 < files.Count)
{
var d2 = new SqlDelete("files_security")
.Where("tenant_id", r.Tenant)
.Where(Exp.In("entry_id", files))
.Where("entry_type", (int)FileEntryType.File)
.Where("subject", r.Subject.ToString());
DbManager.ExecuteNonQuery(d2);
}
tx.Commit();
}
}
else
{
var i = new SqlInsert("files_security", true)
.InColumnValue("tenant_id", r.Tenant)
.InColumnValue("entry_id", r.EntryId)
.InColumnValue("entry_type", (int)r.EntryType)
.InColumnValue("subject", r.Subject.ToString())
.InColumnValue("owner", r.Owner.ToString())
.InColumnValue("security", (int)r.Share)
.InColumnValue("timestamp", DateTime.UtcNow);
DbManager.ExecuteNonQuery(i);
}
}
}
public void DeleteAddressesFromMailGroup(int groupId)
{
var query = new SqlDelete(ServerMailGroupXAddressesTable.TABLE_NAME)
.Where(ServerMailGroupXAddressesTable.Columns.MailGroupId, groupId);
Db.ExecuteNonQuery(query);
}
public void DeleteAddressesFromAnyMailGroup(List <int> addressIds)
{
var query = new SqlDelete(ServerMailGroupXAddressesTable.TABLE_NAME)
.Where(Exp.In(ServerMailGroupXAddressesTable.Columns.AddressId, addressIds));
Db.ExecuteNonQuery(query);
}
public void SetState(int id, MailSendingState result)
{
using (var db = GetDb())
using (var tx = db.BeginTransaction())
{
if (result == MailSendingState.Sended)
{
var d = new SqlDelete("notify_info").Where("notify_id", id);
db.ExecuteNonQuery(d);
}
else
{
if (result == MailSendingState.Error)
{
var q = new SqlQuery("notify_info").Select("attempts").Where("notify_id", id);
var attempts = db.ExecuteScalar <int>(q);
if (NotifyServiceCfg.MaxAttempts <= attempts + 1)
{
result = MailSendingState.FatalError;
}
}
var u = new SqlUpdate("notify_info")
.Set("state", (int)result)
.Set("attempts = attempts + 1")
.Set("modify_date", DateTime.UtcNow)
.Where("notify_id", id);
db.ExecuteNonQuery(u);
}
tx.Commit();
}
}
public void DeleteMailbox(int mailboxId, DbManager db)
{
if (mailboxId < 0)
{
throw new ArgumentException("Argument mailbox_id less then zero.", "mailboxId");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
var mailboxManager = GetMailboxManager();
var mailbox = mailboxManager.GetServerMailBox(tenant, mailboxId, db);
if (mailbox != null)
{
if (!mailbox.IsTeamlab)
{
throw new ArgumentException("Mailbox is not teamlab and it can't be deleted.");
}
mailboxManager.RemoveMailBox(db, mailbox, false);
}
var deleteAddressesQuery = new SqlDelete(AddressTable.Name)
.Where(AddressTable.Columns.MailboxId, mailboxId);
db.ExecuteNonQuery(deleteAddressesQuery);
}
protected void SetRelative(int[] contactID, EntityType entityType, int entityID)
{
using (var tx = DbManager.BeginTransaction())
{
var sqlDelete = new SqlDelete("crm_entity_contact");
if (entityID == 0)
{
throw new ArgumentException();
}
sqlDelete.Where(Exp.Eq("entity_type", entityType) & Exp.Eq("entity_id", entityID));
DbManager.ExecuteNonQuery(sqlDelete);
if (!(contactID == null || contactID.Length == 0))
{
foreach (var id in contactID)
{
SetRelative(id, entityType, entityID);
}
}
tx.Commit();
}
}
public void DeleteConflicting(Connection conn)
{
SqlDelete delete = new SqlDelete(Name);
AddFields(delete, CommonFields);
conn.Execute(delete);
}
public void DeleteTagFromEntity(EntityType entityType, int entityID, String tagName)
{
using (var db = GetDb())
{
var tagID = db.ExecuteScalar <int>(Query("crm_tag").Select("id")
.Where(Exp.Eq("lower(title)", tagName.ToLower()) & Exp.Eq("entity_type", (int)entityType)));
if (tagID == 0)
{
return;
}
var sqlQuery = new SqlDelete("crm_entity_tag")
.Where(Exp.Eq("entity_type", (int)entityType) & Exp.Eq("tag_id", tagID));
if (entityID > 0)
{
sqlQuery.Where(Exp.Eq("entity_id", entityID));
}
db.ExecuteNonQuery(sqlQuery);
if (entityID == 0)
{
db.ExecuteNonQuery(Delete("crm_tag")
.Where(Exp.Eq("id", tagID) & Exp.Eq("entity_type", (int)entityType)));
}
}
}
public void DeleteDomain(int domainId, DbManager db)
{
if (domainId < 0)
{
throw new ArgumentException("Argument domain_id less then zero.", "domainId");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
const string group_alias = "msg";
const string address_alias = "msa";
var groupQuery = new SqlQuery(MailGroupTable.Name.Alias(group_alias))
.InnerJoin(AddressTable.Name.Alias(address_alias),
Exp.EqColumns(MailGroupTable.Columns.AddressId.Prefix(group_alias),
AddressTable.Columns.Id.Prefix(address_alias)
)
)
.Select(MailGroupTable.Columns.Id.Prefix(group_alias))
.Where(AddressTable.Columns.Tenant.Prefix(address_alias), tenant)
.Where(AddressTable.Columns.DomainId.Prefix(address_alias), domainId)
.Where(AddressTable.Columns.IsMailGroup.Prefix(address_alias), true);
var mailboxQuery = new SqlQuery(AddressTable.Name)
.Select(AddressTable.Columns.MailboxId)
.Where(AddressTable.Columns.Tenant, tenant)
.Where(AddressTable.Columns.DomainId, domainId)
.Where(AddressTable.Columns.IsMailGroup, false)
.Where(AddressTable.Columns.IsAlias, false);
var deleteWebDomainQuery = new SqlDelete(DomainTable.Name)
.Where(DomainTable.Columns.Tenant, tenant)
.Where(DomainTable.Columns.Id, domainId);
var result = db.ExecuteList(groupQuery);
var groupIds = result.Select(r => (int)r[0]).ToList();
var groupDal = new MailGroupDal(tenant);
foreach (var groupId in groupIds)
{
groupDal.DeleteMailGroup(groupId, db);
}
result = db.ExecuteList(mailboxQuery);
var mailboxIds = result.Select(r => (int)r[0]).ToList();
var mailboxDal = new MailboxDal(tenant);
foreach (var mailboxId in mailboxIds)
{
mailboxDal.DeleteMailbox(mailboxId, db);
}
db.ExecuteNonQuery(deleteWebDomainQuery);
}
public void DeleteDomain(int domain_id, DbManager db)
{
if (domain_id < 0)
{
throw new ArgumentException("Argument domain_id less then zero.", "domain_id");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
const string group_alias = "msg";
const string address_alias = "msa";
var group_query = new SqlQuery(MailGroupTable.name + " " + group_alias)
.InnerJoin(AddressTable.name + " " + address_alias,
Exp.EqColumns(MailGroupTable.Columns.id_address.Prefix(group_alias),
AddressTable.Columns.id.Prefix(address_alias)
)
)
.Select(MailGroupTable.Columns.id.Prefix(group_alias))
.Where(AddressTable.Columns.tenant.Prefix(address_alias), tenant_id)
.Where(AddressTable.Columns.id_domain.Prefix(address_alias), domain_id)
.Where(AddressTable.Columns.is_mail_group.Prefix(address_alias), true);
var mailbox_query = new SqlQuery(AddressTable.name)
.Select(AddressTable.Columns.id_mailbox)
.Where(AddressTable.Columns.tenant, tenant_id)
.Where(AddressTable.Columns.id_domain, domain_id)
.Where(AddressTable.Columns.is_mail_group, false)
.Where(AddressTable.Columns.is_alias, false);
var delete_web_domain_query = new SqlDelete(DomainTable.name)
.Where(DomainTable.Columns.tenant, tenant_id)
.Where(DomainTable.Columns.id, domain_id);
var result = db.ExecuteList(group_query);
var group_ids = result.Select(r => (int)r[0]).ToList();
var group_dal = new MailGroupDal(tenant_id);
foreach (var group_id in group_ids)
{
group_dal.DeleteMailGroup(group_id, db);
}
result = db.ExecuteList(mailbox_query);
var mailbox_ids = result.Select(r => (int)r[0]).ToList();
var mailbox_dal = new MailboxDal(tenant_id);
foreach (var mailbox_id in mailbox_ids)
{
mailbox_dal.DeleteMailbox(mailbox_id, db);
}
db.ExecuteNonQuery(delete_web_domain_query);
}
private bool disableAlias; //禁用别名开关。
internal override SqlStatement VisitDelete(SqlDelete sd)
{
disableAlias = true;
var result = base.VisitDelete(sd);
disableAlias = false;
return(result);
}
public virtual void RemoveProviderInfo(int linkId)
{
var queryDelete = new SqlDelete(TableTitle)
.Where("id", linkId)
.Where("tenant_id", TenantID);
DbManager.ExecuteNonQuery(queryDelete);
}
public void DeleteGuid(Connection conn, Guid guid, string what)
{
SqlDelete delete = new SqlDelete(EPortGuidName);
delete.AddString("F_GUID", guid.ToString());
conn.Execute(delete);
LogText(String.Format("SqlDelete{0}", what), guid);
}
public void DeleteSignature(int id_mailbox, int tenant)
{
var delete_signature_query = new SqlDelete(SignatureTable.name)
.Where(SignatureTable.Columns.id_mailbox, id_mailbox)
.Where(SignatureTable.Columns.id_tenant, tenant);
_manager.ExecuteNonQuery(delete_signature_query);
}
public int DeleteAutoreply(int mailboxId)
{
var query = new SqlDelete(MailboxAutoreplyTable.TABLE_NAME)
.Where(MailboxAutoreplyTable.Columns.MailboxId, mailboxId)
.Where(MailboxAutoreplyTable.Columns.Tenant, Tenant);
return(Db.ExecuteNonQuery(query));
}
public int Delete()
{
var query = new SqlDelete(FolderCountersTable.TABLE_NAME)
.Where(MailTable.Columns.Tenant, Tenant)
.Where(MailTable.Columns.User, CurrentUserId);
return(Db.ExecuteNonQuery(query));
}
public void DeleteSignature(int mailboxId, int tenant)
{
var deleteSignatureQuery = new SqlDelete(SignatureTable.Name)
.Where(SignatureTable.Columns.MailboxId, mailboxId)
.Where(SignatureTable.Columns.Tenant, tenant);
_manager.ExecuteNonQuery(deleteSignatureQuery);
}
public void Accept_WithoutFrom_VisitsEverything()
{
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var mock = fixture.Freeze<Mock<SqlVisitor>>();
var query = new SqlDelete();
query.Accept(mock.Object);
mock.Verify(_ => _.Visit(It.IsAny<SqlDelete>()), Times.Once);
mock.Verify(_ => _.Visit(It.IsAny<SqlFrom>()), Times.Never);
mock.Verify(_ => _.Visit(It.IsAny<SqlWhere>()), Times.Never);
}
internal override SqlStatement VisitDelete(SqlDelete sd) {
return new SqlDelete((SqlSelect)this.Visit(sd.Select), sd.SourceExpression);
}
internal override SqlStatement VisitDelete(SqlDelete sd) {
Scope save = this.CurrentScope;
this.CurrentScope = new Scope(sd, this.CurrentScope.ContainingScope);
base.VisitDelete(sd);
this.CurrentScope = save;
return sd;
}
internal override SqlStatement VisitDelete(SqlDelete sd) {
bool saveTop = this.topLevel;
this.topLevel = false;
base.VisitDelete(sd);
this.topLevel = saveTop;
return sd;
}
internal virtual SqlStatement VisitDelete(SqlDelete delete) {
delete.Select = this.VisitSequence(delete.Select);
return delete;
}
private SqlStatement VisitDelete(Expression item, LambdaExpression check) {
if (item == null) {
throw Error.ArgumentNull("item");
}
bool saveAllowDeferred = this.allowDeferred;
this.allowDeferred = false;
try {
MetaTable metaTable = this.services.Model.GetTable(item.Type);
Expression source = this.services.Context.GetTable(metaTable.RowType.Type).Expression;
Type rowType = metaTable.RowType.Type;
// construct identity predicate based on supplied item
ParameterExpression p = Expression.Parameter(rowType, "p");
LambdaExpression idPredicate = Expression.Lambda(Expression.Equal(p, item), p);
// combine predicate and check expression into single find predicate
LambdaExpression findPredicate = idPredicate;
if (check != null) {
findPredicate = Expression.Lambda(Expression.And(Expression.Invoke(findPredicate, p), Expression.Invoke(check, p)), p);
}
Expression seq = Expression.Call(typeof(Enumerable), "Where", new Type[] { rowType }, source, findPredicate);
SqlSelect ss = new RetypeCheckClause().VisitSelect(this.VisitSequence(seq));
this.allowDeferred = saveAllowDeferred;
SqlDelete sd = new SqlDelete(ss, source);
return sd;
}
finally {
this.allowDeferred = saveAllowDeferred;
}
}
protected override SqlExpression VisitDelete(SqlDelete expr)
{
return expr;
}
/// <summary>
/// Visits the specified <see cref="SqlDelete"/>.
/// </summary>
/// <param name="expression">
/// The expression to visit.
/// </param>
public virtual void Visit(SqlDelete expression)
{
}
public void ExpressionType_ReturnsDelete()
{
var query = new SqlDelete();
Assert.Equal(SqlExpressionType.Delete, query.ExpressionType);
}
internal override SqlStatement VisitDelete(SqlDelete sd) {
sb.Append("DELETE FROM ");
this.suppressedAliases.Add(sd.Select.From);
this.Visit(sd.Select.From);
if (sd.Select.Where != null) {
sb.Append(" WHERE ");
this.Visit(sd.Select.Where);
}
this.suppressedAliases.Remove(sd.Select.From);
return sd;
}
protected virtual SqlExpression VisitDelete(SqlDelete expr)
{
return expr;
}
