diff --git a/apps/frontend/package.json b/apps/frontend/package.json
index 7fc0be1bd..dedb883f2 100644
--- a/apps/frontend/package.json
+++ b/apps/frontend/package.json
@@ -85,6 +85,7 @@
     "@codemirror/language": "^6.10.3",
     "@codemirror/state": "^6.4.1",
     "@codemirror/view": "^6.34.1",
+    "@floating-ui/dom": "^1.6.12",
     "@formkit/auto-animate": "^0.8.2",
     "@internationalized/date": "^3.5.6",
     "@svelte-put/clickoutside": "^3.0.2",
diff --git a/apps/frontend/src/lib/components/formula/formula-editor.svelte b/apps/frontend/src/lib/components/formula/formula-editor.svelte
index abbba8165..8f3a2c943 100644
--- a/apps/frontend/src/lib/components/formula/formula-editor.svelte
+++ b/apps/frontend/src/lib/components/formula/formula-editor.svelte
@@ -16,6 +16,8 @@
   import { derived } from "svelte/store"
   import FieldIcon from "../blocks/field-icon/field-icon.svelte"
   import { type Field } from "@undb/table"
+  import { computePosition, flip, shift, offset } from "@floating-ui/dom"
+  import { globalFormulaRegistry } from "@undb/formula/src/formula/formula.registry"
 
   const functions = FORMULA_FUNCTIONS
 
@@ -31,8 +33,15 @@
   export let value: string = ""
 
   let editor: EditorView
-  let suggestions: string[] = [...functions, ...$fields]
+  let formulaSuggestions: string[] = [...functions]
+  let fieldSuggestions: string[] = [...$fields]
+
+  $: suggestions = [...formulaSuggestions, ...fieldSuggestions]
+
   let selectedSuggestion: string = ""
