修复错误，优化性能，实现类型系统，优化安装卸载过程

chusql-core/engine/src/ChuSQL/Core/Engine.hs

@@ -99,6 +99,15 @@ runStatementUncheckedM db (Update tbl assigns mWhere) =
 runStatementUncheckedM _ (CreateTable name cols) = do
     result <- createTable name cols
     pure (result >> Right [])
+runStatementUncheckedM _ (CreateDomain name base) = do
+    result <- createTable (domainTableName name) [("base", plainColumn base)]
+    pure (result >> Right [])
+runStatementUncheckedM _ (DropDomain name) = do
+    result <- dropTable (domainTableName name)
+    pure (result >> Right [])
+runStatementUncheckedM db ShowDomains = pure (Right
+    [[("domain", VStr (drop (length (domainTableName "")) name)), ("base_type", VStr (typeName (columnType base)))]
+    | (name, table) <- db, isDomainTable name, Just base <- [lookup "base" (tableCols table)]])
 runStatementUncheckedM _ (DropTable name) = do
     result <- dropTable name
     pure (result >> Right [])
@@ -123,6 +132,8 @@ runStatementUncheckedM db (AlterColumnNull tbl col nullable) =
     alterTable db tbl (\table -> setColumnNullable col nullable (tableCols table) (tableRows table))
 runStatementUncheckedM _ CreateUser{} = pure (Left "CREATE USER is executed by the account service")
 runStatementUncheckedM _ AlterUser{} = pure (Left "ALTER USER is executed by the account service")
+runStatementUncheckedM _ AlterIdentity{} = pure (Left "ALTER ROLE is executed by the account service")
+runStatementUncheckedM _ ShowRoles = pure (Left "SHOW ROLES is executed by the account service")
 runStatementUncheckedM _ DropUser{} = pure (Left "DROP USER is executed by the account service")
 runStatementUncheckedM _ CreateRole{} = pure (Left "CREATE ROLE is executed by the privilege service")
 runStatementUncheckedM _ DropRole{} = pure (Left "DROP ROLE is executed by the privilege service")

chusql-core/engine/src/ChuSQL/Core/Engine/Algebra/Eval.hs

@@ -135,27 +135,33 @@ filterPairsM ::
     [Row] ->
     [Row] ->
     m (Either String [Row])
-filterPairsM db outer kind ncols cond lrows rrows = go lrows []
+filterPairsM db outer kind ncols cond lrows rrows = go lrows [] HM.empty
   where
+    refs = subqueryRefsIn cond
     -- | 逐左行配对，左连接没配上就补 NULL
-    go [] acc = pure (Right (reverse acc))
-    go (l : ls) acc = do
-        hits <- keep l rrows []
+    go [] acc _ = pure (Right (reverse acc))
+    go (l : ls) acc cache = do
+        hits <- keep l rrows [] cache
         case hits of
             Left e -> pure (Left e)
-            Right hs -> do
+            Right (hs, nextCache) -> do
                 let hs' = case (kind, hs) of
                         (LeftJoin, []) -> [l ++ nullRow]
                         _ -> hs
