if (mssql)
{
    return mssqlQuery;
}
else
{
    return postgresQuery;
}

interface UserDao{
  User GetSomeUser();
}

class MssqlUserDao : UserDao {
  User GetSomeUser()
  {
     return new User ...(mssql.query("SELECT TOP 1..."));
  }
}
class PsqlUserDao : UserDao {
  User GetSomeUser()
  {
     return new User ...(psql.query("SELECT... LIMIT 1"));
  }
}

public class FooDto
{
    public  Id {get;}
    public  A {get;set;}
    public  B {get;set;}
}


public interface IFooRepository
{
     IEnumerable<FooDto>  GetItems( params );
     void UpdateItem(FooDto item);     
}

public MsSqlRepository : IFooRepository
{
    //... специфика работы с MsSql
}

public PostgresRepository : IFooRepository
{
    //... специфика работы с Postgres
}

public static Dependencies
{

    // делаешь любым удобным способом переключение с MsSql реализации на Postgres
    public static IFooRepository FooRepository =>  new MsSqlRepository(connectionString);
                                                   //new PostgresRepository(connectionString);
}

// далее работаешь с FooRepository через интерфейс
Dependencies.FooRepository.GetItems();

SELECT /*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) 
           USE_MERGE(j) FULL(j) */
    e1.first_name, e1.last_name, j.job_id, sum(e2.salary) total_sal
  FROM employees e1, employees e2, job_history j
  WHERE e1.employee_id = e2.manager_id
    AND e1.employee_id = j.employee_id
    AND e1.hire_date = j.start_date
  GROUP BY e1.first_name, e1.last_name, j.job_id
  ORDER BY total_sal;

O>SELECT /*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) 
O>           USE_MERGE(j) FULL(j) */
O>    e1.first_name, e1.last_name, j.job_id, sum(e2.salary) total_sal
O>  FROM employees e1, employees e2, job_history j
O>  WHERE e1.employee_id = e2.manager_id
O>    AND e1.employee_id = j.employee_id
O>    AND e1.hire_date = j.start_date
O>  GROUP BY e1.first_name, e1.last_name, j.job_id
O>  ORDER BY total_sal;
O>

