Scope and management pages
WISDOMERA / WTRANSFER

Wtransfer Management Pages Guide

End-to-end configuration guide for database map, server, layer, and layer-parameter management pages.

Scope

This guide covers the usage relationships of the parameters found on the Wtransfer management page. The example tables, columns, domains, and SQL values ​​are for illustrative purposes only; they must be verified against the target schema in a production environment.

1. Database Map Management Page Create the integration map.
2. Server Management Page Connect nodes and physical databases.
3. Layer Management Page Model tables and the layer tree.
4. Layer Parameter Management Page Configure columns, SQL, and option matching.
about

A database map is created for the purpose of integrating with a target database. It stores information regarding associated servers, layers, and parameters linked to those layers. Within the wanalyzer application, a database map can be selected during the data preparation phase in wtransfer mode. Users may select one or more database maps within wanalyzer. Database maps designed with the same layer and parametric architecture can be used within the same *wanalyzer* project. The AiAssistant tool can be utilized during the design of a database map, simplifying the process of achieving the intended database integration. The system includes pre-built database maps; for instance, a hospital database map—developed by WisdomEra—can be integrated directly into a target hospital information management system. Because these pre-built maps are designed according to standardized specifications, their layers and parameters cannot be modified. This standard database map is accompanied by tens of thousands of pre-designed algorithms available to the user; once integrated, these algorithms can be selected and deployed to begin functioning immediately. Furthermore, users can copy an existing pre-built database map to create a custom, tailored version for their own specific requirements.

View the integration flow
status
status select

An active database map is available for selection in Wanalyzer. Inactive maps are not offered for selection.

* Parameter relationships
Parameter: dbmap_config['status']
Condition: No other parameter option is a prerequisite.
Reason and result: “status” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — passive
Excludes the database map from selection and use.
1 — active
Makes the database map selectable and usable in Wanalyzer screens.
Example: 1 — active
dbmap_config['status'] = '1'
Parameter ID: 0
mapping name
mapping name text

A descriptive name identifying the database map.

* Parameter relationships
Parameter: dbmap_config['mapping_name']
Condition: No other parameter option is a prerequisite.
Reason and result: “mapping name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: Hospital HIS Map
dbmap_config['mapping_name'] = 'Hospital HIS Map'
Parameter ID: 1
table relations
table relations textarea

Defines relationships between columns in different tables, such as Patient.Id = Encounter.PatientId. These relationships support parent–child relationships between layers and are maintained at map level.

* Parameter relationships
Parameter: dbmap_config['table_relations']
Condition: No other parameter option is a prerequisite.
Reason and result: “table relations” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: Patient.Id = Encounter.PatientId
dbmap_config['table_relations'] = '[[{"ly_id":["patient"],"c":["Id"],"t":"Patient","dbg":"HIS"},{"ly_id":["encounter"],"c":["PatientId"],"t":"Encounter","dbg":"HIS"}]]'
Parameter ID: 2
layer server group way point
layer server group way point textarea

Used when a query spans different server groups, for example joining patient data from a hospital database with user data from a mobile database. The cross-server WHERE conditions should be connected with AND. Wtransfer first evaluates the primary rule in both databases, derives the target set from the side with fewer records, and then retrieves the required column values.

Generally, it is more logical to construct the main query from within the same server. It is used in rarer cases—specifically when two databases cannot be consolidated onto a single, shared server.

* Parameter relationships
Parameter: dbmap_config['layer_server_group_way_point']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer server group way point” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: HIS.Patient.Id = Mobile.User.PatientId
dbmap_config['layer_server_group_way_point'] = '{"HIS-Mobile":[["patient","mobile_user"]]}'
Parameter ID: 3
application access information
application access information list_parameter

This is the URL specified for sending requests from Wanalyzer to Wtransfer. If this parameter is left blank, the Wtransfer instance located on the same system as the Wisdomera platform is used as the target application. If a URL is defined, requests are sent to that specific target URL. This can be used for a remote Wtransfer instance residing on an external system. For example, if you have three Wtransfer servers—wtransfer1.xyz.com, wtransfer2.xyz.com, and wtransfer3.xyz.com—this parameter allows the system to connect to whichever one is available. It is not mandatory.

* Parameter relationships
Parameter: dbmap_config['application_access_information']
Condition: No other parameter option is a prerequisite.
Reason and result: “application access information” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: wtransfer1.xyz.com
dbmap_config['application_access_information'] = [{'domain': 'wtransfer1.example.com'}]
Parameter ID: 7
domain
domain text

The Wtransfer endpoint can be a domain name or an IP address with port, for example http://10.101.101.25:8487. Requests are directed to the configured endpoint.

* Parameter relationships
Parameter: dbmap_config['application_access_information'][0]['domain']
Condition: The related dbmap_config['application_access_information'] item must exist.
Reason and result: The domain defines an address from which the application may access this DB map.
Example: http://10.101.101.25:8487
dbmap_config['application_access_information'][0]['domain'] = 'wtransfer1.example.com'
Parameter ID: 8
product code
product code text

Determined by Wisdomera. It cannot be edited manually. It is used for matching purposes during the automatic updating of database maps by wtransfer. In database maps where the product code is populated, modifications such as defining new layers, adding new parameters, or adding options are not permitted. However, it is possible to edit settings related to the connection of parameters and layers to the target database, as well as SQL details and table/column information.

* Parameter relationships
Parameter: dbmap_config['product_code']
Condition: No other parameter option is a prerequisite.
Reason and result: “product code” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
dbmap_config['product_code'] = 'HospitalPatient1'
Parameter ID: 9
Worked example

Worked example: hospital integration map

  1. Name the map Hospital HBYS Map and make it active.
  2. Add Patient.Id = Encounter.PatientId to table relations.
  3. Add only a real endpoint when a remote Wtransfer instance is used.
about

Servers associated with a database map are registered here. A server may contain multiple nodes, and those nodes are maintained as a list within the server model. URL, IP address, port, credentials, and database information describe how Wtransfer reaches the target. Servers with comparable roles can also be assigned to a common group. When a query targets that group, Wtransfer runs it against the applicable servers in the group; for example, if Server 1 and Server 2 both belong to the same group, the same query can be executed on both.

status
status select

An active database map is available for selection in Wanalyzer. Inactive maps are not offered for selection.

* Parameter relationships
Parameter: server_config['status']
Condition: No other parameter option is a prerequisite.
Reason and result: “status” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — passive
Excludes the server from queries and the active-server license count.
1 — active
Makes the server available to queries and includes it in the active-server license count.
Example: 1 — active
server_config['status'] = '1'
Parameter ID: 0
type
type select

The Wtransfer application can connect to various database servers. When establishing these connections, the appropriate integration module—from among those already designed—is selected. For instance, if the database server is MSSQL, then "MSSQL" should be chosen.

* Parameter relationships
Parameter: server_config['type']
Condition: No other parameter option is a prerequisite.
Reason and result: “type” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — mssql
Uses the Microsoft SQL Server integration for server connections and queries.
Example: MSSQL
server_config['type'] = '0'
Parameter ID: 1
name
name text

