Apache Ossie Conversion Reference
This reference describes the converter between Coginiti semantic model files (.smdl) and Apache Ossie semantic model documents. The reference shows each mapping in the 2 directions. The reference also shows each message that the converter can report, and the data that each direction does not keep.
For the procedure, the checklists and the corrective actions, see How to import and export Apache Ossie semantic models.
Overview
| Property | Value |
|---|---|
| Availability | Coginiti Team and Coginiti Enterprise |
| Import entry point | Catalog context menu of a project or of a project folder: Import Apache Ossie Model… |
| Export entry point | Catalog context menu of an .smdl file, of a folder, or of a project with 1 semantic layer: Export Apache Ossie Model… |
| Accepted spec versions for an import | 0.1.1, 0.2.0.dev0 |
| Written spec version for an export | 0.2.0.dev0 |
| Document shape | 0.2.0.dev0: 1 model, with name, datasets and the other model keys at the top level, next to version. 0.1.1: 1 or more models in a semantic_model list |
| Maximum document size | 16 MB. The import examines the size before the conversion |
| Import scope | 1 YAML document. One model gives .smdl files without folders. A 0.1.1 document with more than 1 model gives 1 folder for each model |
| Export scope | 1 semantic layer for each document. A project or a folder with 2 or more semantic layers is exported 1 layer at a time |
The importer only adds entities. The importer does not replace an entity.
Terminology
| Ossie | Coginiti | Meaning |
|---|---|---|
| semantic model | semantic layer | 1 named set of tables, columns, aggregates and joins |
| dataset | entity | A table, a view, or a query. Each dataset has 1 .smdl file |
| field | dimension | A column that you can use in a GROUP BY |
| metric | measure | An aggregate, for example a sum or a count |
| relationship | relationship | A join between 2 tables |
Messages
Each import and each export makes a list of messages. Each message has a code and a severity.
| Severity | Meaning |
|---|---|
| Error | The error stops the full conversion. The conversion does not make files |
| Warning | The conversion was successful, but did not keep some data, or changed some data |
| Info | The conversion changed the shape of an object, or removed the description of the model. The message tells you how |
Coginiti does not keep the messages after the dialog is closed. The counts in the dialog include only fields, metrics and joins that the conversion did not import. Keys, markers, synonyms and name changes that the conversion removed do not change the counts.
The importer reports only the first name error or database error. After you correct this error, the next import possibly reports the next error. The errors generated_smdl_invalid and layer_conflict do not return a list of warnings.
Import mapping
Elements
| Ossie | Coginiti |
|---|---|
| a model | a set of .smdl files in the target project. In a 0.1.1 document with more than 1 model, 1 folder for each model |
a dataset, with description and ai_context.synonyms | an entity in 1 .smdl file, with description and synonyms |
a field, with label, description and synonyms | a dimension. A field always becomes a dimension, never a measure |
a field expression | a dimension expr. The importer copies the expression of the selected dialect without changes |
| a metric over 1 dataset | a measure in that entity |
| a ratio, or arithmetic over aggregates | 1 hidden measure for each aggregate, and 1 derived measure with the formula |
| a relationship | a many_to_one relationship on the from entity |
primary_key | primary_key, with only the columns that are defined as fields |
a COGINITI entry in custom_extensions | the setting in the entry: label, hidden flag, measure filter, derived formula, entity of a measure, join type, join expression, or CoginitiScript block reference |
Document shape
A 0.2.0.dev0 document holds 1 model. The model keys are at the top level, next to version. The keys name and datasets are mandatory. A 0.2.0.dev0 document with a semantic_model list stops the import with wrapped_semantic_model.
version: "0.2.0.dev0"
name: sales
datasets:
- name: orders
source: public.orders
A 0.1.1 document holds 1 or more models in a semantic_model list.
version: "0.1.1"
semantic_model:
- name: sales
datasets:
- name: orders
source: public.orders
- name: hr
datasets:
- name: employees
source: public.employees
Source
The importer divides a source with 3 parts into database, schema and table. The importer compares the database part with the database of the selected environment. Then the importer removes the database part. If the environment does not have a database, the importer does not do the comparison. The importer then reports the message database_unverified.
- name: store_sales
source: tpcds.public.store_sales
entity "store_sales" {
schema_name = "public"
table_name = "store_sales"
}
File layout
| Document | Files |
|---|---|
1 model with the datasets orders and customers | orders.smdl, customers.smdl |
a 0.1.1 document with the models sales and hr | sales/orders.smdl, hr/employees.smdl |
All entities are in the same semantic layer. Each dataset name must be unique in the full document, without regard to letter case.
Data types
A document without a datatype gets 1 lossy_datatype message for each
model. The message gives the number of fields and metrics that became text.
A change in the table that follows does not get a message.
Ossie datatype | Coginiti type | Data that is not kept |
|---|---|---|
String | text | none |
Integer | integer | none |
Decimal | decimal | none |
Float | float | none |
Boolean | bool | none |
Date | date | none |
DateTime | datetime | none |
Time | text | the time semantics |
DateTimeTz | datetime | the time zone |
Opaque, or no datatype | text | the type |
A 0.1.1 document does not have a datatype. Each dimension and each measure becomes text, also sums and counts.
Dialect selection
A field or a metric has 1 expression for each dialect. Coginiti keeps 1 expression. The importer selects the entry for the platform of the selected environment. If that entry is not available, the importer selects ANSI_SQL. If ANSI_SQL is not available, the importer selects OSSIE_SQL_2026, the portable SQL of the Ossie spec. The importer removes each other entry without a message.
| Platform of the environment | Entry that the importer uses |
|---|---|
| Snowflake | SNOWFLAKE. If not available, ANSI_SQL, then OSSIE_SQL_2026 |
| BigQuery | BIGQUERY. If not available, ANSI_SQL, then OSSIE_SQL_2026 |
| Databricks | DATABRICKS. If not available, ANSI_SQL, then OSSIE_SQL_2026 |
| other | ANSI_SQL. If not available, OSSIE_SQL_2026 |
The importer does not read MDX, TABLEAU, MAQL, SIGMA, THOUGHTSPOT, DAX or HOLISTICS_AQL. The importer does not import a field or a metric that has no applicable entry. The importer reports dialect_unavailable. A 0.1.1 document does not permit BIGQUERY, OSSIE_SQL_2026, or a different dialect that Ossie added after 0.1.1. The schema check refuses such a document.
- name: email_normalized
expression:
dialects:
- dialect: ANSI_SQL
expression: LOWER(email)
- dialect: SNOWFLAKE
expression: LOWER(email)::VARCHAR
datatype: String
On a Snowflake project, the result is expr = "LOWER(email)::VARCHAR". On a Postgres project, the result is expr = "LOWER(email)".
Metrics
The importer removes the dataset name from the argument and writes the SQL again.
- name: total_revenue
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(orders.amount)
datatype: Decimal
measure "total_revenue" {
type = "decimal"
aggregation_type = "sum"
expr = "amount"
}
The importer imports 7 forms directly. Each form has 1 argument.
| Ossie expression | aggregation_type |
|---|---|
SUM(t.x) | sum |
COUNT(t.x) | count |
COUNT(DISTINCT t.x) | count_distinct |
AVG(t.x) | avg |
MIN(t.x) | min |
MAX(t.x) | max |
MEDIAN(t.x) | median |
The importer imports COUNT(*) in a document with 1 dataset. In a document with more than 1 dataset, write COUNT(orders.*). The importer imports COUNT(1) from a Coginiti export into the entity that the entity key of the COGINITI entry names.
A FILTER (WHERE ...) clause becomes the measure filter, if the condition uses only the same dataset. The clause parses on a Postgres project. Snowflake, BigQuery, Redshift, Yellowbrick and SQL Server do not have a FILTER clause. On these platforms, the importer does not import the metric, because the SQL does not parse.
- name: closed_total
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(orders.amount) FILTER (WHERE orders.status = 'closed')
measure "closed_total" {
aggregation_type = "sum"
expr = "amount"
filter = "status = 'closed'"
}
Decomposed metrics. A ratio, or arithmetic over aggregates, becomes 1 hidden measure for each aggregate. The ratio also becomes 1 derived measure with the formula. Each hidden measure goes into the entity of the aggregate. The name of each hidden measure starts with the metric name. The derived measure goes into the first entity that is not a query. The message metric_decomposed shows the names of the parts. A ratio over 1 dataset gives the same shape, with all parts in that entity.
- name: customer_lifetime_value
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(store_sales.ss_ext_sales_price) / COUNT(DISTINCT customer.c_customer_sk)
# store_sales.smdl
measure "customer_lifetime_value_sum" {
aggregation_type = "sum"
expr = "ss_ext_sales_price"
hidden = true
}
measure "customer_lifetime_value" {
expr = "customer_lifetime_value_sum / customer.customer_lifetime_value_count_distinct"
}
# customer.smdl
measure "customer_lifetime_value_count_distinct" {
aggregation_type = "count_distinct"
expr = "c_customer_sk"
hidden = true
}
Coginiti aggregates each part at the grain of the entity of that part, and then joins. Thus, the result is the same as the result of the original metric. A metric over more than 1 dataset must have a relationship path between the datasets. Without a path, the importer does not import the metric and reports metric_not_importable.
The importer does not import a metric that has the same name as a field of the dataset. The importer reports metric_name_collision.
The entity key. A document from Coginiti has an entity key in the COGINITI entry of each metric. The importer uses the key when the SQL does not name the entity of the measure. COUNT(1) names no dataset. A measure with a filter on a joined dataset names 2 datasets. The importer puts the measure into the entity of the key, if each other dataset in the SQL has a relationship path from that entity. The importer removes only the qualifier of that entity. The other dataset.column references stay as written. A document from a different tool has no entity key. The importer then uses the usual rules.
- name: eu_revenue
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(CASE WHEN customers.region = 'EU' THEN orders.amount END)
custom_extensions:
- vendor_name: COGINITI
data: '{"v":1,"filter":"customers.region = ''EU''","measure_expr":"amount","entity":"orders"}'
# orders.smdl
measure "eu_revenue" {
aggregation_type = "sum"
expr = "amount"
filter = "customers.region = 'EU'"
}
An entity that is not a dataset of the model gives malformed_coginiti_extension. The importer then uses the usual rules.
Relationships
Ossie does not have a join type. The from side is always the many side. The columns in from_columns and to_columns make pairs by position. No message reports a change in the order.
- name: store_sales_to_date
from: store_sales
to: date_dim
from_columns: [ss_sold_date_sk]
to_columns: [d_date_sk]
relationship "store_sales_to_date" {
type = "many_to_one"
expr = "store_sales.ss_sold_date_sk = date_dim.d_date_sk"
}
Each join column must be defined as a field of the dataset. The importer removes a join with a column that is not a field. The importer reports relationship_excluded.
A COGINITI entry with join_type sets one_to_one or one_to_many. A COGINITI entry with join_expr sets the full join condition. The condition must parse and must use only imported dimensions of the 2 datasets. If not, the importer uses the equality join and reports malformed_coginiti_extension.
Import messages
Warnings
| Code | Data that is not kept | Action |
|---|---|---|
metric_not_importable | A nested aggregate. An aggregate that is not 1 of the 7 forms. A column that is not in an aggregate. A metric over 2 or more datasets without a relationship path. A metric without a column, for example COUNT(1), in a model with 2 or more datasets and without an entity key | Write the metric again with the 7 forms, add the relationship, or write COUNT(orders.*) |
metric_not_importable | A metric with OVER (...), IGNORE NULLS, RESPECT NULLS or WITHIN GROUP, or with a FILTER condition on a different dataset. A standard aggregate with the same name gives different results. Thus, the importer makes no measure | Make the measure manually in Coginiti |
relationship_excluded | A join with a column that is not a field. A join with column lists of different lengths. A join with a dataset in a different model | Add the field, correct the lists, or move the 2 datasets into 1 model |
primary_key_column_dropped | A key column that is not a field. The key becomes shorter | Add the column as a field. Set the field to hidden if necessary |
dialect_unavailable | A field or a metric without an entry for the platform, ANSI_SQL or OSSIE_SQL_2026. A DAX, SIGMA, MDX or HOLISTICS_AQL entry alone is not sufficient | Add an ANSI_SQL entry |
field_not_importable | A field with an expression that is not SQL, or with an aggregate. A field is a row expression | Write the expression again as SQL. Move an aggregate into a metric |
lossy_datatype | The type of each field and each metric without a datatype. These become text, also sums and counts | Add a datatype to each field and each metric. A 0.1.1 document does not have this key. First set version to "0.2.0.dev0" |
metric_name_collision | A metric with the same name as a field of the dataset | Change the name of the metric |
relationship_target_not_key | No data. The to columns are not a key. Thus, the join can return more rows | Add a primary_key on the to dataset, if the columns are unique |
dropped_unique_keys | Each unique_keys entry | None. Coginiti does not have a unique key property |
dropped_is_time | The is_time flag. The importer also reports the value false | None. Coginiti does not have a time role marker |
dropped_ai_context | instructions, examples, or an ai_context that is a string | Move the text into description. Coginiti keeps only synonyms |
invalid_synonym_dropped | An empty synonym, or a synonym that occurs more than 1 time without regard to letter case | None. The importer keeps the first copy |
foreign_extension_dropped | Each custom_extensions entry of a different vendor | Read the content of the entry. For example, a Databricks row filter changes each result |
malformed_coginiti_extension | A COGINITI entry that the importer cannot read, or an entity that is not a dataset of the model. The importer uses the standard Ossie form | Correct the JSON, or set the option again in Coginiti |
database_unverified | No data. The environment does not have a database. Thus, the importer did not examine the sources with 3 parts | None. Information only |
query_source_unchecked | No data. A query is the source of the dataset. Thus, the database comparison is not applicable | None. Information only |
diagnostics_elided | No data. The response has more than 200 messages. The list shows the first 199 | Correct the reported items. Then import the file again to see the other messages |
Info
| Code | Meaning |
|---|---|
metric_decomposed | A metric became more than 1 measure. The message shows the names of the parts |
dropped_model_metadata | The importer removed the description and the ai_context of the model. Coginiti does not keep these items |
Errors
| Code | Cause | Action |
|---|---|---|
yaml_parse_error | Invalid YAML, a repeated key, or 2 documents in 1 file. Also, an anchor that makes many copies, or more than 128 levels of nesting. These protect the server | Correct the YAML. Use 1 document for each file. Write the repeated data in full |
schema_violation | A key that the spec does not permit, a missing version, or a 0.1.1 document without a model. In a 0.2.0.dev0 document, also an empty name, an empty source, or an empty datasets, primary_key or unique_keys list. The message shows a path, for example /datasets/2 in a 0.2.0.dev0 document, or /semantic_model/0/datasets/2 in a 0.1.1 document. The first index is 0 | Remove the key, add version, or add the empty value. In a 0.1.1 document, a datatype or a vendor_name: COGINITI entry also gives this error. Version 0.1.1 does not have these items. Set version to "0.2.0.dev0" |
unsupported_version | A version that the importer does not know | Set version to "0.2.0.dev0" |
wrapped_semantic_model | A 0.2.0.dev0 document with a semantic_model list. Ossie removed the list from 0.2.0.dev0. The importer reports only this error | Move name, datasets and the other model keys to the top level, next to version. Put each other model into a document of its own |
invalid_name | A name that is not a valid file name. This applies to a model name and a dataset name. The name becomes a file or a folder | Remove /, \, <, >, ", |, ?, *, : and control characters. Do not end the name with a dot or a space. Do not use ., .., or a Windows device name such as con, nul, aux or com1 |
invalid_name | A name that is not an SQL identifier. This applies to a dataset name, a field name, a metric name and a relationship name | Start the name with a letter or an underscore. Use only letters, digits and underscores. Thus, Sales 2024 and order.items are not permitted |
duplicate_name | Two models of a 0.1.1 document, 2 datasets, or 2 fields in 1 dataset have the same name. The importer compares model names and dataset names without regard to letter case | Change 1 name |
database_mismatch | A source with 3 parts has a database that is different from the database of the environment | Remove the database part. As an alternative, import the file into a project with an environment that uses that database |
source_not_importable | A dataset with a source that is empty or has only spaces. The entity has no data. In a 0.2.0.dev0 document, an empty source gives schema_violation instead | Give the dataset a table or a query |
generated_smdl_invalid | The new entities do not load. The text after the colon shows the cause. A COGINITI entry that was changed manually is the usual cause | Correct the entry |
existing_layer_invalid | The target semantic layer does not load | First correct the semantic layer |
layer_conflict | A dataset has the name of an entity that is already in the semantic layer, without regard to letter case. An import of the same file 2 times always gives this error | Change the name of the dataset, import the file into an empty project, or delete the existing entity |
Data that the importer removes without a message
| Data | Where to examine |
|---|---|
| each dialect entry that the importer did not select | each dimension expr |
| synonyms on a relationship | relationships do not have synonyms in Coginiti |
the database part of a source with 3 parts | the schema_name of each entity |
| changed data types | each text dimension and measure |
| the order of the pairs of join columns | each relationship expr |
| comments and YAML anchors | comments are removed. An anchor becomes a copy. An anchor that makes many copies stops the import |
Export mapping
Elements
The exporter writes 1 document for 1 semantic layer, always with version: 0.2.0.dev0. The model keys are at the top level of the document. The model name is the name of the semantic layer. The file name is the name of the layer, for example sales.yaml. Coginiti refuses to export a project or a folder with 2 or more semantic layers.
| Coginiti | Ossie |
|---|---|
| a table entity | source: schema.table, without a database part |
| a query entity | a source with the query text |
| an entity with a CoginitiScript block that resolves | a source with the resolved table, and the block reference in a COGINITI entry |
| each dimension | a field with datatype, label, description and synonyms |
| a measure with a standard aggregate | a metric, AGG(entity.column), and the entity name in a COGINITI entry |
a measure filter | a CASE WHEN ... END in the SQL |
| a derived measure | a metric with the fully expanded SQL, and the formula in a COGINITI entry |
a many_to_one relationship | from, to, and 2 column lists |
a one_to_many relationship | from and to in the opposite order, and join_type in a COGINITI entry |
a one_to_one relationship | from and to in the same order, and join_type in a COGINITI entry |
| a relationship with a condition that is not an equality | the equality part in the column lists, and the full expr as join_expr in a COGINITI entry |
The exporter adds the entity name to each column reference that does not have a name.
measure "total_amount" {
label = "Total Amount"
type = "decimal"
aggregation_type = "sum"
expr = "amount"
}
- name: total_amount
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(orders.amount)
datatype: Decimal
custom_extensions:
- vendor_name: COGINITI
data: '{"v":1,"entity":"orders","label":"Total Amount"}'
Dialect labels
The exporter gives the SQL the label of the platform. The exporter does not translate the SQL.
| Platform of the semantic layer | Entries that the exporter writes |
|---|---|
| Snowflake | SNOWFLAKE and ANSI_SQL, with the same SQL |
| BigQuery | BIGQUERY and ANSI_SQL, with the same SQL |
| Databricks | DATABRICKS and ANSI_SQL, with the same SQL |
| other | only ANSI_SQL |
The document does not record the platform of the SQL.
Data types
Coginiti type | Ossie datatype |
|---|---|
text | String |
integer | Integer |
decimal | Decimal |
float | Float |
number | Float. The type returns as float |
bool | Boolean |
date | Date |
datetime | DateTime |
The COGINITI extension
Ossie cannot show some settings. The exporter stores these settings in a custom_extensions entry with vendor_name: COGINITI. The data field of the entry is a JSON string with "v":1 and the keys in the table. Each metric has an entry, because each metric has the entity key. Other tools ignore the entry. If a tool removes the entry, all these settings are removed at the same time.
| Key | Location | Coginiti setting | What a different tool sees |
|---|---|---|---|
label | dataset, metric | the label of the entity or of the measure | no label. Ossie fields have a label. Ossie metrics and datasets do not have a label |
hidden | field, metric | hidden = true | a visible field or metric |
filter, measure_expr | metric | the measure filter and the expr without the filter | a CASE expression in the aggregate |
derived_expr | metric | the formula of the derived measure | the expanded SQL, without a reference to the measures in the formula |
entity | metric | the entity of the measure. Each exported metric has the key | only the SQL. COUNT(1) names no table. A filter on a joined table names 2 tables. Without the key, these measures do not return into a layer with 2 or more entities |
join_type | relationship | one_to_one or one_to_many | a many-to-one join |
join_expr | relationship | the full join condition | only the equality part. Thus, a join that returns more rows |
csl with package and block | dataset | the CoginitiScript block reference | a table |
original_name | metric | the measure name before the exporter changed the name | the long name |
A filtered measure in the 2 forms:
measure "closed_total" {
aggregation_type = "sum"
expr = "amount"
filter = "status = 'closed'"
}
expression: SUM(CASE WHEN orders.status = 'closed' THEN orders.amount END)
custom_extensions:
- vendor_name: COGINITI
data: '{"v":1,"filter":"status = ''closed''","measure_expr":"amount","entity":"orders"}'
The results are the same in each tool. Only Coginiti sets the filter line again.
The entity key tells the importer the entity of the measure. Two types of measure return only with this key. A row count with expr = "1" is exported as COUNT(1), which names no table. A measure with a filter or an expr that uses a joined entity, for example filter = "customers.region = 'EU'", names 2 tables. If a tool removes the entry, the import of these measures into a layer with 2 or more entities reports metric_not_importable.
A derived measure. The exporter replaces each measure name with the SQL of that measure. The exporter also expands a derived measure in a different derived measure.
measure "revenue" { aggregation_type = "sum"; expr = "amount" }
measure "order_count" { aggregation_type = "count"; expr = "id" }
measure "aov" { expr = "revenue / NULLIF(order_count, 0)" }
- name: aov
expression:
dialects:
- dialect: ANSI_SQL
expression: SUM(orders.amount) / NULLIF(COUNT(orders.id), 0)
custom_extensions:
- vendor_name: COGINITI
data: '{"v":1,"derived_expr":"revenue / NULLIF(order_count, 0)","entity":"orders"}'
A relationship with a range condition. The equality part goes into the column lists. The full condition goes into the COGINITI entry.
relationship "product" {
type = "many_to_one"
expr = "detail.product_key = product.product_key AND detail.quantity > 2"
}
- name: product
from: detail
to: product
from_columns: [product_key]
to_columns: [product_key]
custom_extensions:
- vendor_name: COGINITI
data: '{"v":1,"join_expr":"detail.product_key = product.product_key AND detail.quantity > 2"}'
Coginiti imports the full condition. Each other tool joins only on product_key and returns more rows.
Export messages
Warnings
| Code | Data that is not exported | Action |
|---|---|---|
measure_not_exportable | A custom aggregate. An expression that does not parse. A derived measure that refers to a custom measure, or to a measure that was not exported | None for a custom aggregate. Ossie does not have a form for it. Correct the measure that the derived measure refers to |
measure_approximated | No data. A derived measure uses 2 entities. The SQL is correct only if the other tool aggregates each part at the grain of its entity | Tell the users of the other tool. Coginiti imports the formula without changes |
relationship_excluded | A join without a from.x = to.y equality, with a top-level OR, or with an entity that was not exported | Write the join again as equalities connected with AND, or accept the removal |
relationship_approximated | No data. Only the equality part is in the column lists | Tell the users of the other tool. Their join returns more rows |
renamed_on_collision | No data. A measure got a new name, for example customers_row_count | Give each measure a unique name in the semantic layer |
entity_excluded | An entity without a source, or with a source that is empty, and the measures and joins of the entity | Give the entity a table or a query |
csl_entity_excluded | An entity with a CoginitiScript block that did not resolve, and the measures and joins of the entity | Run the block. Then export the layer again |
source_not_importable | No data. The source does not return as the same table. The source is 1 string with dots. Thus, a table name with a dot returns as a different table. An empty source stops a later import | Change the name of the table, if the document will return to Coginiti |
name_not_importable | No data. A name that a later import refuses. The document is correct Ossie | Change the name in the semantic layer, if the document will return to Coginiti |
relationship_not_importable | No data. A join column that is not a field. A later import removes the relationship | Define the column as a field. Set the field to hidden if necessary |
primary_key_column_dropped | No data. A key column that is not a field. A later import makes the key shorter | Define the column as a field. Set the field to hidden if necessary |
dataset_name_shared | No data. Two entities of the layer have names that differ only in letter case, for example Orders and orders. The document is correct Ossie. An import into 1 Coginiti layer refuses it with duplicate_name | Change 1 name, if the document will return to Coginiti |
diagnostics_elided | No data. The response has more than 200 messages. The list shows the first 199 | Correct the reported items. Then export the layer again to see the other messages |
Errors
| Code | Cause | Action |
|---|---|---|
layer_not_loaded | The .smdl files of the semantic layer do not load | Open the semantic layer in Coginiti and correct the reported file |
nothing_exportable | A semantic layer without exportable entities. The message is the layer has no exportable datasets (Ossie requires at least one) | Give 1 or more entities a table, a query, or a CoginitiScript block that resolves |
| no code | A project or a folder with 2 or more semantic layers. Coginiti stops the export before the conversion. The message is, for example, the project holds 2 semantic layers (sales, hr); an Ossie document holds one, so export a layer folder or an .smdl asset | Right-click the folder of 1 layer or an .smdl file of the layer. Export each layer 1 at a time |
Data that the exporter does not write
The exporter removes these items without a message:
- the platform, the label and the version of the semantic layer
- the
descriptionof the model - the
descriptionof a relationship unique_keysis_time- comments
The document does not have is_time. Thus, a different tool possibly reads each Date field as a time field. As an alternative, the tool possibly reads no Date field as a time field.
A row count with expr = "1" becomes COUNT(1). The entity key in the COGINITI entry tells the importer the entity. Without the key, the importer imports COUNT(1) only into a semantic layer with 1 entity.
Round trip data that is not kept
Export from Coginiti, then import into Coginiti
| Item that does not return | Cause |
|---|---|
a custom measure | measure_not_exportable in the export |
a join without an equality, or with OR | relationship_excluded in the export |
| an entity without a source | entity_excluded in the export |
type = "number" | the type returns as float, without a message |
| the platform, the label and the version of the semantic layer | the exporter does not write these items |
table_name = "base.fct_sales" without a schema_name | the entity returns as schema_name = "base" and table_name = "fct_sales", without a message |
Import from Ossie, then export to Ossie
| Item that the converter does not keep |
|---|
each custom_extensions entry of a different vendor |
| each dialect entry that the importer did not select |
unique_keys, is_time, the description and ai_context of the model, and the synonyms of relationships |
the database part of each source |
| each window clause and each nested aggregate |
| each join on a column that was not defined as a field |
the version 0.1.1. The version returns as 0.2.0.dev0 |
the model structure of a 0.1.1 document with 2 or more models. The models go into 1 layer. The layer returns as 1 model |
The export does not report these items. The import messages were the only record.