Schema Linking

Resolves ambiguous natural language terms to unique database identifiers. A user query for 'Apple' must be mapped to the correct entity ID based on context—distinguishing between the technology company (entity_type: org) and the fruit (entity_type: food). This process relies on type checking against the schema and contextual cues from neighboring tokens to select the correct canonical entity.

Identifies the correct predicate or foreign key path corresponding to a user's verbal relationship. The phrase 'works for' must be linked to the employment.employer_id property rather than a string match. This involves computing semantic similarity between the natural language predicate and the schema's relation definitions, often using embedding models fine-tuned on domain-specific ontologies.

Standardizes literal values in a query to match the format stored in the database. This includes:

• Date parsing: 'last Tuesday' → 2025-05-13
• Unit conversion: '50 miles' → 80.47 kilometers
• Fuzzy string matching: 'New York City' → NYC Without normalization, syntactically correct queries fail due to format mismatches.

Bridges the gap between high-level user concepts and low-level schema structures. A user asking for 'total sales' may require aggregating across multiple columns (base_price, tax, shipping_fee) or joining several tables (orders, line_items, invoices). The linking mechanism must infer the correct aggregation logic and join path from the schema's foreign key graph.

Maps query terms to schema elements without prior training examples, critical for dynamic or large-scale schemas. Techniques include:

• String matching: Levenshtein distance, n-gram overlap
• Embedding similarity: Cosine distance between query term and column description vectors
• LLM-based selection: Prompting a model to select the most relevant table from a serialized schema representation

Derives implicit filtering conditions from natural language modifiers. The query 'high-value customers in Europe' requires linking 'high-value' to a threshold on customer.lifetime_value and 'Europe' to a geographic constraint on customer.region. This step translates qualitative descriptors into quantitative SQL clauses by referencing schema data types and domain constraints.

The process of disambiguating and matching natural language mentions to their canonical identifiers in a knowledge base. Entity linking maps spans like 'Apple' to the company (Q312) rather than the fruit, while record linkage deduplicates entries across databases. Critical for ensuring schema linking maps to the correct ontological node.

The task of translating natural language utterances into a formal, executable logical form such as SQL, SPARQL, or lambda calculus. A semantic parser converts 'Which director won the most Oscars?' into a structured query with predicates, entities, and aggregation functions that can be executed against a schema.

The process of establishing semantic correspondences between concepts in different ontologies or schemas. When a query uses 'employee' but the database schema uses 'associate', ontology alignment bridges this gap. Techniques include lexical matching, structural graph matching, and embedding-based similarity.

The upstream process of classifying intent, extracting entities, and expanding queries before schema mapping occurs. Includes:

• Intent classification: Is this a lookup, aggregation, or comparison?
• Entity extraction: Identifying spans that map to schema elements
• Query rewriting: Expanding 'last year' to a specific date range

A retrieval-augmented generation approach that constructs a knowledge graph from source documents and performs community summarization. Schema linking in GraphRAG involves mapping query entities to graph nodes and traversing relationships to retrieve holistic, structured context rather than isolated text chunks.

An approach where a model's logical chain is strictly causally determined by the provided schema and data. In schema linking, faithful reasoning ensures that the generated query accurately reflects the database structure—preventing hallucinated column names, fabricated joins, or non-existent relationships.