Refers to the name of the server. It can be recorded with additional information, such as an IP address or a label identifying the server (e.g., "Hospital X Server").

* Parameter relationships
Parameter: server_config['name']
Condition: No other parameter option is a prerequisite.
Reason and result: “name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: Istanbul Hospital MSSQL
server_config['name'] = 'Istanbul Hospital MSSQL'
Parameter ID: 2
code
code text

In the Wtransfer application, the same query can be executed across multiple connected servers. For instance, suppose we want to retrieve the patient IDs of male patients with a diagnosis of "X." Since there are two separate hospitals, it is possible for the same patient ID values ​​to appear. If the "prefix" option is enabled in the parameter settings, the code value for that specific source is appended to the query result, connected by an underscore—for example, "Xyz_123," where "Xyz" represents the code.

* Parameter relationships
Parameter: server_config['code']
Condition: No other parameter option is a prerequisite.
Reason and result: “code” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: IST → result identifier IST_123
server_config['code'] = 'IST'
Parameter ID: 3
group
group text

When a query is sent to Wtransfer, the name of the primary unique layer—referred to as the " main layer "—is also transmitted. The ID of this main layer is known to Wtransfer even before the query begins execution on the servers. Server group assignments are configured within the database map's layer settings; this allows the system to determine which server group the main layer is linked to, as well as the specific list of servers contained within that group. This grouping mechanism is particularly advantageous when a database map involves multiple servers or servers with varying content structures.

For instance, suppose the "Patient" layer is mapped to the "HBYS" (Hospital Information Management System) server group, and our query targets this "Patient" layer. If our map contains five "HBYS" server groups and one "mobile" server group, the query will be executed only across the five "HBYS" server groups—it will not perform any queries against the mobile database.

* Parameter relationships
Parameter: server_config['group']
Condition: No other parameter option is a prerequisite.
Reason and result: “group” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
server_config['group'] = 'his'
Parameter ID: 4
note
note text

Optional free-text notes for the map/server configuration.

* Parameter relationships
Parameter: server_config['note']
Condition: No other parameter option is a prerequisite.
Reason and result: “note” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
server_config['note'] = 'Primary production server group'
Parameter ID: 5
code group
code group text

It serves the purpose of general information and categorization. It has no active function within the system. It can be used when there is a need to group various facility codes together; for instance, hospitals with codes a, b, and c could be assigned to group X, while those with codes d, e, and f could be assigned to group Y. The information regarding groups X and Y is not used in queries.

* Parameter relationships
Parameter: server_config['code_group']
Condition: No other parameter option is a prerequisite.
Reason and result: “code group” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
server_config['code_group'] = 'CLINICAL'
Parameter ID: 6
server nodes
server nodes list_parameter

A server may have replicas, which are essentially copies of that server. When the primary server is updated, the current data is propagated to the other server nodes. Occasionally, server nodes may experience access issues or undergo maintenance. For this reason, access management is handled with these server nodes as the basis.

* Parameter relationships
Parameter: server_config['server_nodes']
Condition: No other parameter option is a prerequisite.
Reason and result: “server nodes” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: HIS-NODE-01, HIS-NODE-02
server_config['server_nodes'] = [{'server_node_status': '1', 'server_data_record_eligibility': '', 'server_node_name': 'HIS Istanbul Hospital', 'server_node_number': '1', 'server_connection_order': '1', 'server_ip': '10.20.30.40', 'server_domain': 'sql01.hospital.example.com', 'server_username': 'wisdomera', 'server_password': '********', 'server_port': '1433', 'server_note': 'Read-only reporting node'}]
Parameter ID: 7
server node status
server node status select

Active nodes can be contacted; inactive nodes are not tried.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_node_status']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the server-node status within the same connection node and is not evaluated without that node.
Options and purposes
0 — passive
Prevents connections to the related server node.
1 — active
Makes the related server node available for connections.
Example: 1 — active
server_config['server_nodes'][0]['server_node_status'] = '1'
Parameter ID: 8
server node name
server node name text

A human-readable name for a server node, such as a hospital name.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_node_name']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the server-node name within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_node_name'] = 'HIS Istanbul Hospital'
Parameter ID: 10
server connection order
server connection order text

Specifies the connection order that the created nodes will follow when establishing connections. For example, replica servers can be prioritized over primary servers. If necessary, the system can be configured so that the primary server is the last one to be connected to.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_connection_order']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the connection order within the same connection node and is not evaluated without that node.
Example: 1
server_config['server_nodes'][0]['server_connection_order'] = '1'
Parameter ID: 12
server ip
server ip text

The IP address used for a connection. An IP or domain is expected; when a domain is configured, it takes precedence.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_ip']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the server IP within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_ip'] = '10.20.30.40'
Parameter ID: 13
server domain
server domain text

The domain used for a connection. An IP or domain is expected; when a domain is configured, it takes precedence.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_domain']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the server domain within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_domain'] = 'sql01.hospital.example.com'
Parameter ID: 14
server username
server username text

The username used to authenticate to the database server.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_username']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the username within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_username'] = 'wisdomera'
Parameter ID: 15
server password
server password text

The password used to authenticate to the database server. Handle this value as a credential.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_password']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the password within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_password'] = '********'
Parameter ID: 16
server port
server port text

Optional connection port, used together with the IP address or domain when supplied.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_port']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the port within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_port'] = '1433'
Parameter ID: 17
server note
server note text

Free-text notes describing a particular server node.

* Parameter relationships
Parameter: server_config['server_nodes'][0]['server_note']
Condition: The related server_config['server_nodes'] item must exist.
Reason and result: This field defines the note within the same connection node and is not evaluated without that node.
Example:
server_config['server_nodes'][0]['server_note'] = 'Note field for authorized person'
Parameter ID: 18
server database
server database list_parameter

A database server can host multiple databases. The databases to be used for queries are specified here. In addition to a basic 'dbo' database, other distinct databases—such as those for a Hospital Information Management System (HBYS) or a laboratory (LAB)—can also be configured.

* Parameter relationships
Parameter: server_config['server_database']
Condition: No other parameter option is a prerequisite.
Reason and result: “server database” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Database type options
0 — mssql
Uses Microsoft SQL Server connection and query behavior for the related database.
Example: dbo, HBYS, LAB
server_config['server_database'] = [{'server_database_group': 'HIS', 'server_database_name': 'HIS_IST'}]
Parameter ID: 19
server database group
server database group text

A database group is a field used to categorize database names; it does not necessarily have to be the actual database name itself. In multi-server database maps, databases with identical structures may have different names across different servers.

For instance, a hospital database might be named `hbys_xyz` on "server1," while the corresponding hospital database on "server2" might be named `hbys_abc`. Since these databases share the same structure, this field allows us to group them under a common group name—for example, "hbys."

By "sharing the same structure," we mean that the tables and the columns within those tables are identical. Once a database group name is defined, it is used across various map layers and their associated parameters. The actual database name is never used directly within these parameters or layer settings. Instead, queries are executed by mapping the parameters to their respective database groups.

