This section details a list of known limitations in Smart Integration Connector.
Business Rule Compatibility
The Smart Integration Connector supports business rule APIs (BR APIs) to allow for execution and management of remote business rules inside the context of the Smart Integration Connector Local Gateway Server. Some OneStream Business Rules are not supported. For compatible Business Rules, see Business Rules.
Parquet Format Transfer
Smart Integration Connector transfers data in Apache Parquet format from the Local Gateway Service to your OneStream cloud instance. If you are transferring a data type that is not fully supported by parquet, the data returns as a string. If the data type can not be converted to parquet, you may have to cast the data type in your query.
Example for datetimeoffset:
-
SELECT CAST(your_datetimeoffset_column AS VARCHAR(50)) AS formatted_datetime
FROM your_table;
For additional information, see Troubleshooting.
Returning Multiple DataTables with Remote Business Rules
If you are returning multiple DataTables in a DataSet from a Remote Business Rule, the maximum number of combined rows and size are around 2 million rows and 2GB of data.
Custom Email Connections
Email over Smart Integration Custom ("Notification Connection" in Data Management jobs) Connections is not supported. Remote BRs do support email in Smart Integration Connector.
FTP Transfers
sFTP is supported by the use of SSH.NET. FTP is currently not supported for SSH.NET. Use sFTP for all file transfers.
Internal Certificate Trust
Certificates issued by an internal domain controller cannot be trusted by OneStream.
SQL Table Editor
If you plan on modifying data with SQL Table Editor using Smart Integration Connector, then you will need to write back data with a custom business rule using the Execute Dashboard Extender Business Rule feature under the Save Data Server Task action.
Precision using Decimals
When transmitting data through Smart Integration Connector, numeric values exceeding certain lengths may be rounded. The following workarounds can help maintain data precision.
Receiving Data from Smart Integration Connector
Smart Integration Connector queries can only return numeric values with up to 38 total digits: 20 integer digits to left of the decimal point and 18 fractional digits to the right of the decimal point.
For example, returning a column with a value of 123456789123456789123 (21 digits) is not supported. Even though there is no decimal point, it still exceeds 20 integer digits, which is the maximum amount.
Similarly, returning a column with a value of 0.1234567891234567891 (19 decimal digits) is not supported, as it contains more than 18 digits on the right side of the decimal point.
If your queries can return values that require more than 20 integer digits or 18 fractional digits, consider casting to a VARCHAR as the following:
-
"SELECT CAST(123456789123456789123 AS VARCHAR)" -- 21 integer digits
If there is no risk of overflowing the opposite side of the decimal point, you can also divide by a factor of 10 to shift right or multiply by a factor of 10 to shift left. This approach is more efficient than casting to a VARCHAR
For example:
-
SELECT 123456789123456789123 / 100 -- 21 integer digits will shift by two digits to the right
-
SELECT 0.1234567891234567890 * 100 -- 19 fractional digits will shift by two digits to the left
Sending Data to Smart Integration Connector
For sending either a DataTable or a CompressionResult into a remote rule, Smart Integration Connector can only return numeric values with up to 18 characters of significance. Values with more than 18 significant digits will lose precision.
For example, when sending a DataTable into Smart Integration Connector, a value of 1234567890123456789.123456 (25 significant digits) will become 1234567890123456800 (17 significant digits).
Similarly, sending a CompressionResult with a value of 123456789012345.123456 (21 significant digits) will become 123456789012345.13 (17 significant digits).
NOTE: This precision limit is a ceiling, not a typical round.
If you are confident that the data will not reach 18 significant digits, no action is needed. If you anticipate that the data sent into Smart Integration Connector will reach this limit, consider using this Business Rule Extender:
namespace OneStream.BusinessRule.Extender.SIC_PrecisionDemo_Extender
{
public class MainClass
{
public const string remoteGatewayName = ""; // Enter gateway name
const decimal OriginalValue = 1234567890123456.12M; // 18 total digits
public object Main(SessionInfo si, BRGlobals globals, object api, ExtenderArgs args)
{
// dataTable with a single row containing OriginalValue above
var dataTable = new System.Data.DataTable("TestDataTable");
dataTable.Columns.Add("DecimalColumn", typeof(decimal));
// Add the original value to the datatable
var row = dataTable.NewRow();
row["DecimalColumn"] = OriginalValue;
dataTable.Rows.Add(row);
// base64-encoded string version of dataTable
var base64 = GetBase64EncodedDataTable(dataTable);
// pass both the raw dataTable and encoded version as two separate arguments to the Remote Business Rule
var arguments = new object[]{dataTable, base64};
var resultObject = BRApi.Utilities.ExecRemoteGatewayBusinessRule(si, "SIC_PrecisionDemo", arguments, remoteGatewayName, "RunOperation");
/*
resultObject.ObjectResultValue: "
WITHOUT encoding: values don't match -- Expected 1234567890123456.12 -- Actual 1.23456789012346E+15.
WITH encoding: values should match -- Expected 1234567890123456.12 -- Actual 1234567890123456.12.
"
*/
return null;
}
public string GetBase64EncodedDataTable(DataTable dt)
{
var serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(DataTable));
var memoryStream = new System.IO.MemoryStream();
serializer.WriteObject(memoryStream, dt);
var bytes = memoryStream.ToArray();
return Convert.ToBase64String(bytes);
}
}
}
To test the Extender, use this Remote Business Rule:
namespace OneStream.BusinessRule.SmartIntegrationFunction.SIC_PrecisionDemo
{
public class MainClass
{
const decimal ExpectedValue = 1234567890123456.12M; // 18 total digits
public string RunOperation(DataTable dataTable, string base64)
{
// Retrieve and log raw dataTable
var retrievedValue = dataTable.Rows[0]["DecimalColumn"];
var message = $"WITHOUT encoding: values don't match -- Expected {ExpectedValue} -- Actual {retrievedValue}.";
// Retrieve and log encoded data table
var bytes = Convert.FromBase64String(base64);
var memoryStream = new System.IO.MemoryStream(bytes);
var serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(DataTable));
var dt = (DataTable)serializer.ReadObject(memoryStream);
var correctValue = dt.Rows[0]["DecimalColumn"];
message += $"\nWITH encoding: values should match -- Expected {ExpectedValue} -- Actual {correctValue}.";
return message;
}
}
}
