arXiv:2607.22843v1 [cs.DB] 24 Jul 2026
Queryable Self-Organizing Maps: A Database Abstraction for Topology-Driven Data Exploration Denis Mayr Lima Martins∗
Gottfried Vossen
Department of Computing and Mathematics University of Sao Paulo Ribeirão Preto, São Paulo, Brazil [email protected]
Department of Information Systems University of Münster Münster, Germany [email protected]
Abstract
Motivating Example
Self-Organizing Maps (SOMs) have long been used as exploratory tools for high-dimensional data: they organize objects into a twodimensional topology that reveals clusters, gradients, sparse regions, dense regions, and boundaries. Yet, in modern data systems, SOMs are typically trained and visualized outside the DBMS, disconnected from the relational data they summarize. We introduce the abstraction of a queryable data map: a learned topological artifact consisting of representatives, neighborhood relations, object assignments, and derived summaries. We instantiate this idea with MapDB, a lightweight prototype that makes SOM artifacts queryable so users can explore data topology without leaving the database. Experimental study shows that SOM training is feasible at moderate analytical scale, that map queries are interactive after materialization, and that SOM regions provide meaningful targets for exploratory SQL.
Consider an analyst investigating a customer table with dozens of behavioral attributes, or a customer-level analytical view derived from customer, orders, lineitem, and supplier. The analyst may not yet know which predicates are useful, which combinations of attributes define recurring profiles, where unusual objects lie, or whether a transition between two populations is sharp or gradual. Conventional SQL assumes that the analyst already knows what to filter, group, or compare. This leads to an important gap between relational querying and exploratory understanding.
ACM Reference Format: Denis Mayr Lima Martins and Gottfried Vossen. 2027. Queryable SelfOrganizing Maps: A Database Abstraction for Topology-Driven Data Exploration . In Proceedings of Conference 2026 (Conference’26). ACM, New York, NY, USA, 6 pages. https://doi.org/XXXXXXX.XXXXXXX
1
Introduction
Before analysts can write precise SQL predicates, they often need to understand the shape of the data. This is difficult in high-dimensional relational datasets, where clusters, gradients, outliers, and boundaries may involve many interacting attributes. We fuse the concept of Self-Organizing Maps (SOMs) [1, 4, 5] with relational databases in MapDB, making the former intensional data that can be queried just like other databse objects.
∗ Both authors contributed equally to this research.
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. Conference’26, place © 2027 Copyright held by the owner/author(s). Publication rights licensed to ACM. ACM ISBN 978-1-4503-XXXX-X/2018/06 https://doi.org/XXXXXXX.XXXXXXX
SOMs are a compelling example of a structure that addresses this gap. A SOM organizes high-dimensional data over a lowdimensional lattice while encouraging nearby map units to represent similar input profiles [4], As a result, SOMs have been widely used as exploratory data maps [7, 8], where: • hit maps reveal dense and sparse areas; • Unified-Distance- or U-Matrices reveal local boundaries; • component planes reveal feature gradients; • prototype vectors summarize local profiles; and • assignments connect objects to topological regions. Despite this exploratory role, SOMs are usually produced outside the database system as transient Python, R, or visualization artifacts. The source data remains queryable, but the map that explains the data is not. This separation is harmful: map regions cannot be naturally joined with source tuples; map versions are not governed by the DBMS; and exploratory recommendations cannot directly exploit the learned topology. If a SOM helps an analyst decide where to look, then the DBMS should know what the SOM contains. This paper proposes that SOMs should be treated as intensional data: persistent, learned topological artifacts stored and queried inside the DBMS. The key observation is that a SOM is almost embarrassingly relational. It consists of neurons, prototype vectors, topology edges, object-to-neuron assignments, and derived summaries such as hit counts, U-Matrix values, and component planes. Each of these objects can be represented as a relation. We present MapDB, a lightweight prototype that stores and queries SOMs inside a relational database. MapDB does not aim to outperform specialized SOM libraries. Instead, it demonstrates a database abstraction: exploratory maps can be stored, queried, joined, versioned, and reused like other database artifacts. This enables SQL queries over specific regions of the map, and finding source tuples that are mapped near a selected neuron. The paper makes four contributions:
Conference’26, date, place
(1) We introduce learned maps as intensional data, arguing that persistent topology can provide a queryable organization over relational tuples. (2) We present MapDB, a relational representation and SQLresident execution substrate for SOM neurons, prototypes, topology, assignments, and summaries. (3) We introduce a compact family of map-aware SQL extensions for map creation, density analysis, U-Matrix inspection, component-plane queries, neighborhood traversal, region drill-down, boundary discovery, and selective summary materialization. (4) We provide a comprehensive evaluation covering scalability, flat-clustering baselines, materialization trade-offs, map-size sensitivity, TPC-H scaling, and single-table and multi-table case studies.
Martins et al. Map-aware SQL Declarative interface for learned topology Map Compiler CREATE MAP compile parsing, binding, rewriting, MAP_BMU() and cost-based selection MAP_UMATRIX() virtual vs. materialized MAP_NEIGHBORHOOD() artifact choice MAP_RECOMMEND()
lower
Logical Map Operations Relational Plan BMUM (R) assign tuples joins over assignments rewrite NBRM (v, r) traverse topology filters over topology edges UMATM boundary query aggregates over prototype weights COMPM (f ) component plane scans over materialized summaries REGIONM (P ) select map regions ordinary relational algebra
catalog lookup
select artifact
Persistent Map State (base representation) SOM_NEURON SOM_WEIGHT SOM_EDGE SOM_ASSIGNMENT FEATURE_VIEW
Materialized Summaries (optional cached artifacts) SOM_HITMAP SOM_UMATRIX SOM_COMPONENT SOM_REGION SOM_SUMMARY
Backend DBMS Execution Engine executes joins, scans, aggregations, window functions, and materialized-view access
Figure 1: MapDB architecture. Map-aware SQL operations compile to logical map operations and then to relational plans over persistent map state or materialized summaries. The backend DBMS executes the resulting plan. Table 1: MapDB core relations.
2
From Visual SOMs to Queryable Data Maps
SOMs are typically consumed as visualizations. A user inspects a two-dimensional map and manually interprets dense regions, boundaries, and feature gradients. However, a visualization alone is not enough for database exploration. A useful exploratory map should support selection, filtering, joining, aggregation, versioning, comparison, and provenance. These are database responsibilities. We therefore define a queryable data map as a learned topological artifact: M = (𝑉 , 𝐸,𝑊 , 𝐴, 𝑆), (1) where 𝑉 is a set of map units, 𝐸 ⊆ 𝑉 ×𝑉 is a neighborhood relation, 𝑊 stores representative parameters, 𝐴 assigns database objects to map units, and 𝑆 stores derived summaries over the map. For a SOM, 𝑉 is the set of neurons, 𝐸 is the lattice topology, 𝑊 is the set of prototype vectors, 𝐴 is the best-matching-unit assignment relation, and 𝑆 includes U-Matrix values, hit counts, component planes, and local error summaries. The important point is that M is both visual and relational. It supports visual exploration because it can be rendered as a map. It supports database exploration because each component is queryable. This abstraction is related to the broader view that learned models can be treated as database artifacts rather than opaque external objects [2]. However, SOMs add an exploratory dimension. They are not only functions to evaluate; they are maps that organize the data space. This makes them particularly suitable for data exploration, workload understanding, and topology-aware recommendation.
3
Relation
Meaning
MAP_NEURON MAP_WEIGHT MAP_EDGE MAP_ASSIGNMENT MAP_SUMMARY
map units and positions prototype values topology relation object-to-unit mapping derived summaries
MAP_CATALOG(map_id, map_name, source_relation, object_id_column, rows, cols, current_epoch, status) MAP_FEATURE(map_id, feature_id, feature_name, transform_spec)
The input data are represented as a long feature relation: MAP_INPUT_LONG(object_id, feature_id, value)
This representation is flexible and uniform: the same SQL patterns support different datasets and feature spaces. Dense numerical datasets can also be stored in wide format or vector columns; we use the long format because it exposes the relational structure most clearly. Training. For input object object 𝑥𝑖 , the Best Matching Unit (BMU) is: 𝑏𝑖 = arg min ∥𝑥𝑖 − 𝑤 𝑗 ∥ 22 . (2) 𝑗
MapDB computes assignments using relational joins, aggregation, and window ranking. A simplified form is:
MapDB Design: SOMs as Relational Objects Listing 2: BMU assignment in SQL.
Figure 1 summarizes the architecture. In essence, the design separates: (1) map-aware SQL syntax; (2) logical map operations; (3) persistent map state; and (4) physical relational strategies. The schema is intentionally simple and includes five core relations (see Table 1). Conceptually: Listing 1: Core Relations. MAP_NEURON(map_id, neuron_id, row_pos, col_pos) MAP_WEIGHT(map_id, epoch, neuron_id, feature_id, value) MAP_EDGE(map_id, src_neuron, dst_neuron, grid_distance) MAP_ASSIGNMENT(map_id, epoch, object_id, neuron_id, distance) MAP_SUMMARY(map_id, epoch, neuron_id, summary_name, value)
A map catalog additionally stores:
SELECT object_id, neuron_id, dist FROM ( SELECT x.object_id, w.neuron_id, SUM(POWER(x.value-w.value,2)) AS dist, ROW_NUMBER() OVER ( PARTITION BY x.object_id ORDER BY SUM(POWER(x.value-w.value,2)) ) AS rn FROM MAP_INPUT_LONG x JOIN MAP_WEIGHT w ON x.feature_id = w.feature_id WHERE w.map_id = :map AND w.epoch = :epoch GROUP BY x.object_id, w.neuron_id ) q WHERE rn = 1;
Queryable Self-Organizing Maps: A Database Abstraction for Topology-Driven Data Exploration
MapDB uses batch SOM training because it is naturally relational. Given BMU assignments, each prototype is recomputed as a neighborhood-weighted average: Í 𝑡 𝑖 ℎ𝑏 ,𝑗 𝑥𝑖 𝑤 𝑡𝑗 +1 = Í 𝑖𝑡 , (3) 𝑖 ℎ𝑏 ,𝑗
Conference’26, date, place
Component Queries. Component planes show how individual features vary across the map (i.e., , a feature-specific projection of the prototypes): Listing 5: Component-plane query. SELECT * FROM mapdb.map_component('census_map', 'education_num');
𝑖
with: ℎ𝑏𝑡 𝑖 ,𝑗 = exp −
𝑑 grid (𝑏𝑖 , 𝑗) 2 2𝜎𝑡2
! .
(4)
The update joins assignments, topology edges, and input features, then aggregates by target neuron and feature. We highlight that training inside SQL is not the end goal. It is the mechanism that keeps the learned topology inside the data system, where it can be queried, versioned, and joined with source data.
This query returns: (𝑟𝑜𝑤, 𝑐𝑜𝑙𝑢𝑚𝑛, 𝑣𝑎𝑙𝑢𝑒). Thus componentplane figures are views over persistent model state rather than external plotting artifacts. Topology Traversal. The most important database interaction is region-to-data drill-down. A user can select a neuron or connected region and retrieve the corresponding source records. Neighborhood traversal is exposed through: SELECT * FROM mapdb.map_neighborhood'census_map', 42, 2);
Immediate adjacency is: MapDB SQL Extensions. Once the SOM is represented relationally, model analysis becomes SQL. However, the low-level relations are useful for transparency and execution, but they are not an appropriate user abstraction. Therefore, MapDB exposes a compact family of map-aware SQL extensions. Map lifecycle. A map can be created from a relation or analytical view: CREATE MAP census_map USING SOM ON census_features OBJECT ID object_id FEATURES (age, education_num, hours_per_week, capital_gain_log1p) WITH (rows = 10, cols = 10, epochs = 20);
The result can be joined with the source relation: Listing 6: Retrieving source tuples by map neighborhood. SELECT a.* FROM census a JOIN mapdb.map_region_objects('census_map', 42, 2) r ON a.object_id = r.object_id;
This operation retrieve all records mapped near a selected region of the learned topology. It turns visual navigation into database navigation.
4
Additional lifecycle statements include:
Experimental Analysis
Our evaluation mainly concerns the scalability of SOM processing in terms of data size, feature dimensionality, and map size. In addition, we evaluate the speedup gains by materializing map artifacts. We also included experiments to check whether the abstraction remain useful for both single-table and multi-table relational settings.
TRAIN MAP census_map FOR 20 EPOCHS; REFRESH MAP census_map; DROP MAP census_map;
Density Queries. The logical operation: SELECT * FROM mapdb.map_hits('census_map');
returns neuron occupancy. Dense neurons reveal common data profiles and are queried as: Listing 3: Dense-region discovery. SELECT * FROM mapdb.map_dense_regions('census_map', 100);
Boundary Queries. The U-Matrix [7] is a common SOM visualization that identifies neurons whose prototypes differ strongly from neighboring prototypes. For neuron 𝑗, the U-Matrix value is: 𝑈 ( 𝑗) =
SELECT * FROM mapdb.map_adjacent('census_map', 42);
∑︁ 1 ∥𝑤 𝑗 − 𝑤𝑘 ∥ 2 . |N ( 𝑗)| 𝑘∈N(𝑗)
Users can query it through: SELECT * FROM mapdb.map_umatrix('census_map');
or select strong boundaries: Listing 4: Boundary-neuron query. SELECT * FROM mapdb.map_boundaries('census_map', 0.8);
(5)
Prototype. MapDB is implemented in DuckDB with Python orchestration. DuckDB stores the relational SOM artifacts and executes BMU assignment, batch updates, map queries, materialization, and case-study drill-down. Python manages data loading, feature preprocessing, repeated runs, baseline models, plotting, and table generation. Datasets. We employ three dataset in our experiments: • Synthetic: We generate controlled Gaussian-mixture data and vary the number of objects 𝑁 , dimensions 𝐷, and map units 𝐾. • Adult Census: Numeric features are imputed when necessary, skewed attributes are log-transformed, and numeric values are standardized. Categorical attributes are one-hot encoded; missing categorical values are represented explicitly. To prevent high-cardinality groups from dominating Euclidean distance, dummy variables belonging to an original categorical attribute with 𝐾𝑔 categories are weighted by √︁ 1/ 𝐾𝑔 . Income is excluded from training and used only for interpretation. • TPC-H: We construct customer-level feature views through joins and aggregation over customer, orders, lineitem, supplier, and part. Features include order counts, total
Conference’26, date, place
Martins et al.
Training Time (s)
Dimensions
Map size
25
25
20
20
15
15
10
10
10
5
5
5
MapDB PythonBatchSOM KMeans MiniBatchKMeans
20 15
0
0 0
20000
40000
Objects (N )
40
4 1.80
1.64
1.53
0
0 20
7.57
8
Speedup (×)
Rows 25
60
200
Features (D)
Component Plane Hit Map Region Drilldown U-Matrix
400
Map units (K)
Figure 4: Median speedup gains from artifact materialization. Figure 2: Synthetic scalability as the number of objects, dimensions, and map units increase.
Metric Value
1.0 0.8 0.6
0.520 0.513
0.466 0.470
MapDB PythonBatchSOM KMeans MiniBatchKMeans
0.4 0.2 0.006 0.008
0.0 Quantization Error
0.048 0.042
Silhouette
Figure 3: SOM and flat clustering baselines. The comparison includes representation quality and region-quality metrics.
spend, average order value, quantity, discount, line price, shipping delay, supplier diversity, and part diversity. Skewed aggregates are log-transformed and standardized. Market segment is retained as an external interpretation label. Baselines and Metrics. We compare MapDB against our own Python implementation of Batch SOM, KMeans, and a mini-batch version of KMeans. For fair comparison, clustering methods use the same number of representatives 𝐾 = map rows × map columns. For evaluating the quality of each method, we report quantization error and silhouette score.
4.1
Results
Synthetic Scalability. We first characterize generic runtime behavior under controlled variation of 𝑁 , 𝐷, and map size (in terms of the number of map units 𝐾). Figure 2 shows that total training time increases with all three factors, as expected from repeated object-to-prototype comparisons. The dominant component is BMU assignment. At the largest tested configuration, MapDB requires approximately 20 seconds to training a map. This result demonstrates that relational SOM processing is feasible for moderate analytical workloads, but larger configurations and larger database sizes motivate vectorized or approximate BMU search. SOM versus Flat Clustering. A central question in our work is whether SOM provides value beyond simply assigning tuples to clusters. Figure 3 compares MapDB, Python Batch SOM, KMeans, and MiniBatchKMeans.
MapDB achieves competivitive results (while taking more runtime, as described before). Flat clustering remains competitive on the Silhouette metric, but lacks explicit adjacency and therefore cannot directly support neighborhood expansion, U-Matrix boundaries, or topological traversal. Materialized versus Recomputed Queries. We benchmark hit maps, U-Matrix values, component planes, and region drill-down. Before timing, MapDB checks that both modes return equivalent results. Figure 4 the speedup obtained by querying materialized SOM artifacts instead of recomputing the same artifacts from lower-level map state. Materialization improves all tested query types, with UMatrix queries showing the largest benefit, with a median speedup of 7.57. This is due to the intrisinc complexity of producing the U-Matrix: recomputation requires joins over topology edges and prototype weights, followed by distance aggregation over neighboring neurons. In contrast, materialized U-Matrix access reduces the operation to a scan over a compact summary relation. These results indicate the need for a selective materialization strategy in which the database system should persist expensive or frequently accessed map-derived summaries while leaving cheaper artifacts virtual when appropriate.
4.2
Case Studies
The systems experiments above test feasibility and topology. We now ask whether queryable maps expose useful exploratory structures in real relational settings. Adult Dataset: Single-Table Exploration. Adult represents a singletable mixed-type setting. The SOM is trained without the income label. After training, map regions are joined back to source tuples and external labels for interpretation. The Adult hit map in Figure 5 shows strongly non-uniform occupancy, in which recurring demographic and employment profiles concentrate in localized areas, while other regions remain sparsely populated. The U-Matrix reveals pronounced high-distance zones on one side of the topology and smoother transitions elsewhere. The combination of density and boundary strength is especially useful. A populated region near a strong U-Matrix boundary is a natural target for comparison because it contains many records while lying close to a sharp profile transition. Component planes in Figure 6 indicate that the learned topology is meaningful, where neighboring neurons correspond to systematically changing demographic and employment profiles. For instance, age varies mainly from older profiles on the left to younger profiles on the right, while education exhibits a clear top–bottom contrast,
Queryable Self-Organizing Maps: A Database Abstraction for Topology-Driven Data Exploration
Row Column
0.6
num orders log1p
total spend log1p
customer Z orders Z lineitem Z supplier Z part. The resulting hit map in Figure 5 again shows strongly nonuniform occupancy. Dense map regions correspond to recurring customer purchasing and logistics profiles, while sparse regions represent less common combinations. In contrast, component planes in Figure 6 (bottom) indicate that the map captures coherent gradients over customer-level aggregate behavior. In particular, the number of orders and total spend increase smoothly from left to right, indicating that the SOM organizes customers by overall purchasing intensity. Morevoer, shipping delay, discount, and return rate exhibit more localized structures, suggesting that logistics and pricing behavior distinguish specific subregions rather than the entire topology. Overall, the component planes show that the map preserves interpretable structure in a multi-table SQL-derived feature space. Region-to-Data Drill-Down. For each case study, MapDB selects three representative region types, such as, dense region, boundary region, and high-error region. The system then expands each region by a configurable grid radius, joins assignments back to source tuples, and reports the strongest feature contrasts.
0123456789
Column
Row
9876543210
avg order value log1p
0123456789
0123456789
Column
Column
0123456789
Column
avg ship delay
avg discount
return rate
Row
Row
TPC-H: Multi-Table SQL Exploration. TPC-H tests whether the same abstraction applies when mapped objects are not stored in a single table but produced by a relational query involving joins and aggregation. We construct customer-level feature vectors from:
9876543210
Row 0123456789
Column
with higher values concentrated in the lower part of the map. Capital gain and capital loss are sparse and localized, indicating that these attributes characterize specific subregions rather than the whole map. The sex=Female plane shows a weaker but still spatially localized pattern.
9876543210
9876543210
Row
Row Row
9876543210
sex=Female
0123456789
Figure 5: Case-study artifacts. Adult exposes non-uniform density and strong topological boundaries. TPC-H exposes structured occupancy over a multi-table analytical view and a coherent feature gradient.
0123456789
9876543210
Column
capital loss log1p
Row
Column
Column
capital gain log1p
9876543210
0 1 2 3 4 5 6 7 8 9
Column
0.8
0.4
0 1 2 3 4 5 6 7 8 9
0123456789
Row
50
1.0
Row
100
Row
150
9 8 7 6 5 4 3 2 1 0
TPC-H U-Matrix
hours per week
Column
9876543210
Column Row
0 1 2 3 4 5 6 7 8 9
education num
0123456789
9876543210
0.5
Column
200
9876543210
1.0
0 1 2 3 4 5 6 7 8 9
TPC-H Hit Map
Row
1.5
9876543210
0
2.0
9876543210
500
Row
1000
9 8 7 6 5 4 3 2 1 0
age
Adult U-Matrix 9 8 7 6 5 4 3 2 1 0
Row
9 8 7 6 5 4 3 2 1 0
Adult Hit Map
Conference’26, date, place
0123456789
0123456789
0123456789
Column
Column
Column
Figure 6: Selected Adult (top rows) and TPC-H (bottom rows) component planes. Each panel is obtained by querying a feature slice of SOM weights. Smooth gradients and high-value areas expose how features vary over the learned topology. Table 2: Case-study region drill-down. Regions selected from the SOM are joined back to the source feature views and summarized by their dominant label and largest standardized contrasts against the global population. Dataset
Region
Size
Dom. label
Main contrasts vs. global
Adult Adult Adult TPC-H TPC-H TPC-H
Dense Boundary High-error Dense Boundary High-error
1332 1425 1665 846 695 468
> 50𝐾 > 50𝐾 > 50𝐾 BUILDING FURNITURE BUILDING
↑ capital loss; ↑ education ↑ capital loss; ↑ education ↑ capital gain; ↑ education ↑ orders; ↓ avg. line price ↓ avg. order value, total spend ↓ avg. order value, and quantity
Region drill-down. Table 2 reports obtained results. In the Adult dataset, dense and boundary regions both correspond to large subpopulations with a slight majority of > 50𝐾 income labels and higher education-related profiles. In TPC-H, the dense region captures a recurring high-activity customer profile with more orders, whereas the boundary and high-error regions identify lower-value customer profiles with lower average order value, total spend, and quantity. These results illustrate the main benefit of MapDB drilldown, i.e., map regions become queryable database subsets that can be summarized, compared, and interpreted with SQL.
Conference’26, date, place
Martins et al.
Table 3: TPC-H multi-table scaling. MapDB trains SOMs over customer-level feature views derived from joins and aggregations. Here, QE denotes the quantization error. SF
Objects
Feat. View (s)
Training (s)
BMU (s)
QE
0.01 0.10 1.00
1,000 10,000 30,000
0.04 0.22 0.95
1.61 6.12 7.35
0.87 3.62 4.28
1.54 1.59 1.65
Scaling Multi-Table Feature Views. We evaluate scale factors 𝑆𝐹 ∈ {0.01, 0.1, 1.0} for TPC-H. In our runs, feature-view construction stayed below one second at scale factor 1.0, while SOM training is the dominant cost. The main contributor is BMU assignment, which reaches 4.28𝑠 at 𝑆𝐹 = 1.0. Map quality remains stable across scales, where quantization error increases only modestly from 1.54 to 1.65. These results suggest that the relational construction of mapped objects is not the main bottleneck in this setting; future optimization should focus on BMU assignment, prototype updates, and incremental map maintenance.
5
Related Work
Self-Organizing Maps and exploratory analysis. A SOM organizes high-dimensional objects over a low-dimensional topology while encouraging neighboring units to represent similar input profiles [4]. Prior work has used SOM for clustering, visualization, and exploratory analysis [6]. MapDB differs from this literature in focus: rather than proposing a new SOM algorithm, we ask what changes when the learned topology becomes persistent, relationally represented, and directly queryable inside a DBMS. In-database analytics and machine learning. Recent work spans in-database model training, declarative machine learning, and systems that expose model state for inspection or querying. Related efforts such as SQL4NN [2] treat learned models as data that can be validated and queried through relational abstractions. MapDB is complementary but targets a different class of object: an exploratory learned structure whose internal topology, assignments, and summaries are themselves useful analytical state. Query recommendation and data exploration. Exploratory database systems help users identify interesting subsets and formulate subsequent queries when the target predicate is not known in advance. For example, PyExplore derives query recommendations from structure discovered in query results [3]. MapDB shares the goal of supporting exploration but introduces a persistent intermediate abstraction: a learned topological map that can be reused across sessions, traversed by neighborhood, queried for boundaries or density, and joined back to source objects. Thus, exploration is expressed over a durable learned organization rather than only over transient clustering or visualization output. To our knowledge, the combination explored here (persistent relational representation of SOM topology, map-aware SQL operations, region-to-data drill-down) has received little attention. MapDB therefore connects three previously separate concerns: exploratory topological learning, database-native model state, and declarative relational analytics.
6
Conclusion
This paper argues that learned exploratory maps, derived from a Self-Organized Map, should be treated as intensional database objects. A SOM organizes high-dimensional data into a two-dimensional lattice that exposes density, boundaries, gradients, and recurring data profiles. In conventional workflows, this organization remains external to the DBMS. MapDB instead treats SOM artifacts as persistent database state. More importantly, MapDB exposes map-aware SQL operations for creating maps, inspecting component planes, traversing neighborhoods, drilling from learned regions back to source tuples, and selectively materializing expensive summaries. Our evaluation shows how this abstraction operates across controlled scalability workloads, flat-clustering comparisons, and materialization trade-offs. More broadly, our results suggest that learned structures need not remain opaque objects invoked from SQL; they can become persistent, queryable components of the database itself. Doing so opens new questions in maintenance, physical design, optimization, and model lifecycle support. SOMs provide a concrete first case, but the broader opportunity is database-native learned analytical structures, including vector quantization, graph embeddings, and manifold summaries.
References [1] Thiego Buenos Aires De Carvalho, Denis M. Lima Martins, Fernando B. De Lima Neto, and Gottfried Vossen. 2022. Recommending View Bundles in Data Marketplaces. In 2022 IEEE International Conference on Systems, Man, and Cybernetics (SMC). 3403–3408. doi:10.1109/SMC53654.2022.9945110 [2] Mark Gerarts, Juno Steegmans, and Jan Van den Bussche. 2025. SQL4NN: Validation and Expressive Querying of Models as Data. In Proceedings of the Workshop on Data Management for End-to-End Machine Learning (Berlin, Germany) (DEEM ’25). Association for Computing Machinery, New York, NY, USA, Article 10, 5 pages. doi:10.1145/3735654.3735946 [3] Apostolos Glenis and Georgia Koutrika. 2021. PyExplore: Query Recommendations for Data Exploration without Query Logs. In Proceedings of the 2021 International Conference on Management of Data (Virtual Event, China) (SIGMOD ’21). Association for Computing Machinery, New York, NY, USA, 2731–2735. doi:10.1145/3448016.3452762 [4] Teuvo Kohonen. 1990. The Self-Organizing Map. Proc. IEEE 78, 9 (1990), 1464–1480. doi:10.1109/5.58325 [5] Denis Mayr Lima Martins and Gottfried Vossen. 2023. Self-Organizing Maps for Data Purchase Support in Data Marketplaces. In Computational Collective Intelligence, Ngoc Thanh Nguyen, János Botzheim, László Gulyás, Manuel Núñez, Jan Treur, Gottfried Vossen, and Adrianna Kozierkiewicz (Eds.). Springer Nature Switzerland, Cham, 43–55. [6] Jörn Lötsch and Alfred Ultsch. 2014. Exploiting the structures of the U-matrix. In Advances in Self-Organizing Maps and Learning Vector Quantization: Proceedings of the 10th International Workshop, WSOM 2014, Mittweida, Germany, July, 2-4, 2014. Springer, 249–257. [7] Alfred Ultsch. 2005. Clustering wih som: U* c. In Proceedings of the 5th workshop on self-organizing maps, Vol. 2. 75–82. [8] Juha Vesanto and Esa Alhoniemi. 2000. Clustering of the self-organizing map. IEEE Transactions on neural networks 11, 3 (2000), 586–600.
Received 20 February 2007; revised 12 March 2009; accepted 5 June 2009