* Parameter relationships
Parameter: server_config['server_database'][0]['server_database_group']
Condition: The related server_config['server_database'] item must exist.
Reason and result: This field defines the database group in the same server-database mapping.
Example: HIS, LAB, dbo
server_config['server_database'][0]['server_database_group'] = 'HIS'
Parameter ID: 20
server database name
server database name text

This corresponds exactly to the name of a database created on a database server. Actual queries are generated by mapping this database name to a database group defined within the map layer and its parameters.

For instance, suppose a database group defined in a layer parameter is named "hbys." In a database map spanning five servers, the actual database names on each server might be "hbys_1," "hbys_2," "hbys_3," "hbys_4," and "hbys_5." To generate valid queries, the system requires the specific database name—such as "hbys_1." By associating the "hbys" group identifier with these individual database names across the servers, the system can easily resolve the correct database name during query execution. When a query is run on the first server, the system identifies that "hbys" corresponds to "hbys_1" and adjusts the query accordingly. In a single-server environment, the database name and the group name may be identical, as there is no need for grouping in such a setup.

* Parameter relationships
Parameter: server_config['server_database'][0]['server_database_name']
Condition: The related server_config['server_database'] item must exist.
Reason and result: This field defines the database name in the same server-database mapping.
Example:
server_config['server_database'][0]['server_database_name'] = 'HIS_IST'
Parameter ID: 21
Worked example

Worked example: two-hospital HBYS group

  1. Assign the HBYS (Hospital Information Management System) server group to the Istanbul and Ankara servers.
  2. Define an active node on each server; if a domain is present, it should be specified before the IP address.
  3. Set the logical database group to HBYS on both servers, with the actual database names being HBYS_IST and HBYS_ANK ," respectively.
  4. This ensures that the same layer and parameter queries are correctly translated for each of the two physical database instances.

about

After the database map is created, first the servers are added. Data layers are then created. Then the parameters associated with the data layers are recorded. The data layer stores information such as which table in the target database to connect to, which column serves as the primary key, and how the parent-child (relational) process between layers is structured.

While layers can be thought of as tables, they should not be equated directly to them; a single layer can aggregate data from multiple tables. In essence, a layer is a data model that allows for the seamless integration of data—whether from the same or different tables—that you wish to use together.

Query Routing Flow

When a query is sent to Wtransfer, information regarding the primary individual row—the "main layer"—is also transmitted. Wtransfer identifies this main layer ID before the query execution begins. The layer configuration within the database map specifies the server group; the system then resolves the list of relevant servers from this group and routes the query to the correct destination.

1. Main layer The main layer ID is sent along with the request.
2. Layer configuration The server group associated with the layer is retrieved via the server group parameter.
3. Server list The available servers associated with the server group are identified.
4. Query destination Queries are processed across the servers, continuing execution from the point where they last left off.
status
status select

An active database map is available for query.

* Parameter relationships
Parameter: layer_config['status']
Condition: No other parameter option is a prerequisite.
Reason and result: “status” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — passive
Excludes the layer from queries.
1 — active
Allows the layer to be used in queries.
Example:
layer_config['status'] = '1'
Parameter ID: 0
layer name
layer name text

This is the layer name value. It must be defined using English characters, with no spaces. Within any given database map, the layer name must be unique. This is because the layer name value is used when generating a common query across different database maps. For instance, if a layer named "Patient" exists in database map 1 and another layer also named "Patient" exists in database map 2, the same query can be applied to both database maps to generate a dataset within a shared WAnalyzer project.

* Parameter relationships
Parameter: layer_config['layer_name']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['layer_name'] = 'patient_visit'
Parameter ID: 16
main table name
main table name text

Layers are data units in which data from various tables is collected. Each layer requires a main table capable of generating a unique ID value for its rows.

For instance, patient encounter data can be retrieved from a table named encounter (or "application/request"). Specific columns from this table can be selected; it is not necessary to include every column. Furthermore, a parameter within the encounter layer—such as "appointment type"—can be sourced from a separate table (e.g., an "appointment" table) and mapped to the corresponding parameter in the encounter layer.

The data layer structure here functions by consolidating data from various tables. The role of the main table is twofold: it serves to generate unique row identifiers and acts as the defining element for the parent-child relationships established within the layer tree.

Additionally, the main table selected here must be one of the tables utilized in the table relationships defined within the layer tree settings—found under the general settings of the database map .

* Parameter relationships
Parameter: layer_config['main_table_name']
Condition: No other parameter option is a prerequisite.
Reason and result: “main table name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['main_table_name'] = '[PatientSchema].[Encounter]'
Parameter ID: 1
client id prefix
client id prefix select

When data is received from the layer, the id value in the primary of the data is also taken. Client id actually means the primary singular id value to be used for this layer in the target database. Select yes if you want the server code —specified in the server settings—to be added as a prefix (followed by an underscore) to the primary column ID value.

If you are performing queries across multiple database servers, it is advisable to set the prefix option to "yes," as the same primary ID might exist on different servers. For instance, a record with an ID of 123 could exist at Hospital X, while another record with the same ID of 123 could exist at Hospital Y. To distinguish between them, the system will retrieve the data as "x_123" and "y_123," respectively.

* Parameter relationships
Parameter: layer_config['client_id_prefix']
Condition: No other parameter option is a prerequisite.
Reason and result: “client id prefix” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and use cases
0 — no
Uses the client ID value as-is, without adding the server code.
1 — yes
Adds the server code as a prefix to the client ID to distinguish identical ID values ​​originating from different servers.
Example:
layer_config['client_id_prefix'] = '1'
Parameter ID: 2
client id table name
client id table name text

The table used to obtain the layer’s unique client ID; normally the same as the main table.

* Parameter relationships
Parameter: layer_config['client_id_table_name']
Condition: No other parameter option is a prerequisite.
Reason and result: “client id table name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['client_id_table_name'] = '[PatientSchema].[Patient]'
Parameter ID: 3
client id query sql
client id query sql text

Client id, that is, the primary unique id value for the layer, can be a direct column value or can be generated with the help of SQL. Because sometimes the direct primary column id may not be designed in the tables. It is used in these situations, albeit rarely.

For instance, a unique primary ID value can be generated by concatenating multiple columns. Since complex SQL structures may be involved, information regarding the server database group is also prefixed to the tables—for example, using `[HIS].[Order].[Drug].[OrderId]` instead of `[Order].[Drug].[OrderId]`. HIS is the server databae group defined in server configurations.

* Parameter relationships
Parameter: layer_config['client_id_query_sql']
Condition: No other parameter option is a prerequisite.
Reason and result: “client id query sql” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['client_id_query_sql'] = 'CONCAT( [HIS].[Order].[Drug].[OrderId], '_', [HIS].[Order].[Drug].[ProductId])'
Parameter ID: 4
about
about text

Free-text description or notes about the layer.

