C# 类型系统上实现一个 SQL 查询引擎原型

// 1. 实体类（用户定义）
public class User 
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}
// 2. 查询入口：DbSet<T>
var users = new DbSet<User>("users");
// 3. LINQ 风格链式调用
var query = users
    .Where(u => u.Age > 18)
    .OrderBy(u => u.Name)
    .Select(u => new { u.Id, u.Name })
    .Take(10);
// 4. 生成 SQL
string sql = query.ToSql();
// 输出: SELECT Id, Name FROM users WHERE Age > 18 ORDER BY Name LIMIT 10

public class DbSet<T>
{
    private readonly string _tableName;
    public DbSet(string tableName) => _tableName = tableName;
    public Query<T> Where(Expression<Func<T, bool>> predicate)
        => new Query<T>(_tableName).Where(predicate);
    // 其他方法委托给 Query<T>
}

public class Query<T>
{
    public string TableName { get; }
    public Expression? WhereClause { get; private set; }
    public LambdaExpression? OrderByClause { get; private set; }
    public LambdaExpression? SelectClause { get; private set; }
    public int? Limit { get; private set; }
    internal Query(string tableName) => TableName = tableName;
    public Query<T> Where(Expression<Func<T, bool>> predicate)
    {
        WhereClause = predicate;
        return this;
    }
    public Query<T> OrderBy<TKey>(Expression<Func<T, TKey>> keySelector)
    {
        OrderByClause = keySelector;
        return this;
    }
    public Query<TResult> Select<TResult>(Expression<Func<T, TResult>> selector)
    {
        return new Query<TResult>(TableName)
        {
            WhereClause = WhereClause,
            OrderByClause = OrderByClause,
            SelectClause = selector,
            Limit = Limit
        };
    }
    public Query<T> Take(int count)
    {
        Limit = count;
        return this;
    }
    public string ToSql()
    {
        return SqlTranslator.Translate(this);
    }
}

public static class SqlTranslator
{
    public static string Translate<T>(Query<T> query)
    {
        var select = BuildSelect(query.SelectClause ?? GetDefaultSelect<T>());
        var from = $"FROM {query.TableName}";
        var where = query.WhereClause != null ? $"WHERE {Visit(query.WhereClause.Body)}" : "";
        var orderBy = query.OrderByClause != null ? $"ORDER BY {GetMemberName(query.OrderByClause.Body)}" : "";
        var limit = query.Limit.HasValue ? $"LIMIT {query.Limit}" : "";
        return $"{select} {from} {where} {orderBy} {limit}".Replace("  ", " ").Trim();
    }
    private static string BuildSelect(LambdaExpression selector)
    {
        if (selector.Body is MemberInitExpression init)
        {
            var members = init.Bindings.OfType<MemberAssignment>()
                .Select(b => b.Member.Name);
            return "SELECT " + string.Join(", ", members);
        }
        else if (selector.Body is ParameterExpression)
        {
            // SELECT * 情况
            return "SELECT *";
        }
        else if (selector.Body is MemberExpression member)
        {
            return $"SELECT {member.Member.Name}";
        }
        throw new NotSupportedException("Unsupported select expression");
    }
    private static string Visit(Expression expr)
    {
        return expr switch
        {
            BinaryExpression bin => VisitBinary(bin),
            MemberExpression mem => mem.Member.Name,
            ConstantExpression con => FormatValue(con.Value),
            MethodCallExpression call => throw new NotSupportedException("Method calls not supported"),
            _ => throw new NotSupportedException($"Expression {expr.NodeType} not supported")
        };
    }
    private static string VisitBinary(BinaryExpression bin)
    {
        var left = Visit(bin.Left);
        var right = Visit(bin.Right);
        var op = bin.NodeType switch
        {
            ExpressionType.Equal => "=",
            ExpressionType.GreaterThan => ">",
            ExpressionType.LessThan => "<",
            ExpressionType.AndAlso => "AND",
            ExpressionType.OrElse => "OR",
            _ => throw new NotSupportedException($"Operator {bin.NodeType} not supported")
        };
        return $"({left} {op} {right})";
    }
    private static string FormatValue(object? value)
    {
        return value switch
        {
            null => "NULL",
            string s => $"'{s.Replace("'", "''")}'", // 简单转义
            bool b => b ? "1" : "0",
            _ => value.ToString()!
        };
    }
    private static string GetMemberName(Expression expr)
    {
        return expr switch
        {
            MemberExpression m => m.Member.Name,
            UnaryExpression u when u.NodeType == ExpressionType.Convert => GetMemberName(u.Operand),
            _ => throw new ArgumentException("Expected member access")
        };
    }
    private static LambdaExpression GetDefaultSelect<T>()
    {
        var param = Expression.Parameter(typeof(T), "x");
        return Expression.Lambda(param, param);
    }
}

var users = new DbSet<User>("users");
// 示例 1：完整查询
var query1 = users
    .Where(u => u.Age > 18 && u.Name == "Alice")
    .OrderBy(u => u.Name)
    .Select(u => new { u.Id, u.Name })
    .Take(5);
Console.WriteLine(query1.ToSql());
// 输出: SELECT Id, Name FROM users WHERE ((Age > 18) AND (Name = 'Alice')) ORDER BY Name LIMIT 5
// 示例 2：仅 WHERE
var query2 = users.Where(u => u.Id == 100);
Console.WriteLine(query2.ToSql());
// 输出: SELECT * FROM users WHERE (Id = 100)