How to execute a sql string in the application layer

I have a very complex business logic,it’s sql string is

SELECT * FROM 
(SELECT OperatorID,Name,YEAR(OrderDate) AS ye,SUM(PayFee) AS scanCode FROM dbo.Operators JOIN   dbo.Orders ON   dbo.Operators.Id=dbo.Orders.OperatorID GROUP BY OperatorID,name,YEAR(OrderDate)
) AS a
JOIN (SELECT OperatorID,SUM(TheDayMoney)AS coinsCast,Year FROM dbo.DeviceCoinsRecords GROUP BY OperatorID,Year
)AS b ON a.OperatorID=b.OperatorID AND a.ye=b.Year WHERE b.Year=YEAR(GETDATE())

How can I do this?

[hikalkan]

Hi,

You don’t have to use repositories. Repository is not a good point for such a generic code. Define an interface like this, in your .Core module:

namespace Acme.PhoneBook.Data
{
    public interface ISqlExecuter
    {
        int Execute(string sql, params object[] parameters);
    }
}

Then implement it in your .EntityFramework module:

using Abp.Dependency;
using Abp.EntityFramework;
using Acme.PhoneBook.Data;

namespace Acme.PhoneBook.EntityFramework
{
    public class SqlExecuter : ISqlExecuter, ITransientDependency
    {
        private readonly IDbContextProvider<PhoneBookDbContext> _dbContextProvider;

        public SqlExecuter(IDbContextProvider<PhoneBookDbContext> dbContextProvider)
        {
            _dbContextProvider = dbContextProvider;
        }

        public int Execute(string sql, params object[] parameters)
        {
            return _dbContextProvider.GetDbContext().Database.ExecuteSqlCommand(sql, parameters);
        }
    }
}

Then you can inject ISqlExecuter anywhere you need. And you can use it like that:

public void ActivateAllUsers()
{
    _sqlExecuter.Execute("UPDATE AbpUsers SET IsActive = 1 WHERE TenantId = {0}", AbpSession.TenantId);
}

For the second question, if you use EF’s class, you need to reference to EF, no way. Why don’t you return list of entities if you need to run sql and get a list of entities.

[mikemey01]

@acjh @hikalkan thank you both for the help, I was able to get typed stored proc calls working. Here’s the code:

Interface (in domain project):

public interface IPMStoredProcedureRepository<TEntity, TPrimaryKey> : IRepository<TEntity, TPrimaryKey> where TEntity: class, IEntity<TPrimaryKey>
{
	List<TEntity> ExecuteSP(string query, params object[] parameters);
}

public interface IPMStoredProcedureRepository<TEntity> : IRepository<TEntity> where TEntity : class, IEntity<int>
{
	List<TEntity> ExecuteSP(string query, params object[] parameters);
}

Implementation (in EntityFramework project):

public class PMStoredProcedureRepository<TEntity> : MyRepositoryBase<TEntity, int>, IPMStoredProcedureRepository<TEntity> where TEntity : class, IEntity<int>
{
	public PMStoredProcedureRepository(IDbContextProvider<MyDbContext> dbContextProvider) : base(dbContextProvider)
	{
	}

	public List<TEntity> ExecuteSP(string query, params object[] parameters)
	{
		var type = Context.Set<TEntity>().FromSql(query, parameters).AsNoTracking().ToList<TEntity>();
		return type;
	}
}

Then you can inject the repository like any other in the application service layer, providing the type that the Stored Proc will return:

private readonly IPMStoredProcedureRepository<PMTestType> _storedProcRepository;
public AppService(IPMStoredProcedureRepository<PMTestType> storedProcRepository)
{
    _storedProcRepository = storedProcRepository;
}

Then to call the stored proc from the app service, you have to wrap it in a unit of work transaction, otherwise the datareader is not freed correctly:

public List<PMTestType> GetTestSP()
{
	using (var uow = UnitOfWorkManager.Begin())
	{
		var ret = _storedProcRepository.ExecuteSP("pme_TestProcedure @inputString", new SqlParameter("@inputString", "abcde"));
		uow.Complete();
		return ret;
	}
}

Hopefully that helps for anyone else that comes across this issue.