* Parameter relationships
Parameter: layer_config['about']
Condition: No other parameter option is a prerequisite.
Reason and result: “about” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['about'] = 'Patient demographics and contact details'
Parameter ID: 5
layer tree
layer tree list_parameter

Contains the list of layers associated with the parent and child of the layer. Thus, the relationship of this layer with other layers is established. The last element in the list is this layer. The preceding elements refer to the upper layers. For example, the diagnosis layer is added after the other layers have been specified, starting from the top of the hierarchy.

* Parameter relationships
Parameter: layer_config['layer_tree']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer tree” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: Patient > Encounter > Diagnosis
layer_config['layer_tree'] = [{'layer_no': '1'}, {'layer_no': '3'}, {'layer_no': '7'}]
Parameter ID: 6
layer primary column name
layer primary column name list_parameter

The layer primary column value is usually the same as the client id value. The primary column value is used as a list. Usually there is one primary column in the table. However, in some cases, a row can be uniquely identified by using more than one column. In such instances, multiple columns can be selected as a list.

For example, an `Id` column might be designated directly as the primary column. Alternatively, a row in a table might be uniquely identified only when both `x_id` and `y_id` are considered together; in this case, both should be selected.

* Parameter relationships
Parameter: layer_config['layer_primary_column_name']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer primary column name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['layer_primary_column_name'] = [{'primary_column_name': 'Id'}]
Parameter ID: 8
primary column name
primary column name text

The selected primary column name within the primary-column list.

* Parameter relationships
Parameter: layer_config['layer_primary_column_name'][0]['primary_column_name']
Condition: The related layer_config['layer_primary_column_name'] item must exist.
Reason and result: Defines one column of the composite key that uniquely identifies the layer record.
Example: Id
layer_config['layer_primary_column_name'][0]['primary_column_name'] = 'Id'
Parameter ID: 9
primary column concat character
merging primary column names character text

If there is more than one primary column, a special character can be chosen to combine them. The underscore _ is generally used for joining.

* Parameter relationships
Parameter: layer_config['primary_column_concat_character']
Condition: No other parameter option is a prerequisite.
Reason and result: “primary column concat character” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example: _
layer_config['primary_column_concat_character'] = '_'
Parameter ID: 10
server group
server group text

The group in which the layer is located in the server list is selected here. Of course, first of all, servers must be created and server groups must be added within the servers. This parameter controls which servers can execute a query when it is initiated from this layer.

For example, suppose there are 20 servers in the server list. If we select "HIS" and 15 of those 20 servers are designated as belonging to the "HIS" server group, then any query initiated from this layer will only be processed across those 15 servers.

* Parameter relationships
Parameter: layer_config['server_group']
Condition: No other parameter option is a prerequisite.
Reason and result: “server group” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['server_group'] = 'HIS'
Parameter ID: 11
database group
database group text

There may be more than one database on the servers. While servers are defined under the map, database groups are also created. This parameter allows for the selection of a database group from those defined on the servers. You should select the database group that contains the layer's main table.

For example, general patient information might be stored in an "HIS" (Hospital Information Management System) database, while laboratory data might reside in a "LAB" database. This setting determines which database group—within the target server group—should be used to execute queries related to this layer.

* Parameter relationships
Parameter: layer_config['database_group']
Condition: No other parameter option is a prerequisite.
Reason and result: “database group” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['database_group'] = 'HIS'
Parameter ID: 12
unique in all database units
singular across all database units mi select

When the data is queried by Wanalyzer, if the data with the same id value is desired to be a single row after data is received from more than one server, then it is specified as yes. In this case, the prefix setting should be set to "no." This is because the unique ID value for a row within a layer must be consistent across all other servers; this is a concept applicable to centralized ID systems.

For example, consider data being collected from 10 different hospitals, where a national identification number serves as the unique identifier—acting as the primary ID. In this scenario, the system consolidates data from the various hospitals into a single row based on this ID. Consequently, data from all hospitals appear in a single row within the Wanalyzer datasets. While a specific laboratory test result might otherwise be stored across different hospital servers, it is consolidated into a single row and cell within the Wanalyzer dataset.

Note: Since this definition involves a data deduplication process for the project, some slowdown may be observed. Therefore, in a multi-hospital server configuration, it should only be used when data consolidation is required based on a central identifier—such as a patient-level ID.

* Parameter relationships
Parameter: layer_config['unique_in_all_database_units']
Condition: No other parameter option is a prerequisite.
Reason and result: “unique in all database units” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and usage purposes
0 — no
Treats the same ID value as a separate, distinct record within each database unit.
1 — yes
Deduplicates and consolidates records with the same ID value across all database units.
Example:
layer_config['unique_in_all_database_units'] = '1'
Parameter ID: 13
offset column
offset column list_parameter

Usually the same as the primary column value. When managing queries, the line point where the query remains is managed with this value. In other words, it is also used as an offset column. The mechanism for resuming from a specific point is managed using this column. In some cases, multiple columns may be required—much like with the primary column—to ensure uniqueness and handle the offset process. In such scenarios, the offset columns are added as a list, structured in a way that guarantees uniqueness.

* Parameter relationships
Parameter: layer_config['offset_column']
Condition: No other parameter option is a prerequisite.
Reason and result: “offset column” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['offset_column'] = [{'offset_column_name': '[Id]'}]
Parameter ID: 14
offset column name
offset column name text

The column name selected as an offset field.

* Parameter relationships
Parameter: layer_config['offset_column'][0]['offset_column_name']
Condition: The related layer_config['offset_column'] item must exist.
Reason and result: Defines a column used to track progress during incremental data transfer.
Example: Id
layer_config['offset_column'][0]['offset_column_name'] = '[Id]'
Parameter ID: 15
layer additional where
layer addition where query text

It is used when you want to create an absolute filter in the layer query.

