Database Entity Recognition: Concepts & Methods

• Database Entity Recognition is a multifaceted topic that formalizes, links, and resolves database-specific entities across several workflows.
• Techniques include data augmentation, transformer-based tagging, and probabilistic blocking to boost precision and recall by over 10%.
• DB-ER underpins trustworthy automation by generating executable ER models, safe APIs, and privacy-aware query routing in modern databases.

Searching arXiv for papers related to "Database Entity Recognition" and adjacent formulations. tool call: arxiv_search(query="\"Database Entity Recognition\" OR \"entity resolution\" database natural language queries ER model partitioning", max_results=10, sort_by="submittedDate")

tool result: [{"arxiv_id":"(Fu et al., 26 Aug 2025)","title":"Database Entity Recognition with Data Augmentation and Deep Learning","authors":["Yakov Galka","Yoni Chaiter","Nir Dagan","Elior Sulem"],"summary":"This paper addresses the challenge of Database Entity Recognition (DB-ER) in Natural Language Queries (NLQ). We present several key contributions to advance this field: (1) a human-annotated benchmark for DB-ER task, derived from popular text-to-sql benchmarks, (2) a novel data augmentation procedure that leverages automatic annotation of NLQs based on the corresponding SQL queries which are available in popular text-to-SQL benchmarks, (3) a specialized LLM based entity recognition model using T5 as a backbone and two down-stream DB-ER tasks: sequence tagging and token classification for fine-tuning of backend and performing DB-ER respectively. We compared our DB-ER tagger with two state-of-the-art NER taggers, and observed better performance in both precision and recall for our model. The ablation evaluation shows that data augmentation boosts precision and recall by over 10%, while fine-tuning of the T5 backbone boosts these metrics by 5-10%."},{"arxiv_id":"(Wang et al., 2 Apr 2025)","title":"FastER: Fast On-Demand Entity Resolution in Property Graphs","authors":["Zhe Bai","Pengjian Xie","Yongluan Zhou","Kai Zheng","Xuemin Lin"],"summary":"Entity resolution (ER) is the problem of identifying and linking database records that refer to the same real-world entity. Traditional ER methods use batch processing, which becomes impractical with growing data volumes due to high computational costs and lack of real-time capabilities. In many applications, users need to resolve entities for only a small portion of their data, making full data processing unnecessary -- a scenario known as \"ER-on-demand\". This paper proposes FastER, an efficient ER-on-demand framework for property graphs. Our approach uses graph differential dependencies (GDDs) as a knowledge encoding language to design effective filtering mechanisms that leverage both structural and attribute semantics of graphs. We construct a blocking graph from filtered subgraphs to reduce the number of candidate entity pairs requiring comparison. Additionally, FastER incorporates Progressive Profile Scheduling (PPS), allowing the system to incrementally produce results throughout the resolution process. Extensive evaluations on multiple benchmark datasets demonstrate that FastER significantly outperforms state-of-the-art ER methods in computational efficiency and real-time processing for on-demand tasks while ensuring reliability. We make FastER publicly available at: https://anonymous.4open.science/r/On_Demand_Entity_Resolution-9DFB"},{"arxiv_id":"([2601.01254](/papers/2601.01254))","title":"Entity-Aware and Secure Query Optimization in Database Using Named Entity Recognition","authors":["Nandagopal Dhanapal","D. Ramya","Mohmed Kays Rassas","Abdullah Alharbi","Mohammed A. Abuhasel","Anis El Ferjani"],"summary":"Cloud storage has become the backbone of modern data infrastructure, yet privacy and efficient data retrieval remain significant challenges. Traditional privacy-preserving approaches primarily focus on enhancing database security but fail to address the automatic identification of sensitive information before encryption. This can dramatically reduce query processing time and mitigate errors during manual identification of sensitive information, thereby reducing potential privacy risks. To address this limitation, this research proposes an intelligent privacy-preserving query optimization framework that integrates Named Entity Recognition (NER) to detect sensitive information in queries, utilizing secure data encryption and query optimization techniques for both sensitive and non-sensitive data in parallel, thereby enabling efficient database optimization. Combined deep learning algorithms and transformer-based models to detect and classify sensitive entities with high precision, and the Advanced Encryption Standard (AES) algorithm to encrypt, with blind indexing to secure search functionality of the sensitive data, whereas non-sensitive data was divided into groups using the K-means algorithm, along with a rank search for optimization. Among all NER models, the Deep Belief Network combined with Long Short-Term Memory (DBN-LSTM) delivers the best performance, with an accuracy of 93% and precision (94%), recall, and F1 score of 93%, and 93%, respectively. Besides, encrypted search achieved considerably faster results with the help of blind indexing, and non-sensitive data fetching also outperformed traditional clustering-based searches. By integrating sensitive data detection, encryption, and query optimization, this work advances the state of privacy-preserving computation in modern cloud infrastructures."},{"arxiv_id":"(Pieris et al., 2020)","title":"ER model Partitioning: Towards Trustworthy Automated Systems Development","authors":["T. A. E. Silva","U. M. Yapa","N. N. Jayasinghe"],"summary":"In database development, a conceptual model is created, in the form of an Entity-relationship(ER) model, and transformed to a relational database schema (RDS) to create the database. However, some important information represented on the ER model may not be transformed and represented on the RDS. This situation causes a loss of information during the transformation process. With a view to preserving information, in our previous study, we standardized the transformation process as a one-to-one and onto mapping from the ER model to the RDS. For this purpose, we modified the ER model and the transformation algorithm resolving some deficiencies existed in them. Since the mapping was established using a few real-world cases as a basis and for verification purposes, a formal-proof is necessary to validate the work. Thus, the ongoing research aiming to create a proof will show how a given ER model can be partitioned into a unique set of segments and use it to represent the ER model itself. How the findings can be used to complete the proof in the future will also be explained. Significance of the research on automating database development, teaching conceptual modeling, and using formal methods will also be discussed."},{"arxiv_id":"(Kaufmann, 2022)","title":"The Lokahi Prototype: Toward the automatic Extraction of Entity Relationship Models from Text","authors":["Ragnar Rosenfeld","Christian Janiesch","Patrick Zschech","Wolfgang Ulbricht"],"summary":"Entity relationship extraction envisions the automatic generation of semantic data models from collections of text, by automatic recognition of entities, by association of entities to form relationships, and by classifying these instances to assign them to entity sets (or classes) and relationship sets (or associations). As a first step in this direction, the Lokahi prototype can extract entities based on the TF*IDF measure, and generate semantic relationships based on document-level co-occurrence statistics, for example with likelihood ratios and pointwise mutual information. This paper presents results of an explorative, prototypical, qualitative and synthetic research, summarizes insights from two research projects and, based on this, indicates an outline for further research in the field of entity relationship extraction from text."},{"arxiv_id":"(Bahmani et al., 2016)","title":"Enforcing Relational Matching Dependencies with Datalog for Entity Resolution","authors":["Leopoldo Bertossi","Enrico Gallinucci","M. Kianpour"],"summary":"Entity resolution (ER) is about identifying and merging records in a database that represent the same real-world entity. Matching dependencies (MDs) have been introduced and investigated as declarative rules that specify ER policies. An ER process induced by MDs over a dirty instance leads to multiple clean instances, in general. General \"answer sets programs\" have been proposed to specify the MD-based cleaning task and its results. In this work, we extend MDs to \"relational MDs\", which capture more application semantics, and identify classes of relational MDs for which the general ASP can be automatically rewritten into a stratified Datalog program, with the single clean instance as its standard model."},{"arxiv_id":"(Marchant et al., 2019)","title":"d-blink: Distributed End-to-End Bayesian Entity Resolution","authors":["Katherine M. Tan","David B. Dunson","Jason Xu"],"summary":"Entity resolution (ER; also known as record linkage or de-duplication) is the process of merging noisy databases, often in the absence of unique identifiers. A major advancement in ER methodology has been the application of Bayesian generative models, which provide a natural framework for inferring latent entities with rigorous quantification of uncertainty. Despite these advantages, existing models are severely limited in practice, as standard inference algorithms scale quadratically in the number of records. While scaling can be managed by fitting the model on separate blocks of the data, such a naïve approach may induce significant error in the posterior. In this paper, we propose a principled model for scalable Bayesian ER, called \"distributed Bayesian linkage\" or d-blink, which jointly performs blocking and ER without compromising posterior correctness. Our approach relies on several key ideas, including: (i) an auxiliary variable representation that induces a partition of the entities and records into blocks; (ii) a method for constructing well-balanced blocks based on k-d trees; (iii) a distributed partially-collapsed Gibbs sampler with improved mixing; and (iv) fast algorithms for performing Gibbs updates. Empirical studies on six data sets—including a case study on the 2010 Decennial Census—demonstrate the scalability and effectiveness of our approach."},{"arxiv_id":"(Grant et al., 2015)","title":"Query-Driven Sampling for Collective Entity Resolution","authors":["Khaled Khashabi","Richard G. Desai","Theodoros Rekatsinas","Georgia Koutrika","Aditya G. Parameswaran"],"summary":"Probabilistic databases play a preeminent role in the processing and management of uncertain data. Recently, many database research efforts have integrated probabilistic models into databases to support tasks such as information extraction and labeling. Many of these efforts are based on batch oriented inference which inhibits a realtime workflow. One important task is entity resolution (ER). ER is the process of determining records (mentions) in a database that correspond to the same real-world entity. Traditional pairwise ER methods can lead to inconsistencies and low accuracy due to localized decisions. Leading ER systems solve this problem by collectively resolving all records using a probabilistic graphical model and Markov chain Monte Carlo (MCMC) inference. However, for large datasets this is an extremely expensive process. One key observation is that, such exhaustive ER process incurs a huge up-front cost, which is wasteful in practice because most users are interested in only a small subset of entities. In this paper, we advocate pay-as-you-go entity resolution by developing a number of query-driven collective ER techniques. We introduce two classes of SQL queries that involve ER operators --- selection-driven ER and join-driven ER. We implement novel variations of the MCMC Metropolis Hastings algorithm to generate biased samples and selectivity-based scheduling algorithms to support the two classes of ER queries. Finally, we show that query-driven ER algorithms can converge and return results within minutes over a database populated with the extraction from a newswire dataset containing 71 million mentions."},{"arxiv_id":"(0711.0348)","title":"Compiling ER Specifications into Declarative Programs","authors":["Michael Hanus","Bernd Braßel","Frank Huch"],"summary":"This paper proposes an environment to support high-level database programming in a declarative programming language. In order to ensure safe database updates, all access and update operations related to the database are generated from high-level descriptions in the entity- relationship (ER) model. We propose a representation of ER diagrams in the declarative language Curry so that they can be constructed by various tools and then translated into this representation. Furthermore, we have implemented a compiler from this representation into a Curry program that provides access and update operations based on a high-level API for database programming."},{"arxiv_id":"(Hanus et al., 2011)","title":"An ER-based Framework for Declarative Web Programming","authors":["Michael Hanus","Johannes P. Hofmann"],"summary":"We describe a framework to support the implementation of web-based systems intended to manipulate data stored in relational databases. Since the conceptual model of a relational database is often specified as an entity-relationship (ER) model, we propose to use the ER model to generate a complete implementation in the declarative programming language Curry. This implementation contains operations to create and manipulate entities of the data model, supports authentication, authorization, session handling, and the composition of individual operations to user processes. Furthermore, the implementation ensures the consistency of the database w.r.t. the data dependencies specified in the ER model, i.e., updates initiated by the user cannot lead to an inconsistent state of the database. In order to generate a high-level declarative implementation that can be easily adapted to individual customer requirements, the framework exploits previous works on declarative database programming and web user interface construction in Curry."} Taken together, these works suggest that Database Entity Recognition (DB-ER) is best understood as an umbrella label for several database-centered tasks in which entities and relationships are treated as explicit semantic objects. In different strands, DB-ER refers to recognizing table names, column names, and values in natural language queries for text-to-SQL; resolving records or mentions that denote the same real-world entity; formalizing entity-relationship constructs so they can be transformed to relational database schemas without semantic loss; and extracting ER structures from text or from security-sensitive query streams (Fu et al., 26 Aug 2025, Grant et al., 2015, Pieris et al., 2020).

1. Terminological scope and research strands

The literature does not use DB-ER as a single stabilized term. Instead, it spans several adjacent problem settings, each centered on the status of entities in database workflows.

Research usage	Primary object of recognition	Representative formulation
Conceptual ER formalization	ER constructs, keys, attributes, min-max constraints	Modified ER notation and ER-construct-units (Pieris, 2013, Pieris et al., 2020)
NLQ-oriented DB-ER	Table names, column names, cell values	Token labels $T$, $C$, $V$, and none (Fu et al., 26 Aug 2025)
Database entity resolution	Mentions or records referring to the same real-world entity	Query-driven, declarative, Bayesian, and graph ER (Grant et al., 2015, Bahmani et al., 2016, Marchant et al., 2019, Wang et al., 2 Apr 2025)
Text-to-schema extraction	Entities, relationships, entity sets, relationship sets from corpora	Automatic extraction of ER models from text (Kaufmann, 2022)
Security-oriented query processing	Sensitive entities in database-related text	NER-driven routing of sensitive and non-sensitive content (Sultana et al., 3 Jan 2026)

A recurring source of confusion is the overloaded abbreviation “ER.” In some papers it denotes entity-relationship modeling, while in others it denotes entity resolution. The overlap is not merely terminological. Both traditions are concerned with preserving semantics of entities across transformations: ER-model work asks whether conceptual structure survives mapping to relational form, while entity-resolution work asks whether multiple records or mentions can be identified as the same underlying entity without losing integrity, uncertainty information, or query-time efficiency.

Another common simplification is to equate DB-ER with generic named entity recognition. The DB-ER literature represented here does not support that reduction. In the NLQ setting, the target labels are database-specific schema objects such as tables, columns, and values rather than open-domain categories like person or organization; in entity-resolution settings, the task is not span labeling at all, but linking or merging tuples, mentions, or graph nodes.

2. Formalization in entity-relationship modeling

One major DB-ER strand is concerned with the semantics of conceptual database models and their preservation under ER-to-relational transformation. The problem is stated directly: when an ER model is transformed into a relational database schema, semantically important elements may disappear or become only partially represented. The elements explicitly identified as vulnerable include min-max constraints, role names, composite attributes, subtype/supertype hierarchies, and certain relationship types. The 2020 partitioning work aligns itself with Hainaut’s view that if forward transformation preserves information, then the reverse transformation should reconstruct the conceptual schema, and it treats irreversibility as evidence of information loss (Pieris et al., 2020).

The 2013 modified-notation work responds by tightening the definition of the conceptual source model. A regular entity type must have at least one key attribute of its own; that key “should be in its atomic non divisible level”; and a regular entity’s key must be a single attribute rather than a combination of two or more attributes. The notation also strengthens subtype criteria, requiring “at least one intrinsic or mutual property,” clarifies weak entity semantics through double-lined notation and partial keys, enforces naming discipline, and adopts min-max cardinality ratio constraints rather than only coarse $1{:}1$ or $1{:}N$ labels. The stated target is a relational schema that is “semantically clear, complete, and accurate with respect to its predecessor ERD and is easy to reverse back to the ERD without any intuition” (Pieris, 2013).

The formalization step in the 2020 paper pushes this program further by partitioning a modified ER model into irreducible “ER-construct-units.” For a regular entity type $e_i$, key attribute $k(e_i)$, and mandatory simple attribute $s_1(e_i)$, the paper defines the base unit $b(e_i)$. Secondary simple attributes $\{s_t(e_i) / t \ge 2\}$ form a distinct unit $C$0. For a binary relationship $C$1, the relationship together with min-max constraint pairs $C$2 and $C$3 forms the unit $C$4, while optional relationship attributes form $C$5. In the generic case with two regular entities and one binary relationship, the model is partitioned into the six distinct units

$C$6

which are described as distinct, non-overlapping, and collectively exhaustive (Pieris et al., 2020).

This line of work treats DB-ER as a precondition for trustworthy automation. The intended theorem is a one-to-one and onto mapping from modified ER model to RDS, with a future proof strategy based on corresponding relation-schema-units on the relational side. The scope remains limited: the current formulation handles binary relationships between two regular entity types, excludes recursive relationship types, and does not address ternary or higher-degree relationships. Even so, it frames DB-ER as a formal methods problem rather than only a notation problem.

3. DB-ER for natural language queries and schema linking

A distinct and explicitly named DB-ER formulation appears in recent text-to-SQL research. Here DB-ER is a specialized named entity recognition task for natural language queries, intended to identify text spans that refer to database-specific entities required for schema grounding. The recognized entity types are table names $C$7, column names $C$8, and cell values or literal values $C$9; non-entity tokens receive the label none. The paper also evaluates coarser settings: a 3-class formulation with $V$0, $V$1, and $V$2, and a 2-class formulation of entity versus non-entity (Fu et al., 26 Aug 2025).

The benchmark is built from Spider and BIRD, using paired NLQ and SQL examples. Human annotation was carried out on a web-based collaborative platform with access to the question, the associated SQL query, and the underlying database schema. The reported dataset sizes are 1,000 manually annotated examples for human train, 500 for human test, and 15,000 automatically annotated examples for synthetic train. Token distributions across human and synthetic data are described as very similar, with roughly 29% entity tokens and 71% background tokens (Fu et al., 26 Aug 2025).

The synthetic annotation function is formalized as

$V$3

Its pipeline first parses SQL into an abstract syntax tree and extracts tables, columns, and values. It then searches over all spans in the NLQ for candidates whose similarity to a database entity exceeds a threshold $V$4, using Jaccard similarity over 3-grams and Levenshtein edit distance. Span assignment is posed as an integer linear program with non-overlap constraints and solved with a CP-SAT / integer programming solver. The threshold and similarity function are selected by grid search against human-annotated data (Fu et al., 26 Aug 2025).

The model architecture uses T5 in two stages. In the sequence-tagging stage, reserved output tokens encode labels: <id_0> for none, <id_1> for table, <id_2> for column, and <id_3> for value. In the downstream stage, the fine-tuned T5 encoder is frozen and a linear classifier predicts one of $V$5 for each token. The strongest reported configuration is T5-Large with synthetic training and fine-tuning of the backbone, achieving Table F1 70.2, Column F1 68.8, Value F1 77.9, and 2-class entity F1 80.8. The paper states that data augmentation boosts precision and recall by over 10%, and that fine-tuning the T5 backbone boosts these metrics by 5–10% (Fu et al., 26 Aug 2025).

This DB-ER formulation is explicitly tied to schema linking. The paper’s practical claim is that DB-ER can function as an intermediate supervision task for query understanding, isolating and improving the recognition of schema-relevant spans before SQL generation. It also underscores that generic NER transfer is insufficient: schema-specific vocabulary remains difficult, and direct seq2seq tag generation is markedly weaker than the frozen-encoder plus linear-classifier approach when supervision is scarce.

4. Record linkage, collective inference, and on-demand entity resolution

A second major DB-ER family concerns entity resolution: identifying and merging records or mentions in a database that correspond to the same real-world entity. In probabilistic databases, query-driven collective ER was proposed as a pay-as-you-go alternative to exhaustive batch resolution. The 2015 work introduces SQL-like ER operators for two query classes: selection-driven ER for one target entity and join-driven ER for watchlists or multiple targets. The probabilistic model is a factor graph $V$6, and inference uses Metropolis-Hastings MCMC with query-biased proposals. The three single-query variants are target-fixed, query-proportional, and hybrid; for multi-query workloads, selectivity-based scheduling is reported as the best overall strategy. On the NYT / Gigaword newswire corpus with 71,433,375 mentions, the paper’s headline claim is that single-node queries converge to high-quality entities in 1–2 minutes (Grant et al., 2015).

A more declarative formulation appears in matching-dependency research. Standard matching dependencies have the form

$V$7

where similarity on the left-hand side triggers enforced equality on the right-hand side. The 2016 extension to relational MDs allows additional database atoms in the left-hand side, so ER policies can depend on relational context rather than only tuple-local similarity. The paper identifies three important classes—similarity-preserving MDs, non-interacting MDs, and SFAI combinations $V$8—for which a general ASP specification can be rewritten into stratified Datalog whose unique standard model is the single clean instance. In those cases ER becomes a deterministic bottom-up computation with polynomial-time data complexity (Bahmani et al., 2016).

Bayesian ER addresses a different concern: scalability without sacrificing posterior correctness. In d-blink, entity resolution, blocking, and merging are integrated in one posterior model by introducing auxiliary block variables $V$9. A deterministic blocking function

$1{:}1$0

partitions the latent entity space, while k-d trees are used to construct well-balanced blocks. Inference relies on a distributed partially-collapsed Gibbs sampler, with PCG-I reported as the preferred practical variant. The paper reports efficiency gains in excess of 300$1{:}1$1 relative to blink, and in the Wyoming Census / SSA Numident case study on about 1,050,000 records it estimates the number of unique individuals with posterior mean 616,000 and standard error 5,000 (Marchant et al., 2019).

Property-graph settings motivate a further shift from batch ER to ER-on-demand. FastER defines a graph differential dependency as

$1{:}1$2

combining graph patterns with distance constraints over attributes, identities, and relation labels. Its workflow has three stages: graph pattern filtering, constraint-based filtering, and blocking-graph construction with Progressive Profile Scheduling. Candidate entity pairs are reduced by factors of $1{:}1$3 to $1{:}1$4 in practice, and emitted results are verified at the entity level. The paper reports a 0% error rate for the first $1{:}1$5 emitted entities and states that the final matching confirmation stage guarantees precision of 1, which is why precision and F1 are not used as evaluation metrics (Wang et al., 2 Apr 2025).

Across these subfields, DB-ER is not a single inference scheme but a spectrum of design choices. Some methods prioritize collective probabilistic inference, some prioritize declarative semantics and clean-instance guarantees, some preserve posterior correctness under scalable blocking, and some prioritize progressive real-time output on query-relevant subsets.

5. Compilation, generated APIs, and ER-driven software synthesis

Another DB-ER trajectory treats the ER model as an executable specification from which database programs and web systems can be generated. In Curry-based work, an ER diagram is represented by the data type $1{:}N$7 with entities, attributes, domains, keys, nullability, relationships, relationship ends, and cardinalities represented explicitly. The compiler pipeline has three phases: translation from tool-specific ERD format into the Curry ERD term, transformation of relationships into relational form, and code generation using a Database library. Relationships are mapped according to cardinality, with simple-simple relations becoming foreign keys with possible Unique constraints, simple-complex relations becoming foreign keys on the many side, and complex-complex relations becoming new relations. The generated API separates Query, Transaction, and IO, includes integrity checks for uniqueness, foreign-key existence, and min/max cardinalities, and deliberately omits general delete operations because safe cascading behavior is difficult to generate automatically (0711.0348).

This design makes DB-ER operational rather than merely descriptive. Entities become typed Curry data types and persistent dynamic predicates; relationships become safe access paths; and ER constraints become executable integrity checks. Constructor-like operations follow a general pattern of running a sequence of checks before committing a new entry, and a global checkAllData transaction can validate the entire database after unsafe changes or periodically (0711.0348).

The same perspective is extended to full web application generation in the Spicey framework. Starting from an ERD, Spicey generates model code, safe database operations, views, controllers, routing, session support, authentication and authorization hooks, and process specifications for multi-step workflows. The framework’s blog example includes entities such as Entry, Comment, and Tag, relationships such as Commenting and Tagging, and generated operations like newEntry and newCommentWithEntryCommentingKey. The system also generates query operations such as queryCommentsOfEntry, where relationship predicates constrain which entities are returned. A central property is that updates initiated by users cannot lead to an inconsistent state of the database with respect to the data dependencies specified in the ER model (Hanus et al., 2011).

In this software-synthesis strand, DB-ER is closely tied to the idea that conceptual models should determine executable behavior. The ER model ceases to be only a design artifact; it becomes the source of safe CRUD logic, authorization envelopes, session-aware controllers, and user processes. This suggests a strong connection between DB-ER and trustworthy automation, especially when the target is not only a schema but a complete data-manipulating system.

6. Text-derived ER models and security-oriented recognition

A further extension of DB-ER shifts the source of entities away from curated schemas and toward unstructured text. The Lokahi prototype formulates a simplified ER structure as

$1{:}1$6

where $1{:}1$7 is a set of entities, $1{:}1$8 is a set of binary relationships, $1{:}1$9 is a set of entity classes, and $1{:}N$0 is a set of relationship classes. The prototype extracts entities by TF*IDF scoring,

$1{:}N$1

with

$1{:}N$2

and also studies a modified variant

$1{:}N$3

Relationships are generated from document-level co-occurrence using pointwise mutual information

$1{:}N$4

and likelihood ratio

$1{:}N$5

The implementation extends Lucene, indexes around 500K Wikipedia articles, and emphasizes qualitative, exploratory evaluation rather than benchmarked accuracy (Kaufmann, 2022).

Here DB-ER is explicitly a schema-induction problem: text is mined for candidate entities and relations, which are then intended to be abstracted into entity sets and association sets. The paper is careful to characterize itself as prototypical and synthetic research, and it leaves automatic class formation, relation-type induction, and richer semantics as future work (Kaufmann, 2022).

A different text-facing application is security-aware query optimization. In this formulation, NER is used to separate sensitive from non-sensitive entities in database-related text, especially NoSQL query/content fields. The explicitly listed sensitive entity types are PASSPORT, PHONE, CREDIT_CARD, EMAIL, SSN, URL, and PAYMENT. The preprocessing pipeline includes segmentation, tokenization, punctuation removal, regex-based pattern detection, IOB annotation, and Word2Vec-based vectorization; the data split is 80:20 with 10-fold cross-validation. Compared models include BiLSTM, CNN, CNN-LSTM, DBN-LSTM, BERT, and XLNet, with DBN-LSTM reported as best at 93% accuracy, 94% precision, 93% recall, and 93% F1-score (Sultana et al., 3 Jan 2026).

The downstream system uses this recognition result as a routing layer. Sensitive entities are encrypted with AES and indexed through blind indexing for searchable encryption; non-sensitive content is represented with TF-IDF, clustered by K-means, and ranked by cosine similarity,

$1{:}N$6

The paper reports that blind index lookup is essentially constant time, with direct search at 100K records taking about 5–20 ms, blind index search about 0.0001 ms, and a claimed improvement of 50,000–200,000x faster. In this strand, DB-ER is neither schema linking nor entity resolution; it is the enabling mechanism for privacy-preserving, branch-specific query execution (Sultana et al., 3 Jan 2026).

7. Misconceptions, limits, and open directions

The first misconception dispelled by this literature is that DB-ER names a single technical problem. The evidence here points instead to several non-equivalent but related problem families: ER-model formalization, natural-language schema linking, record linkage and entity resolution, text-driven ER extraction, and security-oriented sensitive-entity detection. Treating them as identical obscures crucial differences in inputs, outputs, and correctness criteria (Pieris et al., 2020, Fu et al., 26 Aug 2025, Grant et al., 2015).

The second misconception is that standard ER notation and conventional ER-to-relational transformation are already information-preserving. The modified-notation and partitioning papers explicitly dispute that assumption. They argue that conventional workflows can lose semantically important constructs, and the formal proof of a bijection between ER model and relational database schema remains incomplete. The current formalization is restricted to modified ER models with binary relationships between two regular entity types and does not yet extend to recursive, ternary, or higher-degree cases (Pieris, 2013, Pieris et al., 2020).

The third misconception is that high-quality entity resolution must be global and batch-oriented. Query-driven collective ER, Bayesian blocking with posterior correctness, and graph ER-on-demand all show that on-demand and progressive settings are viable. At the same time, their limitations are explicit: convergence is difficult to verify in practice, SFAI is instance-dependent, GDDs must be available or mined beforehand, and the effectiveness of on-demand filtering depends strongly on rule quality and threshold choice (Grant et al., 2015, Bahmani et al., 2016, Wang et al., 2 Apr 2025, Marchant et al., 2019).

The fourth misconception is that general NER transfer is sufficient for database-centered entity tasks. In NLQ DB-ER, synthetic augmentation still relies on lexical similarity and may miss paraphrases, implicit mentions, and indirect references. In the security-oriented framework, sensitive-entity detection is built around a finite set of PII-like categories plus regex- and IOB-driven preprocessing. The Lokahi line, meanwhile, remains largely qualitative and acknowledges that n-gram composition, automatic class formation, and full ER schema induction are unresolved (Fu et al., 26 Aug 2025, Sultana et al., 3 Jan 2026, Kaufmann, 2022).

A plausible synthesis is that DB-ER research is converging not toward one canonical algorithm but toward a layered view of database semantics. In that view, entities may need to be notated precisely, recognized in language, resolved across noisy records, compiled into safe programs, extracted from text, or routed differently according to privacy constraints. The heterogeneity is substantive rather than accidental: each strand addresses a different place where database entities risk becoming ambiguous, lossy, unsafe, or computationally impractical.