-                go ls (reverse hs' ++ acc)
+                go ls (reverse hs' ++ acc) nextCache
     -- | 拿一行右行去比条件
-    keep _ [] acc = pure (Right (reverse acc))
-    keep l (r : rs) acc = do
-        ok <- evalCondForRowM db cond (l ++ r ++ outer)
-        case ok of
+    keep _ [] acc cache = pure (Right (reverse acc, cache))
+    keep l (r : rs) acc cache = do
+        let env = l ++ r ++ outer
+            key = bindingKey refs env
+        resolved <- case HM.lookup key cache of
+            Just expression -> pure (Right expression)
+            Nothing -> substSubqueries db cond env
+        case resolved of
             Left e -> pure (Left e)
-            Right True -> keep l rs ((l ++ r) : acc)
-            Right False -> keep l rs acc
+            Right expression -> case evalCondForRow expression env of
+                Left e -> pure (Left e)
+                Right matches -> keep l rs (if matches then (l ++ r) : acc else acc) (HM.insert key expression cache)
     nullRow = [(c, VNull) | c <- ncols]
 
 -- | 索引连接：右表是裸 Scan 时逐左行点查
@@ -197,6 +203,7 @@ floatType :: ColumnType -> Bool
 floatType CFloat = True
 floatType CDouble = True
 floatType (CDecimal _ _) = True
+floatType (CDomain _ base) = floatType base
 floatType _ = False
 
 -- | 是不是浮点值
@@ -249,7 +256,14 @@ evalAggregate outer keys aggs rows = do
 
 -- | 绑定键：子查询引用的外层列在这一行上的取值
 bindingKey :: [String] -> Row -> String
-bindingKey refs env = show [(c, lookup c env) | c <- refs]
+bindingKey refs env = show [(c, bindingValue c env) | c <- refs]
+
+-- | 查已解析外层引用对应的物理列值
+bindingValue :: String -> Row -> Maybe Value
+bindingValue column env = case lookup column env of
+    Just value -> Just value
+    Nothing | '.' `elem` column -> lookup (reverse (takeWhile (/= '.') (reverse column))) [(key, value) | (key, value) <- env, '.' `notElem` key]
+    Nothing -> Nothing
 
 -- | 每个绑定留第一行当样本，去掉重复绑定
 bindingSamples :: [String] -> Row -> [Row] -> [(String, Row)]
@@ -414,7 +428,14 @@ substSubqueries db e env = case e of
 runSubqueryRows :: (MonadStorage m) => Database -> Subquery -> Row -> m (Either String [Row])
 runSubqueryRows db sq outer = case translate (subqueryStatement sq) of
     Left e -> pure (Left e)
-    Right op -> evalRelOpIn db outer (optimize db op)
+    Right op -> case mapM bind (subqueryRefs sq) of
+        Left err -> pure (Left err)
+        Right bindings -> evalRelOpIn db (bindings ++ outer) (optimize db op)
+  where
+    -- | 给外层物理列补回已解析的限定名
+    bind column = case bindingValue column outer of
+        Just value -> Right (column, value)
+        Nothing -> Left ("unknown outer column: " ++ column)
 
 -- | 单子求值：Scan/点查/范围查都问存储
 evalRelOpM :: (MonadStorage m) => Database -> RelOp -> m (Either String [Row])

chusql-core/engine/src/ChuSQL/Core/Engine/Algebra/JoinOrder.hs

@@ -1,7 +1,7 @@
 module ChuSQL.Core.Engine.Algebra.JoinOrder (reorderJoins) where
 
 import ChuSQL.Core.Engine.Algebra.Cost (pointRows, rangeRows, selectivityOf, tableMetaOf)
-import ChuSQL.Core.Engine.Algebra.Expr (colsInExpr, hasDivision)
+import ChuSQL.Core.Engine.Algebra.Expr (colsInExpr, hasDivision, hasSubquery)
 import ChuSQL.Core.Engine.Algebra.Op (RelOp (..), relOpCols)
 import ChuSQL.Core.Engine.Syntax.AST (Expr (..), JoinKind (..))
 import ChuSQL.Core.Model
@@ -46,8 +46,13 @@ leafRows db op = case op of
     Scan _ t _ -> rowCountOf db t
     Lookup _ t c _ -> pointRows <$> tableMetaOf db t <*> pure c
     Range _ t c lo hi -> (\m -> rangeRows m c lo hi) <$> tableMetaOf db t
-    Filter p x -> scaleRows db p x <$> leafRows db x
+    Filter p x | not (hasDivision p || hasSubquery p) -> scaleRows db p x <$> leafRows db x
     Project _ x -> leafRows db x
+    Compute items x | all (\(_, e) -> not (hasDivision e || hasSubquery e)) items -> leafRows db x
+    Sort _ x -> leafRows db x
+    Limit n x -> min (max 0 n) <$> leafRows db x
+    Derived _ x -> leafRows db x
+    Unit -> Just 1
     _ -> Nothing
 
 -- | 表统计里的行数

chusql-core/engine/src/ChuSQL/Core/Engine/Algebra/Optimize.hs

@@ -117,8 +117,16 @@ pushProject db need (Join kind l r c)
 pushProject db need leaf@(Scan a t _)
     | needsAll need = leaf
     | all (`elem` need) (relOpCols db leaf) = leaf
-    | otherwise = Scan a t (Just (nub (map (unqualify a) need)))
-pushProject _ _ (Derived a x) = Derived a x
+    | otherwise = Scan a t (Just (nub [column | requested <- need, let column = physicalColumn requested, column `elem` available]))
+  where
+    available = map (unqualify a) (relOpCols db (Scan a t Nothing))
+    -- | 把扫描限定列换成存储物理列名
+    physicalColumn column = unqualify (Just (deriveQualifier a t)) (unqualify a column)
+pushProject db need (Derived a x)
+    | needsAll need || all (`elem` wanted) (relOpCols db x) = Derived a (pushProject db ["*"] x)
+    | otherwise = Derived a (Project wanted (pushProject db wanted x))
+  where
+    wanted = nub (map (unqualify a) need)
 pushProject db need leaf@(Lookup _ _ _ _) = pushProjectLeaf db need leaf
 pushProject db need leaf@(Range _ _ _ _ _) = pushProjectLeaf db need leaf
 

chusql-core/engine/src/ChuSQL/Core/Engine/Algebra/Planner.hs

@@ -1,8 +1,9 @@
 module ChuSQL.Core.Engine.Algebra.Planner (translate) where
 
-import ChuSQL.Core.Engine.Algebra.Expr (aggregatesIn)
+import ChuSQL.Core.Engine.Algebra.Expr (aggregatesIn, colsInExpr)
 import ChuSQL.Core.Engine.Algebra.Op
 import ChuSQL.Core.Engine.Syntax.AST
+import Data.List (nub)
 
 -- 计划生成：把语句翻译成算子树。
 
@@ -91,5 +92,16 @@ translate q = case q of
     SelectExpr items fromC mWhere groupBy orderBy mLimit -> do
         plan0 <- source fromC mWhere
         let (plan, items') = grouped groupBy items plan0
-        Right (Compute items' (limited orderBy mLimit plan))
+        Right $ if any (\(c, _) -> c `elem` map fst items') orderBy
+            then orderedProjection items' orderBy mLimit plan
+            else Compute items' (limited orderBy mLimit plan)
     _ -> Left "only SELECT is supported by translate"
+
+-- | 在排序前计算别名并保留输出顺序
+orderedProjection :: [(String, Expr)] -> [(String, SortDir)] -> Maybe Int -> RelOp -> RelOp
+orderedProjection items orderBy mLimit plan =
+    Compute items (limited ordering mLimit (Compute (carried ++ keys) plan))
+  where
+    carried = [(column, Col column) | column <- nub (concatMap (colsInExpr . snd) items)]
+    keys = [("$order" ++ show n, maybe (Col c) id (lookup c items)) | (n, (c, _)) <- zip [1 :: Int ..] orderBy]
+    ordering = [(key, direction) | ((key, _), (_, direction)) <- zip keys orderBy]

chusql-core/engine/src/ChuSQL/Core/Engine/Error.hs

@@ -36,6 +36,8 @@ errorRules =
     [ ErrorRule "no database selected" NoDatabaseError "no_database"
     , ErrorRule "administrator required" PermissionError "forbidden"
     , ErrorRule "unknown table" CatalogError "not_found"
+    , ErrorRule "unknown domain" CatalogError "not_found"
+    , ErrorRule "domain is still used" CatalogError "query_error"
     , ErrorRule "unknown column" CatalogError "query_error"
     , ErrorRule "unknown database" CatalogError "not_found"
     , ErrorRule "unknown role" CatalogError "not_found"
@@ -72,5 +74,7 @@ errorCode message = maybe "query_error" ruleCode (errorLike message)
 -- | 账号服务对外的错误码
 accountErrorCode :: String -> String
 accountErrorCode "account already exists" = "conflict"
+accountErrorCode "identity already exists" = "conflict"
+accountErrorCode "the last enabled login superuser cannot be removed" = "bad_request"
 accountErrorCode "unknown account" = "not_found"
 accountErrorCode _ = "storage_error"

chusql-core/engine/src/ChuSQL/Core/Engine/Semantic.hs

@@ -5,7 +5,7 @@ import ChuSQL.Core.Model
 import ChuSQL.Core.Engine.Syntax.AST
 import ChuSQL.Core.Engine.Syntax.Parser (parseExpression)
 import Data.Char (isAlphaNum, isAscii, toLower)
-import Data.List (intercalate, isInfixOf, isPrefixOf, nub)
+import Data.List (intercalate, isInfixOf, isPrefixOf, isSuffixOf, nub)
 
 -- 语义检查：表和列在不在、类型对不对，全部在执行前查。
 
@@ -53,10 +53,15 @@ checkFrom db outer (FromJoin _ left right cond) = do
     checkBool db "ON" (Scope env outer) cond
     Right env
 
--- | 派生表里 NULL 字面量列没有具体类型，按字符串处理
+-- | 保留派生表输出的类型或未定型 NULL
 derivedType :: InferredType -> ColumnType
 derivedType (InferType t) = t
-derivedType InferNull = CStr
+derivedType InferNull = CNull
+
+-- | 将列类型还原为表达式推导类型
+inferredColumnType :: ColumnType -> InferredType
+inferredColumnType CNull = InferNull
+inferredColumnType ty = InferType ty
 
 -- | 合并两层列，本层优先且不重复
 scopedEnv :: [(String, Column)] -> [(String, Column)] -> [(String, Column)]
@@ -113,7 +118,7 @@ renderType (InferType t) = typeLabel t
 
 -- | 推导表达式的类型（子查询也在这里整条查一遍）
 inferExpr :: Database -> String -> Scope -> Expr -> Either String InferredType
-inferExpr _ place env (Col c) = InferType . columnType . snd <$> scopeAt place env c
+inferExpr _ place env (Col c) = inferredColumnType . columnType . snd <$> scopeAt place env c
 inferExpr _ _ _ LitNull = Right InferNull
 inferExpr _ _ _ (LitInt _) = Right (InferType CInt)
 inferExpr _ _ _ (LitFloat _) = Right (InferType CFloat)
@@ -213,7 +218,7 @@ inferSubqueryOutput db outerScope sq = case subqueryStatement sq of
     -- | 查这一列的推导类型
     columnTypeOf env c = do
         (_, col) <- scopeAt "SELECT" (Scope env enclosing) c
-        Right (c, InferType (columnType col))
+        Right (c, inferredColumnType (columnType col))
 
 -- | 聚合的参数：列要在，且不能嵌套聚合
 aggregateArg :: Database -> String -> Scope -> Expr -> Either String InferredType
@@ -282,7 +287,7 @@ boolean db place env a b = do
   where
     -- | 挨个查操作数是不是布尔
     boolOperand _ _ InferNull = Right ()
-    boolOperand _ _ (InferType CBool) = Right ()
+    boolOperand _ _ (InferType ty) | typeClassOf ty == BooleanClass = Right ()
     boolOperand p other t = Left (p ++ ": operator needs TBool on both sides, got " ++ renderType other ++ " and " ++ renderType t)
 
 -- | 要求条件能算出布尔
@@ -292,7 +297,7 @@ checkBool db place env e = do
     t <- inferExpr db place env e
     case t of
         InferNull -> Right ()
-        InferType CBool -> Right ()
+        InferType x | typeClassOf x == BooleanClass -> Right ()
         InferType x -> Left (place ++ ": condition must be a boolean, got " ++ typeLabel x)
 
 -- | 检查赋值列和类型
@@ -321,10 +326,88 @@ check db q = () <$ prepare db q
 -- | 执行前解析列名并检查类型
 prepare :: Database -> Statement -> Either String Statement
 prepare db q = do
-    resolved <- resolveStatement db q
-    checkResolved db resolved
+    typed <- resolveDomainTypes db q
+    let visible = filter (not . isDomainTable . fst) db
+    resolved <- resolveStatement visible typed
+    case resolved of
+        CreateDomain name base -> do
+            checkDomainName name
+            checkTypeParameters base
+            case base of
+                CVarchar n | n <= 0 -> Left "CREATE DOMAIN: length must be positive"
+                CChar n | n <= 0 -> Left "CREATE DOMAIN: length must be positive"
+                CDecimal p s | p <= 0 || p > 308 || s < 0 || s > p -> Left "CREATE DOMAIN: invalid precision or scale"
+                _ -> Right ()
+            if any ((== domainTableName name) . fst) db
+                then Left ("domain already exists: " ++ name)
+                else Right ()
+        DropDomain name -> do
+            _ <- maybe (Left ("unknown domain: " ++ name)) Right (lookup (domainTableName name) db)
+            if any (any (usesDomain name . columnType . snd) . tableCols . snd) db
+                then Left ("domain is still used by a column: " ++ name)
+                else Right ()
+        ShowDomains -> Right ()
+        _ -> do
+            if any (isDomainTable . lastTablePart) (ddlTargets resolved)
+                then Left "reserved domain catalog"
+                else Right ()
+            checkResolved visible resolved
     pure resolved
 
+-- | 检查命名类型的名称
+checkDomainName :: String -> Either String ()
+checkDomainName name
+    | null name || length name > 48 = Left "CREATE DOMAIN: name must contain 1 to 48 characters"
+    | any (\c -> not (isAscii c && (isAlphaNum c || c == '_'))) name = Left "CREATE DOMAIN: invalid name"
+    | Just _ <- parseColumnType name = Left "CREATE DOMAIN: built-in type name is reserved"
+    | "__system_" `isPrefixOf` map toLower name = Left "CREATE DOMAIN: reserved name"
+    | otherwise = Right ()
+
+-- | 判断列类型是否引用指定命名类型
+usesDomain :: String -> ColumnType -> Bool
+usesDomain name (CDomain other base) = map toLower name == map toLower other || usesDomain name base
+usesDomain _ _ = False
+
+-- | 列出结构语句的目标表
+ddlTargets :: Statement -> [String]
+ddlTargets statement = case statement of
+    CreateTable name _ -> [name]
+    DropTable name -> [name]
+    CreateIndex name _ -> [name]
+    DropIndex name _ -> [name]
+    AddColumn name _ -> [name]
+    DropColumn name _ -> [name]
+    RenameColumn name _ _ -> [name]
+    AlterColumnType name _ _ -> [name]
+    AlterColumnDefault name _ _ -> [name]
+    AlterColumnNull name _ _ -> [name]
+    _ -> []
+
+-- | 从 schema 解析列上的命名类型
+resolveDomainTypes :: Database -> Statement -> Either String Statement
+resolveDomainTypes db statement = case statement of
+    CreateDomain name base -> CreateDomain name <$> resolveType base
+    CreateTable name cols -> CreateTable name <$> mapM resolveColumnType cols
+    AddColumn name col -> AddColumn name <$> resolveColumnType col
+    AlterColumnType name col ty -> AlterColumnType name col <$> resolveType ty
+    _ -> Right statement
+  where
+    -- | 解析一列的类型
+    resolveColumnType (name, col) = do
+        ty <- resolveType (columnType col)
+        Right (name, col {columnType = ty})
+    -- | 从类型目录取基础类型
+    resolveType = resolveWith []
+    -- | 递归解析类型并拒绝循环定义
+    resolveWith seen (CDomain name _)
+        | map toLower name `elem` seen = Left ("cyclic domain definition: " ++ name)
+        | otherwise = do
+            table <- maybe (Left ("unknown domain: " ++ name)) Right (lookup (domainTableName name) db)
+            base <- maybe (Left ("invalid domain catalog: " ++ name)) Right (lookup "base" (tableCols table))
+            resolved <- resolveWith (map toLower name : seen) (columnType base)
+            Right (CDomain (map toLower name) resolved)
+    resolveWith _ ty = Right ty
+
 -- | 检查已解析的语句
 checkResolved :: Database -> Statement -> Either String ()
 checkResolved db = checkResolvedWith db []
@@ -350,8 +433,8 @@ checkResolvedWith db outer q = case q of
         env <- checkFrom db outer fromC
         let full = Scope env outer
         mapM_ (\item -> () <$ inferExpr db "SELECT" full (snd item)) items
-        checkGrouping full groupBy items
-        checkColumns "ORDER BY" full (map fst orderBy)
+        checkGrouping full groupBy (items ++ [(c, Col c) | (c, _) <- orderBy, c `notElem` map fst items])
+        mapM_ (checkOrder full items . fst) orderBy
         mapM_ (checkNoAggregate "WHERE") mWhere
         mapM_ (checkBool db "WHERE" full) mWhere
     Insert tbl cols rows -> do
@@ -420,6 +503,7 @@ checkResolvedWith db outer q = case q of
     AlterColumnType tbl col ty -> do
         t <- lookupTable db tbl
         c <- requireColumn "ALTER COLUMN" t col
+        checkTypeParameters ty
         if columnAutoIncrement c && not (integerType ty)
             then Left "ALTER COLUMN: AUTO_INCREMENT column must stay an integer type"
             else Right ()
@@ -435,6 +519,12 @@ checkResolvedWith db outer q = case q of
             else Right ()
     CreateUser name password -> checkAccount name password
     AlterUser name password -> checkAccount name password
+    AlterIdentity name attributes -> do
+        checkRoleName name
+        if length (nub (map fst attributes)) == length attributes
+            then Right ()
+            else Left "duplicate identity attribute"
+    ShowRoles -> Right ()
     DropUser name -> checkUserName name
     CreateRole name -> checkRoleName name
     DropRole name -> checkRoleName name
@@ -456,6 +546,9 @@ checkResolvedWith db outer q = case q of
     DropDatabase name -> checkDatabaseName name
     UseDatabase name -> checkDatabaseName name
     ShowDatabases -> Right ()
+    CreateDomain{} -> Right ()
+    DropDomain{} -> Right ()
+    ShowDomains -> Right ()
     -- | 事务控制由会话层执行，语义层不做列检查
     BeginTransaction -> Right ()
     CommitTransaction -> Right ()
@@ -485,6 +578,7 @@ checkInsertTargets t cols = mapM_ checkTarget (tableCols t)
 -- | 检查一列定义是否合法（names 给 CHECK 用）
 checkColumnDefs :: [String] -> [(String, Column)] -> Either String ()
 checkColumnDefs names cols = do
+    mapM_ (checkTypeParameters . columnType . snd) cols
     mapM_ (\(_, c) -> mapM_ (checkDefault c) (columnDefault c)) cols
     mapM_ (\(_, c) -> checkAutoIncrement c) cols
     if length [() | (_, c) <- cols, columnAutoIncrement c] > 1
@@ -492,6 +586,16 @@ checkColumnDefs names cols = do
         else Right ()
     checkChecks names cols
 
+-- | 校验列类型的长度和精度参数
+checkTypeParameters :: ColumnType -> Either String ()
+checkTypeParameters (CDomain _ base) = checkTypeParameters base
+checkTypeParameters CNull = Left "NULL is only valid as an inferred query output"
+checkTypeParameters (CDecimal p s)
+    | p <= 0 || p > 308 || s < 0 || s > p = Left "invalid decimal precision or scale"
+checkTypeParameters (CVarchar n) | n <= 0 = Left "character length must be positive"
+checkTypeParameters (CChar n) | n <= 0 = Left "character length must be positive"
+checkTypeParameters _ = Right ()
+
 -- | 自增列必须是整数列
 checkAutoIncrement :: Column -> Either String ()
 checkAutoIncrement c
@@ -502,8 +606,8 @@ checkAutoIncrement c
 checkDefault :: Column -> Value -> Either String ()
 checkDefault c v
     | VNull <- v = Right ()
-    | valueFits (columnType c) v = Right ()
-    | otherwise = Left ("DEFAULT: value does not fit column type " ++ show c)
+    | valueFits (columnType c) v = () <$ coerceValue (columnType c) v
+    | otherwise = Left ("DEFAULT: value does not fit column type " ++ typeLabel (columnType c))
 
 -- | CHECK 里的列必须存在
 checkChecks :: [String] -> [(String, Column)] -> Either String ()
@@ -717,6 +821,13 @@ resolveSelect db q@Select{} = resolveQuery db [] q (map (\c -> (c, Col c)) (sele
 resolveSelect db q@SelectExpr{} = resolveQuery db [] q (selectItems q)
 resolveSelect _ q = Right q
 
+-- | 检查排序输出别名或来源列
+checkOrder :: Scope -> [(String, Expr)] -> String -> Either String ()
+checkOrder env items column = case [e | (label, e) <- items, label == column] of
+    [] -> checkColumns "ORDER BY" env [column]
+    [_] -> Right ()
+    _ -> Left ("ORDER BY: ambiguous projection alias: " ++ column)
+
 -- | 解析投影、条件、排序与连接引用
 resolveQuery :: Database -> [(String, Column)] -> Statement -> [(String, Expr)] -> Either String Statement
 resolveQuery db outer q items = do
@@ -727,7 +838,13 @@ resolveQuery db outer q items = do
             FromTable Nothing tbl -> unqualify (Just (deriveQualifier Nothing tbl)) c
             _ -> c
         -- | 查一列并换算成物理名
-        name place c = physical . fst <$> scopedColumnAt place env outer c
+        name place c
+            | length (filter (== '.') c) == 2, not (qualifiedReference c) = Left (missingColumn place c env)
+            | otherwise = physical . fst <$> scopedColumnAt place env outer c
+        -- | 库限定列只引用来源中的真实表名
+        qualifiedReference c = qualifiedReferenceIn db (selectFrom q) c
+            || (any (\(key, _) -> length (filter (== '.') key) == 1 && ("." ++ key) `isSuffixOf` c) outer
+                && (not (any (elem '.' . fst) db) || any (\(table, _) -> (table ++ ".") `isPrefixOf` c) db))
         -- | 换算一个投影项：带别名时保留别名做输出列名
         output (label, Col c) = do
             k <- name "SELECT" c
@@ -742,11 +859,29 @@ resolveQuery db outer q items = do
         else mapM output items
     condition <- mapM (resolveExpr db env outer (name "WHERE")) (selectWhere q)
     grouping <- mapM (name "GROUP BY") (selectGroupBy q)
-    ordering <- mapM (\(c, d) -> (\k -> (k, d)) <$> name "ORDER BY" c) (selectOrderBy q)
+    -- | 优先解析唯一投影别名，再查来源列
+    let orderName c = case [label | (label, _) <- projected, label == c, qIsExpression] of
+            [] -> name "ORDER BY" c
+            [label] -> Right label
+            _ -> Left ("ORDER BY: ambiguous projection alias: " ++ c)
+        qIsExpression = case q of SelectExpr{} -> True; _ -> False
+    ordering <- mapM (\(c, d) -> (\k -> (k, d)) <$> orderName c) (selectOrderBy q)
     pure $ case q of
         Select{} -> Select (map fst projected) source condition grouping ordering (selectLimit q)
         _ -> SelectExpr projected source condition grouping ordering (selectLimit q)
 
+-- | 收集没有别名遮蔽的来源表名
+sourceTableNames :: FromClause -> [String]
+sourceTableNames (FromTable Nothing table) = [table]
+sourceTableNames (FromJoin _ left right _) = sourceTableNames left ++ sourceTableNames right
+sourceTableNames _ = []
+
+-- | 库限定引用必须使用当前来源的表名
+qualifiedReferenceIn :: Database -> FromClause -> String -> Bool
+qualifiedReferenceIn db source c = any (\table -> (table ++ ".") `isPrefixOf` c) tables
+  where
+    tables = sourceTableNames source ++ [key | table <- sourceTableNames source, Right (key, _) <- [resolveTable db table]]
+
 -- | 单表不加限定名，其余来源交给 resolveFrom
 resolveSource :: Database -> [(String, Column)] -> FromClause -> Either String FromClause
 resolveSource db outer fromC = case fromC of
@@ -769,7 +904,11 @@ resolveFrom db outer (FromJoin kind left right cond) = do
     l <- resolveFrom db outer left
     r <- resolveFrom db outer right
     env <- checkFrom db outer (FromJoin kind l r cond)
-    c <- resolveExpr db env outer (fmap fst . columnAt "ON" env) cond
+    -- | 连接条件也拒绝不存在的库前缀
+    let joinName column
+            | length (filter (== '.') column) == 2, not (qualifiedReferenceIn db (FromJoin kind left right cond) column) = Left (missingColumn "ON" column env)
+            | otherwise = fst <$> columnAt "ON" env column
+    c <- resolveExpr db env outer joinName cond
     pure (FromJoin kind l r c)
 
 -- | 派生表的输出列名：列取裸名，表达式保留原标签

chusql-core/engine/src/ChuSQL/Core/Engine/Storage/FFI.hs

@@ -7,6 +7,7 @@ module ChuSQL.Core.Engine.Storage.FFI (
     openStorage,
     closeStorage,
     storageRequest,
+    maintainStorage,
 ) where
 
 import Control.Exception (SomeException, try)
@@ -40,6 +41,21 @@ foreign import ccall unsafe "chusql_storage_free"
 foreign import ccall unsafe "chusql_storage_last_error"
     cStorageLastError :: Ptr CSize -> IO (Ptr CChar)
 
+foreign import ccall safe "chusql_storage_maintenance"
+    cStorageMaintenance :: CString -> Ptr CChar -> CSize -> Ptr (Ptr CChar) -> Ptr CSize -> IO CInt
+
+-- | 离线修复系统目录并返回结果
+maintainStorage :: FilePath -> BS.ByteString -> IO (Either String BS.ByteString)
+maintainStorage path payload = withCString path $ \config ->
+    BS.useAsCStringLen payload $ \(input, size) -> alloca $ \outRef -> alloca $ \lenRef -> do
+        code <- cStorageMaintenance config input (fromIntegral size) outRef lenRef
+        if code /= 0 then Left <$> lastError else do
+            output <- peek outRef
+            len <- peek lenRef
+            bytes <- BS.packCStringLen (output, fromIntegral len)
+            cStorageFree output len
+            pure (Right bytes)
+
 -- | 库版本（Rust 侧的 CARGO_PKG_VERSION）
 storageVersion :: IO String
 storageVersion = cStorageVersion >>= peekCString

chusql-core/engine/src/ChuSQL/Core/Engine/Storage/Memory.hs

@@ -2,6 +2,7 @@ module ChuSQL.Core.Engine.Storage.Memory (MemoryStorage (runMemoryStorage)) wher
 
 import ChuSQL.Core.Model
 import ChuSQL.Core.Engine.Storage
+import qualified Data.HashSet as HS
 
 -- 内存实现：Database 上的状态，错误通道是 Either String。
 
@@ -74,11 +75,32 @@ instance MonadStorage MemoryStorage where
     -- \| 原样返回当前库
     snapshot = MemoryStorage $ \db -> Right (db, db)
 
+    -- \| 返回实时行数与去重统计的无数据结构
+    schema = MemoryStorage $ \db -> Right (map describe db, db)
+      where
+        -- | 将存储数据汇总为结构统计
+        describe (name, table) =
+            (name, table {tableRows = [], tableMeta = Just metadata})
+          where
+            metadata = TableMeta (length (tableRows table)) distinct [] []
+            distinct = [columnStatistics column (tableRows table) | (column, _) <- tableCols table]
+
     -- \| 改表结构：列定义与行一起换
     replaceSchema name cols rows = MemoryStorage $ \db -> case lookup name db of
         Nothing -> Right (Left ("unknown table: " ++ name), db)
         Just tbl -> Right (Right (), replaceTable name tbl{tableCols = cols, tableRows = rows} db)
 
+-- | 对列值去重并限制统计内存
+columnStatistics :: String -> [Row] -> (String, Int, Bool)
+columnStatistics column rows = go rows HS.empty
+  where
+    -- | 累积规范化值，达到上限后停止
+    go remaining values
+        | HS.size values >= 4096 = (column, 4096, True)
+        | otherwise = case remaining of
+            [] -> (column, HS.size values, False)
+            row : rest -> go rest (maybe values (\v -> HS.insert (canonicalValue v) values) (lookup column row))
+
 -- | 用给定表替换同名表
 replaceTable :: String -> Table -> Database -> Database
 replaceTable name table =

chusql-core/engine/src/ChuSQL/Core/Engine/Syntax/AST.hs

@@ -25,6 +25,9 @@ data Statement
     | Delete String (Maybe Expr)
     | Update String [(String, Expr)] (Maybe Expr)
     | CreateTable String [(String, Column)]
+    | CreateDomain String ColumnType
+    | DropDomain String
+    | ShowDomains
     | DropTable String
     | CreateIndex String String
     | DropIndex String String
@@ -36,6 +39,8 @@ data Statement
     | AlterColumnNull String String Bool
     | CreateUser String String
     | AlterUser String String
+    | AlterIdentity String [(String, Bool)]
+    | ShowRoles
     | DropUser String
     -- | 新角色：权限的载体，用户靠成员资格继承它的权限
     | CreateRole String

chusql-core/engine/src/ChuSQL/Core/Engine/Syntax/Parser.hs

@@ -8,7 +8,7 @@ import ChuSQL.Core.Engine.Syntax.AST
 import Control.Monad (void)
 import Control.Monad.Combinators.Expr (Operator (..), makeExprParser)
 import Data.Char (isAlpha, isAlphaNum, isHexDigit, isSpace, toLower, toUpper)
-import Data.List (intercalate)
+import Data.List (intercalate, isInfixOf)
 import Data.Maybe (fromMaybe)
 import Data.Void (Void)
 import Text.Megaparsec
@@ -475,8 +475,25 @@ alterUserStatement = do
     keyword "alter"
     keyword "user"
     name <- userName
-    pw <- identifiedBy
-    return (AlterUser name pw)
+    (AlterUser name <$> identifiedBy) <|> (AlterIdentity name <$> some identityAttribute)
+
+-- | 读身份属性开关
+identityAttribute :: Parser (String, Bool)
+identityAttribute = choice
+    [ ("system_catalog_manager", True) <$ keyword "system_catalog_manager"
+    , ("system_catalog_manager", False) <$ keyword "nosystem_catalog_manager"
+    , ("login", True) <$ keyword "login", ("login", False) <$ keyword "nologin"
+    , ("superuser", True) <$ keyword "superuser", ("superuser", False) <$ keyword "nosuperuser"
+    , ("enabled", True) <$ keyword "enabled", ("enabled", False) <$ keyword "disabled"
+    ]
+
+-- | 读 ALTER ROLE 属性或口令
+alterRoleStatement :: Parser Statement
+alterRoleStatement = do
+    keyword "alter"
+    keyword "role"
+    name <- userName
+    (AlterUser name <$> identifiedBy) <|> (AlterIdentity name <$> some identityAttribute)
 
 -- | 读 DROP USER
 dropUserStatement :: Parser Statement
@@ -599,6 +616,7 @@ columnTypeP =
         , keyword "date" >> pure CDate
         , keyword "timestamp" >> pure CTimestamp
         , keyword "blob" >> pure CBlob
+        , (\name -> CDomain (map toLower name) CStr) <$> identifier
         ]
 
 -- | DECIMAL 的精度与小数位
@@ -682,7 +700,14 @@ renameColumns name cols q@Select { selectCols = names } = do
         )
 renameColumns name cols q@SelectExpr { selectItems = items } = do
     checkCteArity name cols (map snd items)
-    Right q { selectItems = zip cols (map snd items) }
+    ordering <- mapM renameOrder (selectOrderBy q)
+    Right q { selectItems = zip cols (map snd items), selectOrderBy = ordering }
+  where
+    -- | 列清单同步改写内层排序输出别名
+    renameOrder (column, direction) = case [new | ((old, _), new) <- zip items cols, old == column] of
+        [] -> Right (column, direction)
+        [new] -> Right (new, direction)
+        _ -> Left ("WITH: ambiguous ORDER BY alias: " ++ column)
 renameColumns _ _ _ = Left "WITH: a CTE must be a SELECT"
 
 -- | 列清单个数必须和本体输出一致
@@ -808,7 +833,7 @@ transactionStatement =
 parseStatement :: String -> Either String Statement
 parseStatement input =
     case runParser (sc *> statementP <* sc <* eof) "<query>" input of
-        Left err -> Left (errorBundlePretty err)
+        Left err -> Left (safeParseError input err)
         Right q -> Right q
   where
     -- | 按关键字分派到各语句解析器
@@ -819,12 +844,17 @@ parseStatement input =
             <|> try (CreateDatabase <$> (keyword "create" *> keyword "database" *> identifier))
             <|> try (DropDatabase <$> (keyword "drop" *> keyword "database" *> identifier))
             <|> (UseDatabase <$> (keyword "use" *> identifier))
-            <|> (ShowDatabases <$ (keyword "show" *> keyword "databases"))
+            <|> try (ShowDatabases <$ (keyword "show" *> keyword "databases"))
+            <|> try (ShowDomains <$ (keyword "show" *> keyword "domains"))
+            <|> try (CreateDomain <$> (keyword "create" *> keyword "domain" *> identifier) <*> (keyword "as" *> columnTypeP))
+            <|> try (DropDomain <$> (keyword "drop" *> keyword "domain" *> identifier))
             <|> insertStatement
             <|> deleteStatement
             <|> updateStatement
             <|> try createUserStatement
             <|> try alterUserStatement
+            <|> try alterRoleStatement
+            <|> try (ShowRoles <$ (keyword "show" *> keyword "roles"))
             <|> try dropUserStatement
             <|> try createRoleStatement
             <|> try dropRoleStatement
@@ -840,9 +870,15 @@ parseStatement input =
 parseExpression :: String -> Either String Expr
 parseExpression input =
     case runParser (sc *> expr <* sc <* eof) "<expr>" input of
-        Left err -> Left (errorBundlePretty err)
+        Left err -> Left (safeParseError input err)
         Right e -> Right e
 
+-- | 隐去含口令输入的解析诊断
+safeParseError :: String -> ParseErrorBundle String Void -> String
+safeParseError input errors
+    | any (`isInfixOf` map toLower input) ["password", "identified"] = "syntax error in credential statement (input redacted)"
+    | otherwise = errorBundlePretty errors
+
 -- | 表名至多有一个库前缀。
 tableName :: Parser String
 tableName = do