For example, if we never want to retrieve those whose status is canceled in a reference layer, We can specify it as `[HIS].[PatientSchema].[Patient].[Status] IN ('0'). In fact, the query is generated by appending this to the `WHERE` clause.

* Parameter relationships
Parameter: layer_config['layer_additional_where']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer additional where” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
layer_config['layer_additional_where'] = "[HIS].[PatientSchema].[Patient].[Status] IN ('0')"
Parameter ID: 17
Worked example

Application example: Application layer

  1. Enter PatientApplication as the layer name.
  2. Select [Patient].[Application] as the main table.
  3. Set the primary column to Id .
  4. The offset column can also be Id .
  5. If "Patient" (Hasta) is the parent layer, establish the hierarchy as Patient → Application in the layer tree.
  6. To exclude cancelled records, enter a valid SQL condition in the additional "where" field.

about

Once a layer has been created on the database map, the parameters to be displayed in a common row within that layer are configured. Parameter settings offer a wide range of data retrieval methods; you can specify which table the data should be pulled from, which column within that table should be used, or even utilize a selected SQL model instead of a direct column reference. For parameters with selectable options, you can define static choices or configure the system to dynamically retrieve the label value for each option directly from the database.

status
status select

An active database map is available for selection in Wanalyzer. Inactive maps are not offered for selection.

* Parameter relationships
Parameter: parameter_config['status']
Condition: No other parameter option is a prerequisite.
Reason and result: “status” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — passive
Excludes the parameter from query generation and results.
1 — active
Allows the parameter to be used in queries and results.
Example: 1 — active
parameter_config['status'] = '1'
Parameter ID: 0
name
name text

The name of the parameter is its value. It should be designed using English characters without spaces. When multiple database maps are used in a Wanalyzer project, parameters with the same name within layers that also share the same name will produce identical query outputs.

* Parameter relationships
Parameter: parameter_config['name']
Condition: No other parameter option is a prerequisite.
Reason and result: “name” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
parameter_config['name'] = 'Gender'
Parameter ID: 2
prefix
prefix select

When a query with more than one server is appropriate, the prefix value indicating that there are different servers can be added to the beginning of the parameters coming from the query.

For example, the hospital code is IST in Istanbul hospital and IST in Ankara hospital. Let’s assume the code is ANK. Data is retrieved as IST_123 from the server with the code IST, and as ANK_123 from the server with the code ANK. This can be used when a parameter is intended to be presented as a unique, singular value.

* Parameter relationships
Parameter: parameter_config['prefix']
Condition: No other parameter option is a prerequisite.
Reason and result: “prefix” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and use cases
0 — no
Uses the parameter value without adding the server code.
1 — yes
Adds the server code to the beginning of the value to distinguish identical values ​​in multi-server queries.
Example:
parameter_config['prefix'] = '1'
Parameter ID: 1
table
table name text

If the parameter content will be a column of a table, table selection is made here. If parameter data will be taken directly from the main table, the main table value can be selected. This table name does not necessarily have to be the primary table of the layer. If data is to be retrieved from a table other than the primary one, a join relationship must be established between the primary table and the specified table. This join configuration is defined within the "Join SQL" parameter.

For instance, let the "Patient" (Hasta) layer be defined based on the `[Hasta]` table. Suppose we want to retrieve the "SMS communication consent" parameter from a related table—`[hastaizinler]` (patient consents)—and add it as a parameter to the Patient layer. In this case, the table name would be `[hastaizinler]`, and the `smsizni` (SMS consent) column from that table would be specified as the column name parameter. Furthermore, the `Id` in the `[Hasta]` table must be joined with the `HastaId` in the `[hastaizinler]` table. A join configuration such as the following should be defined in the "Join SQL" parameter:

LEFT JOIN [HBYS].[Hasta].[hastaizinler] WITH (NOLOCK) ON [HBYS].[Hasta].[hastaizinler].[State] = 1 AND [HBYS].[Hasta].[Hasta].[Id] = [HBYS].[Hasta].[hastaizinler].[HastaId]

Consequently, once the patient ID is obtained from the primary row in the `[Hasta]` table, the corresponding SMS consent status for that patient can be retrieved from the related consent table.

* Parameter relationships
Parameter: parameter_config['table']
Condition: parameter_config['select_sql_text'] must be empty.
Reason and result: Defines the table used in standard table/column mode; it is hidden when a custom SELECT statement is entered.
Example:
parameter_config['table'] = '[GeneralSchema].[Patient]'
Parameter ID: 3
column name
column name text

Column that provides the parameter value. The column name is expressed using square brackets.

* Parameter relationships
Parameter: parameter_config['column_name']
Condition: parameter_config['select_sql_text'] must be empty.
Reason and result: Defines the column used in standard table/column mode; it is hidden when a custom SELECT statement is entered.
Example:
parameter_config['column_name'] = '[GenderId]'
Parameter ID: 4
layer main date parameter
layer main date parameter select

If this parameter is the historical parameter of the layer, then it is specified as yes.

For example, when the laboratory layer is designed, the results of the laboratory parameters are also included. A historical parameter is defined. Selecting "yes" designates a specific historical parameter to represent the laboratory date for the entire layer. There must be exactly one such parameter for the entire layer.

* Parameter relationships
Parameter: parameter_config['layer_main_date_parameter']
Condition: No other parameter option is a prerequisite.
Reason and result: “layer main date parameter” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and intended use
0 — no
Does not use the parameter as the primary date parameter for the layer.
1 — yes
Designates the parameter as the sole primary date parameter representing the temporal information for the layer.
Example:
parameter_config['layer_main_date_parameter'] = '1'
Parameter ID: 5
Is the content in JSON text format?
Is the content in JSON format? text

If the data retrieved from the database is in a JSON object format, the specific key within that JSON should be specified here. This ensures that once the data is retrieved, the value corresponding to that key is extracted.

For example, the data retrieved from a database cell might look like this: {'pain': 'yes' , 'treatment_note': 'xxxx yyyy'}. The JSON key here can be either 'pain' or 'treatment_note'.

* Parameter relationships
Parameter: parameter_config['content_json_text']
Condition: No other parameter option is a prerequisite.
Reason and result: '0' — “no” processes the cell directly. '1' — “yes” enables JSON key, JSON field name, and JSON column-content type.
Options and intended use
0 — no
Used if the content in the cell is not in JSON format.
1 — yes
Selected if the content in the cell is in JSON format.
parameter_config['content_json_text'] = '1'
Parameter ID: 7
json key
json key text

If the data content received from the database is json in object format, then the key value in the json is specified here. Thus, once the data has been retrieved, the information corresponding to the relevant key is obtained.

For example, data from a database cell might arrive in this format: {'pain': 'yes', 'treatment_note': 'xxxx yyyy'}. Here, the JSON key could be 'pain' or 'treatment_note'.

* Parameter relationships
Parameter: parameter_config['json_key']
Condition: parameter_config['content_json_text'] = '1' ; option '1' means “yes” .
Reason and result: This field defines the key read from JSON; it is hidden and not evaluated when content is not JSON.
Example:
parameter_config['json_key'] = 'treatment_note'
Parameter ID: 7
json column content type
json column content format select

When the database cell content is json, a frequently used json content format determined directly, the format selection can be made to get the relevant data key region. If the target content matches these JSON formats, you can proceed by selecting one of the available formats. When selecting a format, the `json_field_name` must also be defined in accordance with that format.

format_2: [{"values":[xxx]}]

format3: [{"values":[{"value":"xxx"

format4: [{"values":[xxx]}]

format5: [{"values":["xxx"]}]

format6: [{"values":[{"value":"xxx"

format7: [{"children":{"' + json_field_name + '":[{"values":["xxx"]}]}

* Parameter relationships
Parameter: parameter_config['column_content_type']
Condition: parameter_config['content_json_text'] = '1' ; option '1' means “yes” .
Reason and result: This field defines the content type of the JSON value; it is hidden and not evaluated when content is not JSON.
Options and intended uses
0 — format 2
Parses cell content according to the format 2 schema.
1 — format 3
Parses cell content according to the format 3 schema.
2 — format 4
Parses cell content according to the format 4 schema.
3 — format 5
Parses cell content according to the format 5 schema.
4 — format 6
Parses cell content according to the format 6 schema.
5 — format 7
Parses cell content according to the format 7 schema.
Example:
parameter_config['column_content_type'] = '5'
Parameter ID: 9
json field name
json field name text

Field name used by supported structured JSON formats. For format 7, it identifies the named child collection that Wtransfer should read; the value must match the structure stored in the source column.

* Parameter relationships
Parameter: parameter_config['json_field_name']
Condition: parameter_config['content_json_text'] = '1' ; option '1' means “yes” .
Reason and result: This field defines the JSON field name used in output; it is hidden and not evaluated when content is not JSON.
Example:
parameter_config['json_field_name'] = 'children'
Parameter ID: 8
server group
server group text

When the server group is the server group belonging to the layer in which the parameter is located, there is no need to make any definition.

If, during a query on a target server, a parameter specifies a different server group, the system iterates through all servers associated with that specified server group in the database map, queries the targeted data, and adds it to the data list.

For example, suppose the server group for a given layer of this parameter is HIS . If, while processing the HIS servers, a parameter specifies a different server group—such as mobile —the data is instead queried from the servers defined under that mobile server group. This is a relatively uncommon configuration. If a design requires connecting to a different server group, the table names, column names, or SQL fields must be defined in accordance with the table structures present in those target server groups.

* Parameter relationships
Parameter: parameter_config['server_group']
Condition: The form's “Is the server the same as the layer main table server?” selection must be “no” .
Reason and result: Selects the server group when the parameter is read from a server different from the main layer server; it is cleared when “yes” is selected.
Example:
parameter_config['server_group'] = 'mobile'
Parameter ID: 10
select sql text
select query text text

The layer parameter is usually chosen as a column of a table. Sometimes a direct table may not have a column. Data can also be retrieved by constructing specific SQL queries—such as using `CASE` statements or other custom logic—to obtain parameters. In this approach, the table and column name fields are left blank, and a `SELECT` SQL statement is provided instead. The value of this `SELECT` SQL statement should consist of the text that would typically appear between the `SELECT` and `FROM` clauses of a standard SQL query.

For example, you can retrieve the Code information from the Hospital table by constructing a `SELECT` SQL statement like this: `(SELECT [HIS].[dbo].[Hospital].[Code] FROM [HIS].[dbo].[Hospital] WITH (NOLOCK) WHERE [HIS].[dbo].[Hospital].[Status] = 1)`. This SQL text is then inserted between the `SELECT` and `FROM` keywords to execute the query.

* Parameter relationships
Parameter: parameter_config['select_sql_text']
Condition: parameter_config['table'] must be empty.
Reason and result: Stores a custom SELECT statement when table/column selection is not used.
Example:
parameter_config['select_sql_text'] = '(SELECT [HIS].[dbo].[Hospital].[Code] FROM [HIS].[dbo].[Hospital] WITH (NOLOCK) WHERE [HIS].[dbo].[Hospital].[Status] = 1)'
Parameter ID: 11
where query
where query text

When the select sql text is produced, the same sql information is usually added here so that the same parameter can be queried in the where query. This is because a value retrieved via a `SELECT` statement—defined between the `SELECT` and `FROM` clauses—is then utilized within the `WHERE` clause of the query.

* Parameter relationships
Parameter: parameter_config['where_query']
Condition: parameter_config['select_sql_text'] must be populated.
Reason and result: Defines the filter applied to the custom SELECT statement; it is hidden without SELECT text.
Example:
parameter_config['where_query'] = "(SELECT [HBYS].[dbo].[Hastane].[Kod] FROM [HBYS].[dbo].[Hastane] WITH (NOLOCK) WHERE [HBYS].[dbo].[Hastane].[Status] = 1)"
Parameter ID: 12
database column type
database column type select

The type of the column in the database is selected here. It can be left blank when not directly connected to a specific column.

* Parameter relationships
Parameter: parameter_config['database_column_type']
Condition: No other parameter option is a prerequisite.
Reason and result: “database column type” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — smalldatetime
Processes the column as the MSSQL smalldatetime date-time type.
1 — datetime
Processes the column as the MSSQL datetime date-time type.
2 — int
Processes the column as an integer.
3 — bit
Processes the column as a bit carrying a true/false value.
4 — tinyint
Processes the column as a small-range integer.
5 — varchar
Processes the column as variable-length non-Unicode text.
6 — nvarchar
Processes the column as variable-length Unicode text.
7 — money
Processes the column as a monetary value.
8 — date
Processes the column as a date without time information.
9 — smallint
Processes the column as a smallint integer.
Example:
parameter_config['database_column_type'] = '1'
Parameter ID: 13
parameter type
parameter type select

WisdomEra parameter type, independent of the database-native type.

* Parameter relationships
Parameter: parameter_config['parameter_type']
Condition: No other parameter option is a prerequisite.
Reason and result: '0' means “select” , '1' “integer” , '2' “float” , '3' “text” , '4' “textarea” , and '5' “datetime” . Only '0' enables option settings.
Options and purposes
0 — select
Presents categorical data as selectable options.
1 — integer
Processes the parameter as an integer.
2 — float
Processes the parameter as a floating-point number.
3 — text
Processes the parameter as single-line text.
4 — textarea
Processes the parameter as long or multiline text.
5 — datetime
Processes the parameter as a date and time value.
Example:
parameter_config['parameter_type'] = '0'
Parameter ID: 14
server database group
server database group text

This parameter specifies which database group on the server the parameter data belongs to.

For instance, a server might contain databases named "dbo," "HBYS," and "LAB." If a parameter resides within the "LAB" database, "LAB" is selected here. A "database group" does not necessarily have to be the actual name of the database on the server; rather, these groups are defined within the server settings and then selected here. This is particularly useful in environments with multiple similar server structures, where the same database might be referred to by different names—in such cases, a common group name is created and used.

For example, if the first server contains a database named "HBYS_1" and the second server contains "HBYS_2," and both databases share the same table and column structure, they can be grouped under the name "HBYS." Consequently, when the servers are queried iteratively, the system retrieves the specific database name from the database group to construct the queries.

* Parameter relationships
Parameter: parameter_config['server_database_group']
Condition: No other parameter option is a prerequisite.
Reason and result: “server database group” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
parameter_config['server_database_group'] = 'HIS_MAIN'
Parameter ID: 16
server id
server id text

INormally, when a query is executed, it continues its query cycle on the server associated with the layer. However, this parameter is used when a specific value needs to be retrieved directly from a different server, rather than from the active server within the current cycle. It is generally left unspecified; this is a very rarely used configuration. For instance, it might be employed when a piece of information needs to be fetched from an entirely different server.

* Parameter relationships
Parameter: parameter_config['server_id']
Condition: The same-server selection must be “no” and parameter_config['server_group'] must be populated.
Reason and result: Selects the concrete server record in the different server group; the field is hidden and cleared when conditions do not hold.
Example:
parameter_config['server_id'] = 'bd513e04-d868-45d5-82d3-78ed0d2a7bef'
Parameter ID: 17
bit column true option
bit column true option select

A column in a bit format—that is, a True/False format—might sometimes be designed to represent the opposite of what its name suggests.

For instance, a state of "having no complaints" could be configured as "True." If the parameter is instead defined based on "having a complaint," then the "False" value in the database actually represents the "true" (correct) condition. In this case, by selecting "False" for this parameter, we effectively specify the value that is considered the correct one for that parameter.

* Parameter relationships
Parameter: parameter_config['bit_column_true_option']
Condition: No other parameter option is a prerequisite.
Reason and result: “bit column true option” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Options and purposes
0 — false
Treats the database false value as the parameter positive/true option.
1 — true
Treats the database true value as the parameter positive/true option.
Example: 1
parameter_config['bit_column_true_option'] = '1'
Parameter ID: 18
join sql
join sql textarea

When data needs to be retrieved from another table related to the main table, the JOIN structure is defined here.

For example, when the main table is Patient and data needs to be retrieved from the PatientPermissions table, a JOIN SQL statement can be designed using the relationship Patient.Id = PatientPermissions.PatientId . This allows the value of the SmsPermission parameter to be retrieved from the PatientPermissions table.

In JOIN statements, table references must include the database group prefix. For example, tables should be referenced as [HIS].[Patient].[PatientPermissions] rather than [Patient].[PatientPermissions] . HIS: Health Information System

* Parameter relationships
Parameter: parameter_config['join_sql']
Condition: No other parameter option is a prerequisite.
Reason and result: “join sql” is stored directly in its record context; its frontend visibility and backend persistence do not depend on another parameter option.
Example:
parameter_config['join_sql'] = 'LEFT JOIN [HIS].[Patient].[PatientPermissions] WITH (NOLOCK) ON [HIS].[Patient].[PatientPermissions].[State] = 1 AND [HIS].[Patient].[Patient].[Id] = [HIS].[Patient].[PatientPermissions].[PatientId]'
Parameter ID: 19
option type
option type select

For parameters with options, this determines how a categorical value retrieved from the database is converted into a label to be displayed to the user. For example, mapping the value '1' to the label 'Female' is handled using one of these methods.

Label resolution methods

1. Use parameter options

Define the values ​​and labels as a static list of options. No additional queries are executed; this is suitable for lists that do not change frequently. Other option query fields are left blank.

  • Required: The list of options must be manually added to the options list field.
  • Server and table settings are not used.
  • The label is read directly from the static list.
  • Recommended for small, static lists. (female 1, male 2 etc.)

2. Retrieve the option label via a query

Fetch both the value and the label within the same SQL query. For a simple lookup, join the Patient.GenderId and Gender.Id fields, and select Gender.Name as the label. If only active rows are required, add a State = 1 condition. For labels composed of multiple columns—such as a doctor's name—use the CONCAT function within the label selection query.

  • Required: Option table name
  • Required: Option value column
  • Either the label column or the label selection query must be provided
  • Optional: Option join condition
                          
                            SELECT
                            
Patient.GenderId,
Gender.Name AS label FROM Patient LEFT JOIN Gender ON Gender.Id = Patient.GenderId WHERE Patient.Id = '12345'

3. Post-parameter query

If the label cannot be joined within the same query, first retrieve the parameter value, then send a separate query to the lookup source—which may reside on a different server or database. Since this method incurs the cost of an additional query, it should only be used when the sources cannot be joined in a single query.

  • Required: target server group and server ID
  • Required: target table, value column, and label column
  • Optional: a different database group for the target
  • Optional: additional WHERE clause

4. Use database mapping

Define standard options within an option list and map the values ​​from the source database to these options. In WisdomEra standard mappings, this enables algorithms to operate using fixed, consistent values.

For example, the standard of Female = 1 and Male = 2 can be maintained.

  • Required: list of options
  • Required: database mappings for the options
  • Other option query fields are left blank
  • Recommended for standard mappings
* Parameter relationships
Parameter: parameter_config['option_type']
Condition: parameter_config['parameter_type'] = '0' ; parameter type '0' means “select” .
Reason and result: '0' means “use parameter options” ; '1' “retrieve option label by query” ; '2' “after parameter query” ; and '3' “use database mapping” . The selection enables only the relevant list or query fields.
Options and intended uses
0 — use parameter options
Retrieves the label from a fixed list of options.
1 — retrieve option label via query
Retrieves both the value and the label in the same query.
2 — post-parameter query
Resolves the label using a separate query.
3 — use database mapping
Converts the source value into a standard label.
Example:
parameter_config['option_type'] = '0'
Parameter ID: 28
option server database group
option server database group text

It is used in select type parameters. If the option value is to be connected to a different database and retrieved, then the database group is specified. If no database group is specified, the parameter's database group is used as the target database.

For instance, while the database group for a parameter might be HIS, the option values ​​for that parameter could be retrieved from a different database named LOOKUP.

* Parameter relationships
Parameter: parameter_config['option_server_database_group']
Condition: parameter_config['option_type'] must be '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_server_database_group'] = 'LookupDb'
Parameter ID: 20
option server id
option server id text

It is used for parameters of the "select" type—that is, those offering a choice of options. It is employed when the values ​​for these options are to be retrieved from another server.

* Parameter relationships
Parameter: parameter_config['option_server_id']
Condition: parameter_config['option_type'] must be '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_server_id'] = '3'
Parameter ID: 30
option value column
option value column text

It is used for parameters of the "select" type—that is, those with options. It represents the "value" of an option; in other words, it is the unique ID value for that option.

* Parameter relationships
Parameter: parameter_config['option_value_column']
Condition: parameter_config['option_type'] must be '1' — “retrieve option label by query” , '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_value_column'] = '[Id]'
Parameter ID: 21
option table name
option table name text

Table containing the option lookup records. Specify the schema-qualified table name. Tables are expressed with schemas.

* Parameter relationships
Parameter: parameter_config['option_table_name']
Condition: parameter_config['option_type'] must be '1' — “retrieve option label by query” , '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_table_name'] = '[GeneralSchema].[Gender]'
Parameter ID: 22
option server group
option server group text

It is used for parameters of the "select" type—that is, those offering a choice of options. It is employed when the values ​​for these options are to be retrieved from another server.

* Parameter relationships
Parameter: parameter_config['option_server_group']
Condition: parameter_config['option_type'] must be '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_server_group'] = 'LookupServer'
Parameter ID: 23
option additional where query
option additional where query text

It is used in select type parameters. If the option type is in 'parameter query after' mode, this parameter is filled if necessary. If you need to retrieve a specific row—such as one where a 'state' column indicates it is active—from the table containing the label value, you can define that condition here using a `WHERE` clause. This is optional.

Within the queries, the server database group is also specified, along with the tables.

* Parameter relationships
Parameter: parameter_config['option_additional_where_query']
Condition: parameter_config['option_type'] must be '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_additional_where_query'] = '[HIS].[Gender].[Status] = 1'
Parameter ID: 24
option server name
option server name text

It is used in select type parameters. Options are available when retrieving from another server. It is not mandatory. It can be used for general informational purposes to indicate a server name.

* Parameter relationships
Parameter: parameter_config['option_server_name']
Condition: parameter_config['option_type'] must be '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_server_name'] = 'Lookup Server'
Parameter ID: 25
option join
option join text

It is used in select type parameters. It is not mandatory.

If the option type is set to 'query with parameter' mode, the label is retrieved by performing a join with the target lookup table using the value obtained from the parameter. In some cases, an additional join may be required; this field is used for that purpose.

* Parameter relationships
Parameter: parameter_config['option_join']
Condition: parameter_config['option_type'] must be '1' — “retrieve option label by query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_join'] = 'LEFT JOIN [HIS].[Patient].[PatientPermissions] WITH (NOLOCK) ON [HIS].[Patient].[PatientPermissions].[State] = 1 AND [HIS].[Patient].[Patient].[Id] = [HIS].[Patient].[PatientPermissions].[PatientId]'
Parameter ID: 26
option label column
option label column text

It is used for parameters of the "select" (choice-based) type. It specifies the column from which the label value for an option is to be retrieved. Most commonly, these label values ​​are obtained by providing the name of the table containing the options and the specific column that serves as the option label.

Square brackets are also used at the beginning and end of column names.

* Parameter relationships
Parameter: parameter_config['option_label_column']
Condition: parameter_config['option_type'] must be '1' — “retrieve option label by query” , '2' — “after parameter query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example: Name
parameter_config['option_label_column'] = '[Name]'
Parameter ID: 27
option label select sql
option title select query text

It is used in select type parameters. When multiple columns are used as option labels instead of a single standard column from the table, the query text to be added to the `SELECT ... FROM` statement is specified here.

* Parameter relationships
Parameter: parameter_config['option_label_select_sql']
Condition: parameter_config['option_type'] must be '1' — “retrieve option label by query” .
Reason and result: Participates in resolving the option value and displayed label from the related table/server query; it is hidden for other option types.
Example:
parameter_config['option_label_select_sql'] = "CONCAT([firstname], ' ', [surname])"
Parameter ID: 29
option list
option list textarea

This is used for parameters of the "select" (option-based) type. Options are added and managed via the option list management table. For option types that are in database-mapping mode, a database mapping must also be configured.

i: the ID value. Example: '1'

l: the label or title. Example: 'woman'

di: the database ID value. Example: '2'

dl: the database label value. Example: 'female'

* Parameter relationships
Parameter: parameter_config['option_list']
Condition: parameter_config['option_type'] must be '0' — “use parameter options” or '3' — “use database mapping” .
Reason and result: Stores fixed option value/label pairs and, where needed, their database mappings.
Example:
parameter_config['option_list'] = '[{"i":"1","l":"female","di":"","dl":""},{"i":"2","l":"male","di":"","dl":""}]'
Parameter ID: 31
option list sql
option list sql text

When the option list type is of type - with parameter query- , it needs to be updated in the option list layer parameter from the servers in the database map. Wtransfer automatically connects to the servers to update parameter options. Consequently, if any new options have been created, they appear within the parameter options—and by extension, in the sections of Wanalyzer where query rules are defined—making them available for use. This mechanism is not used during the actual creation of a data query, and it is not mandatory for an option to be predefined; however, if it is defined, the list of parameter options is updated automatically. When creating the query, the option's ID value must be defined as ' value ' and its label as ' label ' using the 'as' syntax.

For instance, when a new test is added to the laboratory test list within a hospital database, this SQL query retrieves the new test and adds it to the parameter's list of options. As a result, this new test value becomes visible among the parameter options when constructing a query in Wanalyzer.

* Parameter relationships
Parameter: parameter_config['option_list_sql']
Condition: parameter_config['parameter_type'] = '0' ; parameter type '0' means “select” .
Reason and result: Custom SQL used to generate options; it is unused outside option settings.
Example:
parameter_config['option_list_sql'] = "SELECT Code AS 'value', Name AS 'label' FROM GenderOption"
Parameter ID: 15
Worked example

Application example: Gender parameter

  1. create gender parameter as select type;
  2. source table [GeneralSchema].[Hasta] ,
  3. with the column [GenderId] .
  4. For static options, select “use parameter options”;
  5. if a lookup JOIN can be established within the same query, select “retrieve option label via query”;
  6. if a different server is required, select “after parameter query”;
  7. if database mappings are maintained in a standardized map, select the “use database mapping” method.

                      // these SQL constructs run in the background.
                      
SELECT
P.GenderId,
G.Name AS label
FROM [HIS].[GeneralSchema].[Patient] P
LEFT JOIN [HIS].[GeneralSchema].[Gender] C ON G.Id = P.GenderId
WHERE H.Id = '12345'
Example flow across management pages

End-to-end example flow

Step Management page Check
1 Database Map Management Page Active map, unique name, and remote Wtransfer endpoint when needed
2 Server Management Page Active node, IP/domain, order, logical group, and physical DB name
3 Layer Management Page Server/database group, main table, primary/offset columns, and layer tree
4 Layer Parameter Management Page Table+column or select SQL, plus the correct option method for select fields
Install a Ready DB Map

Ready database map installation

This process covers matching and using database maps supplied by WisdomEra with the system installation. The database map is installed in the language selected by the user. Two installation modes are available.

Automatic product updates

Updates published by WisdomEra may introduce new layers, parameters, and options. This mode is suitable for keeping the standardized data integration model up to date automatically. Users cannot modify the layer and parameter structures.

Manual management

After installation, users can make all changes and add new layers or parameters. In this mode, WisdomEra updates are not applied to the map automatically.

Generate Database Map Configuration

Generate the live configuration

This button converts the target configuration into a form that can be used in production, based on server additions, layer settings, and parameter settings.


Complete server, layer, and parameter work

Generate database map configuration

Use the updated map
Important: Changes do not become active until this action is triggered. This prevents work in progress from disrupting the currently active configuration.

After the work is complete, click the button to generate a new configuration and make the current version of the database map available for use.

Update Options

Update parameter options

This button refreshes newly generated labels on the servers for selectable database-map parameters whose option source is parameter query .


Identify selectable parameters

Query new labels on the servers

Refresh parameter options
This process normally runs automatically in the background. A user who does not want to wait for the scheduled run can trigger the update directly with this button.
Use This Server for Configuration

Select the reference configuration server

Defining database groups and selecting tables and columns for a database map requires a reference server. Therefore, after creating the map, first add a server so its database, table, and column structures can be used for selection.

Add a server
Select the configuration server
Select databases, tables, and columns
Change the server when necessary

When this button is clicked, all database, table, and column selections on the screen use that server as the reference. If a different database server must be used while configuring a layer, select the relevant server and click the button again.

Wtransfer Query Builder

Test layer and parameter settings

This screen is used to test the configured layer and parameter settings. First select the server to use for configuration. The main rule and column rules can then be queried on that server with the specified limit.

Select the configuration server
Apply the main rule and column rules
Run the query with the specified limit
Review the generated SQL queries
Viewing and checking the generated SQL queries makes it easy to verify whether the layer and parameter settings have been configured correctly.