using (var db = new DataConnection())
{
   db.StatementHints.Add(@"/*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) 
           USE_MERGE(j) FULL(j) */");

   var query = from e1 in db.GetTable<Employee>()
               from e2 in db.GetTable<Employee>().InnerJoin(e2 => e2.ManagerId == e1.EmployeeId)
               from j  in db.GetTable<JobHitory>().InnerJoin(j => j.EmployeeId == e1.EmployeeId && j.StartDate == e1.HireDate)
               group new {e1, e2} by new { e1.FirstName, e1.LastName, j.JobId } into g
               select new 
               {
                  g.Key.FirstName,    
                  g.Key.LastName,    
                  g.Key.JobId,
                  TotalSal = g.Sum(e => e.e2.Salary)
               };
    query = query.OrderBy(e => e. TotalSal);
    var result = query.ToList();
}

D>using (var db = new DataConnection())
D>{
D>   db.StatementHints.Add(@"/*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) 
D>           USE_MERGE(j) FULL(j) */");
D>}
D>

select schema.sequence.NEXTVAL from dual;

D>>using (var db = new DataConnection())
D>>{
D>>   db.StatementHints.Add(@"/*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) 
D>>           USE_MERGE(j) FULL(j) */");
D>>}
D>>

O>select schema.sequence.NEXTVAL from dual;
O>

static class Oracle
{
   [SqlExtension("{0}.{1}.NEXTVAL", ServerSideOnly = true)]
   public static long NextVal(string schema, string sequence)
   {
      throw new NotImplementedException();
   }
}


var nextValue = db.Select(() => Oracle.NextVal("schema", "sequence"));

SELECT *
FROM (    SELECT LEVEL n, TO_DATE ('31/12/2010', 'DD/MM/YYYY') + NUMTODSINTERVAL (LEVEL, 'day') CurrDate
          FROM DUAL
    CONNECT BY LEVEL <= 2000)

O>select schema.sequence.NEXTVAL from dual;
O>

public static IQueryable<EmpSalary> GetEmployeesSalary(this DataConnection db)
{
   var query = from e1 in db.GetTable<Employee>()
               from e2 in db.GetTable<Employee>().InnerJoin(e2 => e2.ManagerId == e1.EmployeeId)
               from j  in db.GetTable<JobHitory>().InnerJoin(j => j.EmployeeId == e1.EmployeeId && j.StartDate == e1.HireDate)
               group new {e1, e2} by new { e1.FirstName, e1.LastName, j.JobId } into g
               select new EmpSalary
               {
                  FirstName =g.Key.FirstName,    
                  LastName = g.Key.LastName,    
                  JobId = g.Key.JobId,
                  TotalSal = TotalSal = g.Sum(e => e.e2.Salary)
               };
    return query.OrderBy(e => e. TotalSal);
}

public IEnumerable<EmpSalary> GetEmployeesSalary()
{
   StatementHints.Add(@"/*+ LEADING(e2 e1) USE_NL(e1) INDEX(e1 emp_emp_id_pk) USE_MERGE(j) FULL(j) */");
   var query = QueryExtensions.GetEmployeesSalary(this); 
   return query.ToList(); // force hints application to avoid reusing the query in other statements
}

public interface IRepository
{
  Result Select();
}

public BaseRepository  : IRepository
{
    virtual Result Select();
}

public OracleRepository : BaseRepository
{
    override Result Select();
}

public MsSqlRepository : BaseRepository
{
    override Result Select();
}

Msql2000Repository : IRepository
{
}

S> вообще, link2db достаточно умный, чтобы автоматически порождать адекватные идиомы SQL. Скажем, поддержка иерархических запросов через CTE в нём есть.

create table Permissions
{
  TableName varchar(max),
  RowId int,
  UserId int not null foreign key Users(Id) on delete cascade,
  bit CanRead,
  bit CanUpdate
}

select * from Document

select Document.* from Document inner join Permissions on Document.Id = Permission.RowId and Permission.TableName = 'Document' and UserId = @CurrentUser
where Permissions.CanRead = 1

S>>select Document.* from Document inner join Permissions on Document.Id = Permission.RowId and Permission.TableName = 'Document' and UserId = @CurrentUser
S>>where Permissions.CanRead = 1
S>>

interface IPermissionAware
{
   int RowId { get; }
}

[Table("Document")]
class Document : IPermissionAware
{
   public int RowId { get; set; }   
   public bool IsDone { get; set; }   
   public bool IsApproved { get; set; }   
   ....
}

[Table("Order")]
class Order : IPermissionAware
{
   public int RowId { get; set; }   
   ....
}

public static class PermissionExtensions
{
   public static IQueryable<T> GetAllowed<T>(this IDataContext db)
     where T: IPermissionAware
   {
      var ed = db.MappingSchema.GetEntityDescriptor(typeof(T));
      var query = from t in db.GetTable<T>()
                  from p in db.GetTable<Permissions>().InnerJoin(p => p.TableName = ed.TableName && p.RowId == t.RowId)
                  select t;
      return query;
   }
}

using (var db = new DataConnection())
{
   // взять только количество
   var count = db.GetAllowed<Document>().Count();

   // отфильтровать еще раз и проставить значение
   db.GetAllowed<Document>()
     .Where(d => d.IsDone)
     .Set(d => d.Approved, true)
     .Update();

   // вставить в другую таблицу
   db.GetAllowed<Document>().Into(db.GetTable<ArchiveDocument>())

   // снести их с базы к черту
   db.GetAllowed<Document>().Delete();
}

public interface IDwarfFilter
{
    IQueryable<Dwarf> FilterByHeight(IQueryable<Dwarf> source, double height);
}

using (var tmp = db.CreateTempTable("#tmp", from t in Table ..... select new { ... })
{
    from t1 in db.MyTable
    join t2 in tmp on ....
}

using (var tmp = db.CreateTempTable("#tmp", myList)
{
    from t1 in db.MyTable
    join t2 in tmp on ....
}