+  let hoverSuggestion: string = ""
+
+  $: hoverFormula = hoverSuggestion ? globalFormulaRegistry.get(hoverSuggestion as FormulaFunction) : undefined
 
   const highlightStyle = HighlightStyle.define([
     { tag: tags.keyword, color: "#5c6bc0" },
@@ -281,8 +290,8 @@
       if (!isInsideParens) {
         const functionNode = visitor.getNearestFunctionNode()
         if (functionNode) {
-          const functionStart = functionNode.start.startIndex
-          const functionNameLength = functionNode.IDENTIFIER().text.length
+          const functionStart = functionNode.start.tokenIndex
+          const functionNameLength = functionNode.IDENTIFIER().getText().length
           const transaction = editor.state.update({
             changes: {
               from: functionStart,
@@ -383,9 +392,30 @@
       errorMessage = (error as Error).message
     }
   }
+
+  let hoverSuggestionContainer: HTMLElement
+  let editorContainerWrapper: HTMLElement
+
+  function update() {
+    if (hoverSuggestionContainer && editorContainerWrapper && hoverFormula) {
+      computePosition(editorContainerWrapper, hoverSuggestionContainer, {
+        placement: "left-start",
+        middleware: [flip(), shift({ padding: 5 }), offset(10)],
+      }).then(({ x, y }) => {
+        Object.assign(hoverSuggestionContainer.style, {
+          left: `${x}px`,
+          top: `${y}px`,
+        })
+      })
+    }
+  }
+
+  onMount(() => {
+    update()
+  })
 </script>
 
-<div>
+<div bind:this={editorContainerWrapper} id="editor-container-wrapper" class="relative">
   <div id="editor-container" class="mb-2 rounded-sm border"></div>
   {#if errorMessage}
     <p class="text-destructive flex items-center gap-1 text-xs">
@@ -395,32 +425,94 @@
   {/if}
 
   <ul class="mt-2 flex h-[250px] flex-col divide-y overflow-auto rounded-lg border border-gray-200">
-    {#each suggestions as suggestion}
+    <div class="sticky top-0 z-10 border-b bg-gray-100 px-2 py-1.5 text-xs font-semibold">Formula</div>
+    {#each formulaSuggestions as suggestion}
       {@const isSelected = suggestion === selectedSuggestion}
-      {@const isFunction = functions.includes(suggestion)}
-      {@const isField = !isFunction}
-      <button type="button" on:click={() => insertSuggestion(suggestion)} class="w-full text-left text-xs font-medium">
+      {@const isHovered = suggestion === hoverSuggestion}
+      <button
+        type="button"
+        on:click={() => insertSuggestion(suggestion)}
+        on:mouseenter={() => {
+          hoverSuggestion = suggestion
+          update()
+        }}
+        class="group relative w-full text-left text-xs font-medium"
+      >
+        <li
+          class={cn("flex w-full items-center gap-1 p-2 hover:bg-gray-100", (isSelected || isHovered) && "bg-gray-100")}
+        >
+          <span class="font-normal">
+            <SquareFunctionIcon class="size-4" />
+          </span>
+          <span>
+            {suggestion}()
+          </span>
+        </li>
+
+        <div class="absolute left-0 top-0 z-50 -translate-x-[100%] group-hover:block">hello</div>
+      </button>
+    {/each}
+    <div class="sticky top-0 z-10 border-b bg-gray-100 px-2 py-1.5 text-xs font-semibold">Field</div>
+    {#each fieldSuggestions as suggestion}
+      {@const isSelected = suggestion === selectedSuggestion}
+      {@const field = $table.schema.getFieldByIdOrName(suggestion).into(null)}
+      <button
+        type="button"
+        on:mouseenter={() => {
+          hoverSuggestion = ""
+        }}
+        on:click={() => insertSuggestion(suggestion)}
+        class="w-full text-left text-xs font-medium"
+      >
         <li class={cn("flex w-full items-center gap-1 p-2 hover:bg-gray-100", isSelected && "bg-gray-100")}>
-          {#if isFunction}
-            <span class="font-normal">
-              <SquareFunctionIcon class="size-4" />
+          {#if field}
+            <span class="flex items-center gap-1">
+              <FieldIcon class="size-4" type={field.type} {field} />
+              {field.name.value}
             </span>
-            <span>
-              {suggestion}()
-            </span>
-          {:else}
-            {@const field = $table.schema.getFieldByIdOrName(suggestion).into(null)}
-            {#if field}
-              <span class="flex items-center gap-1">
-                <FieldIcon class="size-4" type={field.type} {field} />
-                {field.name.value}
-              </span>
-            {/if}
           {/if}
         </li>
       </button>
     {/each}
   </ul>
+
+  <div bind:this={hoverSuggestionContainer} class="fixed left-0 top-0 w-80 rounded-md border bg-white shadow-md">
+    {#if hoverFormula}
+      <div>
+        <div class="flex items-center gap-2 border-b bg-gray-100 px-2 py-1 text-sm">
+          <SquareFunctionIcon class="size-4" />
+          {hoverSuggestion}()
+        </div>
+      </div>
+
+      <div class="space-y-2 p-2">
+        <p class="overflow-hidden whitespace-normal break-words text-xs text-gray-500">{hoverFormula.description}</p>
+        <div class="space-y-2">
+          <p class="text-xs font-semibold text-gray-500">Syntax</p>
+          {#each hoverFormula.syntax as syntax}
+            <div class="whitespace-normal break-words rounded-sm border px-2 py-1 text-xs leading-6 text-gray-800">
+              {syntax}
+            </div>
+          {/each}
+        </div>
+        {#if hoverFormula.examples && hoverFormula.examples.length > 0}
+          <p class="text-xs font-semibold text-gray-500">Examples</p>
+          <div class="space-y-2">
+            {#each hoverFormula.examples as example}
+              <div class="whitespace-normal break-words rounded-sm border px-2 py-1 text-xs leading-6 text-gray-800">
+                {example[0]}
+                {#if example[1]}
+                  <span class="text-gray-500">
+                    => {example[1]}
+                  </span>
+                {/if}
+              </div>
+            {/each}
+          </div>
+        {/if}
+      </div>
+    {/if}
+  </div>
 </div>
 
 <style lang="postcss">
diff --git a/bun.lockb b/bun.lockb
index f0c1840b8..7c9155a60 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/packages/formula/src/formula.visitor.ts b/packages/formula/src/formula.visitor.ts
index 47e3da2f7..4db2b9104 100644
--- a/packages/formula/src/formula.visitor.ts
+++ b/packages/formula/src/formula.visitor.ts
@@ -1,5 +1,5 @@
+import { globalFormulaRegistry } from "./formula/formula.registry"
 import { FormulaFunction } from "./formula/formula.type"
-import { globalFunctionRegistry } from "./formula/registry"
 import {
   AddSubExprContext,
   AndExprContext,
@@ -172,15 +172,15 @@ export class FormulaVisitor extends FormulaParserVisitor<ExpressionResult> {
     const funcName = ctx.IDENTIFIER().getText() as FormulaFunction
     const args = ctx.argumentList() ? (this.visit(ctx.argumentList()!) as FunctionExpressionResult) : undefined
 
-    if (!globalFunctionRegistry.isValid(funcName)) {
+    if (!globalFormulaRegistry.isValid(funcName)) {
       throw new Error(`Unknown function: ${funcName}`)
     }
 
     if (args) {
-      globalFunctionRegistry.validateArgs(funcName, args.arguments)
+      globalFormulaRegistry.validateArgs(funcName, args.arguments)
     }
 
-    const returnType = globalFunctionRegistry.get(funcName)!.returnType
+    const returnType = globalFormulaRegistry.get(funcName)!.returnType
 
     return {
       type: "functionCall",
diff --git a/packages/formula/src/formula/formula.registry.test.ts b/packages/formula/src/formula/formula.registry.test.ts
new file mode 100644
index 000000000..d8eff24ce
--- /dev/null
+++ b/packages/formula/src/formula/formula.registry.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test"
+import { FormulaRegistry } from "./formula.registry"
+
+describe("FormulaRegistry", () => {
+  it("should register ADD functions", () => {
+    const registry = new FormulaRegistry()
+    registry.register("ADD", [["number", "number"]], "number")
+    expect(registry.isValid("ADD")).toBe(true)
+    expect(registry.get("ADD")?.syntax).toEqual(["ADD(number1, number2)"])
+  })
+
+  it("should register SUM functions", () => {
+    const registry = new FormulaRegistry()
+    registry.register("SUM", [["number", "variadic"]], "number")
+    expect(registry.isValid("SUM")).toBe(true)
+    expect(registry.get("SUM")?.syntax).toEqual(["SUM(number1, [number2, ...])"])
+  })
+
+  it("should register ABS functions", () => {
+    const registry = new FormulaRegistry()
+    registry.register("ABS", [["number"]], "number")
+    expect(registry.isValid("ABS")).toBe(true)
+    expect(registry.get("ABS")?.syntax).toEqual(["ABS(number)"])
+  })
+})
diff --git a/packages/formula/src/formula/formula.registry.ts b/packages/formula/src/formula/formula.registry.ts
new file mode 100644
index 000000000..7eb0d7c9f
--- /dev/null
+++ b/packages/formula/src/formula/formula.registry.ts
@@ -0,0 +1,357 @@
+import { ParamType, ReturnType, type ExpressionResult } from "../types"
+import { FormulaFunction } from "./formula.type"
+
+interface FormulaDefinition {
+  paramPatterns: ParamType[][]
+  returnType: ReturnType
+  syntax: string[]
+  description: string
+  examples?: [string, any | undefined][]
+}
+
+export class FormulaRegistry {
+  private functions: Map<string, FormulaDefinition> = new Map()
+
+  register(
+    name: FormulaFunction,
+    paramPatterns: ParamType[][],
+    returnType: ReturnType,
+    description: string,
+    examples?: [string, any][],
+  ) {
+    function generateFunctionSyntax(): string[] {
+      if (paramPatterns.length === 0) {
+        return [`${name}()`]
+      }
+      return paramPatterns.map((pattern) => {
+        const params = pattern.includes("variadic")
+          ? `${pattern
+              .slice(0, -1)
+              .map((p, i) => `${p}${i + 1}`)
+              .join(", ")}, [${pattern[pattern.length - 2]}${pattern.length}, ...]`
+          : pattern.length === 1
+            ? pattern[0]
+            : pattern.map((p, i) => `${p}${i + 1}`).join(", ")
+
+        return `${name}(${params})`
+      })
+    }
+
+    const syntax = generateFunctionSyntax()
+
+    this.functions.set(name, { paramPatterns, returnType, syntax, description, examples })
+  }
+
+  get(name: FormulaFunction): FormulaDefinition | undefined {
+    return this.functions.get(name.toUpperCase())
+  }
+
+  isValid(name: string): boolean {
+    return this.functions.has(name.toUpperCase())
+  }
+
+  validateArgs(name: FormulaFunction, args: ExpressionResult[]): void {
+    const funcDef = this.get(name)
+    if (!funcDef) {
+      throw new Error(`Unknown function name: ${name}`)
+    }
+
+    // 检查是否有任何模式的参数数量匹配
+    const hasMatchingPattern = funcDef.paramPatterns.some((pattern) => {
+      // 如果模式中包含 VARIADIC，则参数数量必须大于等于 pattern.length - 1
+      // 否则参数数量必须完全匹配
+      if (pattern.includes("variadic")) {
+        return args.length >= pattern.length - 1
+      }
+      return args.length === pattern.length
+    })
+
+    if (!hasMatchingPattern) {
+      const expectedCounts = funcDef.paramPatterns
+        .map((pattern) => (pattern.includes("variadic") ? `at least ${pattern.length - 1}` : `${pattern.length}`))
+        .join(" or ")
+      throw new Error(`Function ${name} expects ${expectedCounts} arguments, but got ${args.length}`)
+    }
+
+    const isValidPattern = funcDef.paramPatterns.some((pattern) => {
+      for (let i = 0; i < pattern.length; i++) {
+        const expectedType = pattern[i]
+        if (expectedType === "variadic") {
+          // 剩余的所有参数都应该匹配 VARIADIC 的前一个类型
+          const variadicType = pattern[i - 1]
+          return args.slice(i - 1).every((arg) => this.isTypeMatch(arg, variadicType))
+        }
+        if (!this.isTypeMatch(args[i], expectedType)) {
+          return false
+        }
+      }
+      return true
+    })
+
+    if (!isValidPattern) {
+      throw new Error(`Function ${name} arguments do not match: ${JSON.stringify(args)}`)
+    }
+  }
+
+  private isTypeMatch(arg: ExpressionResult, expectedType: ParamType): boolean {
+    if (arg.type === "functionCall") {
+      return arg.returnType === expectedType
+    }
+
+    if (arg.type === "variable") {
+      return true
+    }
+
+    switch (expectedType) {
+      case "number":
+        return arg.type === "number"
+      case "string":
+        return arg.type === "string"
+      case "boolean":
+        return arg.type === "boolean"
+      case "date":
+        // TODO: 假设有日期类型的处理
+        return false
+      case "any":
+        return true
+      default:
+        return false
+    }
+  }
+}
+
+export const globalFormulaRegistry = new FormulaRegistry()
+
+// 注册函数，支持多种参数模式
+globalFormulaRegistry.register("ADD", [["number", "number"]], "number", "Adds two numbers.", [
+  ["ADD(1, 2)", 3],
+  ["ADD({{field1}}, 1)", undefined],
+])
+globalFormulaRegistry.register("SUBTRACT", [["number", "number"]], "number", "Subtracts two numbers.", [
+  ["SUBTRACT(1, 2)", -1],
+  ["SUBTRACT({{field1}}, 1)", undefined],
+])
+globalFormulaRegistry.register("MULTIPLY", [["number", "number"]], "number", "Multiplies two numbers.", [
+  ["MULTIPLY(1, 2)", 2],
+  ["MULTIPLY({{field1}}, 2)", undefined],
+])
+globalFormulaRegistry.register("DIVIDE", [["number", "number"]], "number", "Divides two numbers.", [
+  ["DIVIDE(1, 2)", 0.5],
+  ["DIVIDE({{field1}}, 2)", undefined],
+])
+globalFormulaRegistry.register("SUM", [["number", "variadic"]], "number", "Sums a list of numbers.", [
+  ["SUM(1, 2, 3)", 6],
+  ["SUM({{field1}}, 1)", undefined],
+])
+globalFormulaRegistry.register(
+  "MOD",
+  [["number", "number"]],
+  "number",
+  "Returns the remainder when one number is divided by another.",
+  [
+    ["MOD(1, 2)", 1],
+    ["MOD({{field1}}, 2)", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "POWER",
+  [["number", "number"]],
+  "number",
+  "Raises a number to the power of another number.",
+  [
+    ["POWER(2, 3)", 8],
+    ["POWER({{field1}}, 2)", undefined],
+  ],
+)
+globalFormulaRegistry.register("SQRT", [["number"]], "number", "Returns the square root of a number.", [
+  ["SQRT(4)", 2],
+  ["SQRT({{field1}})", undefined],
+])
+globalFormulaRegistry.register("ABS", [["number"]], "number", "Returns the absolute value of a number.", [
+  ["ABS(-1)", 1],
+  ["ABS({{field1}})", undefined],
+])
+globalFormulaRegistry.register(
+  "ROUND",
+  [["number"]],
+  "number",
+  "Rounds a number to a specified number of decimal places.",
+  [
+    ["ROUND(1.2345, 2)", 1.23],
+    ["ROUND({{field1}}, 2)", undefined],
+  ],
+)
+globalFormulaRegistry.register("FLOOR", [["number"]], "number", "Rounds a number down to the nearest integer.", [
+  ["FLOOR(1.2345)", 1],
+  ["FLOOR({{field1}})", undefined],
+])
+globalFormulaRegistry.register("CEILING", [["number"]], "number", "Rounds a number up to the nearest integer.", [
+  ["CEILING(1.2345)", 2],
+  ["CEILING({{field1}})", undefined],
+])
+globalFormulaRegistry.register("MIN", [["number", "variadic"]], "number", "Returns the smallest number in a list.", [
+  ["MIN(1, 2, 3)", 1],
+  ["MIN({{field1}}, 1)", undefined],
+])
+globalFormulaRegistry.register("MAX", [["number", "variadic"]], "number", "Returns the largest number in a list.", [
+  ["MAX(1, 2, 3)", 3],
+  ["MAX({{field1}}, 1)", undefined],
+])
+globalFormulaRegistry.register(
+  "AVERAGE",
+  [["number", "variadic"]],
+  "number",
+  "Returns the average of a list of numbers.",
+  [
+    ["AVERAGE(1, 2, 3)", 2],
+    ["AVERAGE({{field1}}, 1)", undefined],
+  ],
+)
+
+globalFormulaRegistry.register("CONCAT", [["string", "variadic"]], "string", "Concatenates a list of strings.", [
+  ["CONCAT('Hello', 'World')", "HelloWorld"],
+  ["CONCAT({{field1}}, 'World')", undefined],
+])
+globalFormulaRegistry.register("UPPER", [["string"]], "string", "Converts a string to uppercase.", [
+  ["UPPER('hello')", "HELLO"],
+  ["UPPER({{field1}})", undefined],
+])
+globalFormulaRegistry.register("LOWER", [["string"]], "string", "Converts a string to lowercase.", [
+  ["LOWER('HELLO')", "hello"],
+  ["LOWER({{field1}})", undefined],
+])
+globalFormulaRegistry.register(
+  "TRIM",
+  [["string"]],
+  "string",
+  "Removes leading and trailing whitespace from a string.",
+  [
+    ["TRIM('  Hello  ')", "Hello"],
+    ["TRIM({{field1}})", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "LEFT",
+  [["string", "number"]],
+  "string",
+  "Returns the leftmost characters of a string.",
+  [
+    ["LEFT('Hello', 3)", "Hel"],
+    ["LEFT({{field1}}, 3)", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "RIGHT",
+  [["string", "number"]],
+  "string",
+  "Returns the rightmost characters of a string.",
+  [
+    ["RIGHT('Hello', 3)", "llo"],
+    ["RIGHT({{field1}}, 3)", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "MID",
+  [["string", "number", "number"]],
+  "string",
+  "Returns a substring from a string.",
+  [
+    ["MID('Hello', 2, 3)", "llo"],
+    ["MID({{field1}}, 2, 3)", undefined],
+  ],
+)
+globalFormulaRegistry.register("LEN", [["string"]], "number", "Returns the length of a string.", [
+  ["LEN('Hello')", 5],
+  ["LEN({{field1}})", undefined],
+])
+globalFormulaRegistry.register(
+  "REPLACE",
+  [["string", "string", "string"]],
+  "string",
+  "Replaces a substring within a string.",
+  [
+    ["REPLACE('Hello', 'e', 'o')", "Holl"],
+    ["REPLACE({{field1}}, 'e', 'o')", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "SUBSTITUTE",
+  [["string", "string", "string", "number"]],
+  "string",
+  "Replaces a substring within a string.",
+  [
+    ["SUBSTITUTE('Hello', 'e', 'o', 1)", "Holl"],
+    ["SUBSTITUTE({{field1}}, 'e', 'o', 1)", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "REPEAT",
+  [["string", "number"]],
+  "string",
+  "Repeats a string a specified number of times.",
+  [
+    ["REPEAT('Hello', 3)", "HelloHelloHello"],
+    ["REPEAT({{field1}}, 3)", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "SEARCH",
+  [["string", "string"]],
+  "number",
+  "Returns the position of a substring within a string.",
+  [
+    ["SEARCH('Hello', 'e')", 1],
+    ["SEARCH({{field1}}, 'e')", undefined],
+  ],
+)
+globalFormulaRegistry.register(
+  "SUBSTR",
+  [["string", "number", "number"]],
+  "string",
+  "Returns a substring from a string.",
+  [
+    ["SUBSTR('Hello', 2, 3)", "ll"],
+    ["SUBSTR({{field1}}, 2, 3)", undefined],
+  ],
+)
+
+globalFormulaRegistry.register("AND", [["boolean", "variadic"]], "boolean", "Returns true if all arguments are true.", [
+  ["AND(true, true)", true],
+  ["AND({{field1}}, true)", undefined],
+])
+globalFormulaRegistry.register("OR", [["boolean", "variadic"]], "boolean", "Returns true if any argument is true.", [
+  ["OR(true, false)", true],
+  ["OR({{field1}}, false)", undefined],
+])
+globalFormulaRegistry.register("NOT", [["boolean"]], "boolean", "Returns the opposite of a boolean value.", [
+  ["NOT(true)", false],
+  ["NOT({{field1}})", undefined],
+])
+globalFormulaRegistry.register("ISBLANK", [["any"]], "boolean", "Returns true if the value is blank.", [
+  ["ISBLANK('')", true],
+  ["ISBLANK({{field1}})", undefined],
+])
+globalFormulaRegistry.register("ISNUMBER", [["any"]], "boolean", "Returns true if the value is a number.", [
+  ["ISNUMBER(1)", true],
+  ["ISNUMBER({{field1}})", undefined],
+])
+globalFormulaRegistry.register("ISTEXT", [["any"]], "boolean", "Returns true if the value is a text.", [
+  ["ISTEXT('Hello')", true],
+  ["ISTEXT({{field1}})", undefined],
+])
+
+globalFormulaRegistry.register("JSON_EXTRACT", [["string", "string"]], "any", "Extracts a value from a JSON string.", [
+  ["JSON_EXTRACT('{\"name\":\"John\"}', '$.name')", "John"],
+  ["JSON_EXTRACT({{field1}}, '$.name')", undefined],
+])
+
+globalFormulaRegistry.register("RECORD_ID", [], "string", "Returns the ID of the current record.", [
+  ["RECORD_ID()", "rec1"],
+])
+globalFormulaRegistry.register(
+  "AUTO_INCREMENT",
+  [],
+  "number",
+  "Returns the next value in an auto-incrementing sequence.",
+  [["AUTO_INCREMENT()", 1]],
+)
diff --git a/packages/formula/src/formula/registry.ts b/packages/formula/src/formula/registry.ts
deleted file mode 100644
index f852969ff..000000000
--- a/packages/formula/src/formula/registry.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { ParamType, ReturnType, type ExpressionResult } from "../types"
-import { FormulaFunction } from "./formula.type"
-
-interface FunctionDefinition {
-  paramPatterns: ParamType[][]
-  returnType: ReturnType
-}
-
-export class FunctionRegistry {
-  private functions: Map<string, FunctionDefinition> = new Map()
-
-  register(name: FormulaFunction, paramPatterns: ParamType[][], returnType: ReturnType) {
-    this.functions.set(name, { paramPatterns, returnType })
-  }
-
-  get(name: FormulaFunction): FunctionDefinition | undefined {
-    return this.functions.get(name.toUpperCase())
-  }
-
-  isValid(name: string): boolean {
-    return this.functions.has(name.toUpperCase())
-  }
-
-  validateArgs(name: FormulaFunction, args: ExpressionResult[]): void {
-    const funcDef = this.get(name)
-    if (!funcDef) {
-      throw new Error(`Unknown function name: ${name}`)
-    }
-
-    // 检查是否有任何模式的参数数量匹配
-    const hasMatchingPattern = funcDef.paramPatterns.some((pattern) => {
-      // 如果模式中包含 VARIADIC，则参数数量必须大于等于 pattern.length - 1
-      // 否则参数数量必须完全匹配
-      if (pattern.includes("variadic")) {
-        return args.length >= pattern.length - 1
-      }
-      return args.length === pattern.length
-    })
-
-    if (!hasMatchingPattern) {
-      const expectedCounts = funcDef.paramPatterns
-        .map((pattern) => (pattern.includes("variadic") ? `at least ${pattern.length - 1}` : `${pattern.length}`))
-        .join(" or ")
-      throw new Error(`Function ${name} expects ${expectedCounts} arguments, but got ${args.length}`)
-    }
-
-    const isValidPattern = funcDef.paramPatterns.some((pattern) => {
-      for (let i = 0; i < pattern.length; i++) {
-        const expectedType = pattern[i]
-        if (expectedType === "variadic") {
-          // 剩余的所有参数都应该匹配 VARIADIC 的前一个类型
-          const variadicType = pattern[i - 1]
-          return args.slice(i - 1).every((arg) => this.isTypeMatch(arg, variadicType))
-        }
-        if (!this.isTypeMatch(args[i], expectedType)) {
-          return false
-        }
-      }
-      return true
-    })
-
-    if (!isValidPattern) {
-      throw new Error(`Function ${name} arguments do not match: ${JSON.stringify(args)}`)
-    }
-  }
-
-  private isTypeMatch(arg: ExpressionResult, expectedType: ParamType): boolean {
-    if (arg.type === "functionCall") {
-      return arg.returnType === expectedType
-    }
-
-    if (arg.type === "variable") {
-      return true
-    }
-
-    switch (expectedType) {
-      case "number":
-        return arg.type === "number"
-      case "string":
-        return arg.type === "string"
-      case "boolean":
-        return arg.type === "boolean"
-      case "date":
-        // TODO: 假设有日期类型的处理
-        return false
-      case "any":
-        return true
-      default:
-        return false
-    }
-  }
-}
-
-export const globalFunctionRegistry = new FunctionRegistry()
-
-// 注册函数，支持多种参数模式
-globalFunctionRegistry.register("ADD", [["number", "number"]], "number")
-globalFunctionRegistry.register("SUBTRACT", [["number", "number"]], "number")
-globalFunctionRegistry.register("MULTIPLY", [["number", "number"]], "number")
-globalFunctionRegistry.register("DIVIDE", [["number", "number"]], "number")
-globalFunctionRegistry.register("SUM", [["number", "variadic"]], "number")
-globalFunctionRegistry.register("MOD", [["number", "number"]], "number")
-globalFunctionRegistry.register("POWER", [["number", "number"]], "number")
-globalFunctionRegistry.register("SQRT", [["number"]], "number")
-globalFunctionRegistry.register("ABS", [["number"]], "number")
-globalFunctionRegistry.register("ROUND", [["number"]], "number")
-globalFunctionRegistry.register("FLOOR", [["number"]], "number")
-globalFunctionRegistry.register("CEILING", [["number"]], "number")
-globalFunctionRegistry.register("MIN", [["number", "variadic"]], "number")
-globalFunctionRegistry.register("MAX", [["number", "variadic"]], "number")
-globalFunctionRegistry.register("AVERAGE", [["number", "variadic"]], "number")
-
-globalFunctionRegistry.register("CONCAT", [["string", "variadic"]], "string")
-globalFunctionRegistry.register("UPPER", [["string"]], "string")
-globalFunctionRegistry.register("LOWER", [["string"]], "string")
-globalFunctionRegistry.register("TRIM", [["string"]], "string")
-globalFunctionRegistry.register("LEFT", [["string", "number"]], "string")
-globalFunctionRegistry.register("RIGHT", [["string", "number"]], "string")
-globalFunctionRegistry.register("MID", [["string", "number", "number"]], "string")
-globalFunctionRegistry.register("LEN", [["string"]], "number")
-globalFunctionRegistry.register("REPLACE", [["string", "string", "string"]], "string")
-globalFunctionRegistry.register("SUBSTITUTE", [["string", "string", "string", "number"]], "string")
-globalFunctionRegistry.register("REPEAT", [["string", "number"]], "string")
-globalFunctionRegistry.register("SEARCH", [["string", "string"]], "number")
-globalFunctionRegistry.register("SUBSTR", [["string", "number", "number"]], "string")
-
-globalFunctionRegistry.register("AND", [["boolean", "variadic"]], "boolean")
-globalFunctionRegistry.register("OR", [["boolean", "variadic"]], "boolean")
-globalFunctionRegistry.register("NOT", [["boolean"]], "boolean")
-globalFunctionRegistry.register("ISBLANK", [["any"]], "boolean")
-globalFunctionRegistry.register("ISNUMBER", [["any"]], "boolean")
-globalFunctionRegistry.register("ISTEXT", [["any"]], "boolean")
-
-// globalFunctionRegistry.register("COUNT", [["variadic"]], "number")
-// globalFunctionRegistry.register("COUNTA", [["variadic"]], "number")
-// globalFunctionRegistry.register("COUNTIF", [["variadic"]], "number")
-// globalFunctionRegistry.register("SUMIF", [["variadic"]], "number")
-
-globalFunctionRegistry.register("JSON_EXTRACT", [["string", "string"]], "any")
-
-globalFunctionRegistry.register("RECORD_ID", [], "string")
-globalFunctionRegistry.register("AUTO_INCREMENT", [], "number")
diff --git a/packages/formula/src/types.ts b/packages/formula/src/types.ts
index 2df265615..21163b6ba 100644
--- a/packages/formula/src/types.ts
+++ b/packages/formula/src/types.ts
@@ -8,14 +8,14 @@ export const returnType = z.enum(["number", "string", "boolean", "date", "any"])
 
 export type ReturnType = z.infer<typeof returnType>
 
-export type FunctionDefinition = string
+export type FormulaDefinition = string
 
 export type FunctionExpressionResult = {
   type: "functionCall"
   name: string
   arguments: ExpressionResult[]
   returnType: ReturnType
-  value: FunctionDefinition
+  value: FormulaDefinition
 }
 
 export type ArgumentListResult = {