跳至主要内容
文档
文档
Adaptive Planning
上次更新时间 ：2023-06-23
ai.dataSource

ai.dataSource

​数据源包含设置和表格。

函数

方法
参数
退货
描述
getTables()
Array<ai.dataSource.table>
返回导入表格的列表。
getTable( tableId )
tableId : 表的 String 远程编号
ai.dataSource.table
返回具有所请求表格编号的表格。如果未找到表格，则返回 null。
getSettings()
Array<ai.dataSource.setting>
返回所有弹性设置。
getSetting( displayName )
displayName : String 设置的名称
ai.dataSource.setting
按弹性设置的显示名称返回弹性设置。
示例

function previewData(context) {
 var dataSource = context.getDataSource();
 var allTablesInThisDataSource = dataSource.getTables();
 //Navigate to Designer Settings tab, drag and drop a Static Integer parameter from the Settings Component
 //Setting Name: Custom Integer and Value: 100
 var getSetting=dataSource.getSetting("Custom Integer" );
 ai.log.logInfo(getSetting.getValue()); //100
}

ai.dataSource.table

方法
参数
退货
描述
getColumnByDisplayName( name )
name : String 列的显示名称
ai.dataSource.column
按显示名称查找列。如果未找到列，则返回 null。
getColumnById( id )
id：列的 String 远程编号
ai.dataSource.column
按列的远程编号查找列。如果未找到列，则返回 null。
getColumns()
Array<ai.dataSource.column>
返回已启用数据导入的所有子列。
getDisplayName()
String
返回表格的显示名称。
getId()
String
返回此表格的远程编号，如果未指定远程编号，则返回显示名称。
getLastImported()
String
返回一个字符串，用于标识上次导入表格的时间。
getRelationships()
Array<ai.dataSource.relationship>
返回此表作为关系的主表的所有关系。
getRequiredParameters()
Array<ai.dataSource.table.requiredParameter>
返回所有表格必需的参数及其参数值。
getRequiredParameter( id )
id：在导入结构期间定义的必需参数的字符串远程编号
ai.dataSource.table.requiredParameter
按表格的远程编号返回表格必需参数。
示例

//Consider a sample data source
dataSample = {
     rows: [
        {"Value": 10, "Measure": "", "Test": "No Space", "Effective Date": "2018-11-01"},
        {"Value": 20, "Measure": " ", "Test": "One Space", "Effective Date": "2018-11-01"},
        {"Value": 30, "Measure": "  ", "Test": "Two Spaces", "Effective Date": "2018-11-01"},
        {"Value": 40, "Measure": "   ", "Test": "Three Spaces", "Effective Date": "2018-11-01"},
        {"Value": 50, "Measure": "1 ", "Test": "Aus" + '\\-' + "tin" + '\\-', "Effective Date": "2018-11-01"},
        {"Value": 10, "Measure": "2  ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 20, "Measure": "3   ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 30, "Measure": "4    ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 40, "Measure": "5     ", "Test": "Austin", "Effective Date": "2018-12-01"}
    ]
};
ExternalMetadataDefinition = {
    Tables : [
        {
            name : "dataSample",
            displayName : "Sample",
            id:"dataSample",
            parameterId:"sampleParameter",
            columns : [
                {name : "Value", displayName : "Value", type: "float", includeByDefault : true, },
                {name : "Measure", displayName : "Measure", type: "text", includeByDefault : true},
                {name : "Test", displayName : "Test", type: "text", includeByDefault : true},
                {name : "Effective Date", displayName : "Date", type : "datetime", includeByDefault : true}
            ]
        }
    ]
};

//Create a table structure
function importStructure(context) {
    var addColumn = function(table, column, order) {
        var recordColumn = table.addColumn(column.name);
        recordColumn.setDisplayName(column.displayName);
        switch (column.type) {
            case "text":
                recordColumn.setTextColumnType(column.length);
                break;
            case "int":
                recordColumn.setIntegerColumnType();
                break;
            case "float":
                recordColumn.setFloatColumnType();
                break;
            case "boolean":
                recordColumn.setBooleanColumnType();
                break;
            case "datetime":
                recordColumn.setDateTimeColumnType();
                break;
            default:
                recordColumn.setTextColumnType(200);
                break;
        }
        recordColumn.setDisplayOrder(order);
        recordColumn.setIncludeByDefault(column.includeByDefault || false);
        recordColumn.setIncludeInKey(column.includeInKey || false);
        recordColumn.setMandatoryForImports(column.mandatoryForImport || false);
        recordColumn.setRemoteColumnType(column.remoteColumnType || "String");
    };
    var builder = context.getStructureBuilder();
    var dataSource=context.getDataSource();
    for (var i = 0; i < ExternalMetadataDefinition.Tables.length; i++) {
        var externalTable = ExternalMetadataDefinition.Tables[i];
        var table = builder.addTable(externalTable.name);
        table.setDisplayName(externalTable.displayName);
        for (var j = 0; j < externalTable.columns.length; j++) {
            addColumn(table, externalTable.columns[j], j + 1);
        }
    }
}

//Examples for ai.datasource.table
function importData(context){
    var dataSource = context.getDataSource();
    var alltablesinds=dataSource.getTables();
    var rowset=context.getRowset();
    //Example: getTableId;
    var tableId = rowset.getTableId(); ////dataSample
    var table= dataSource.getTable( tableId );
    //Example: getDisplayName 
    var dname=table.getDisplayName(); //Sample
    ai.log.logInfo("Table Display Name",dname);
    //Example: getLastImported
    var lastImported=table.getLastImported();
    ai.log.logInfo("Last Imported:",lastImported); //Last Imported 10/23/2020 01:12:59
    //Example: getId
    ai.log.logInfo("Table id",table.getId()) //dataSample
    
}

ai.dataSource.table.column

方法
参数
退货
描述
getColumnType()
String
返回列类型。值为“DateTimeColumn”、“IntegerColumn”、“FloatColumn”、“BooleanColumn”或“TextColumn”。
getDisplayName()
String
返回列的显示名称。
getDisplayOrder()
String
返回列的显示顺序。
getId()
String
如果未指定远程编号，则返回列的显示名称。
getIncludeByDefault()
Boolean
如果导入的数据中包括该列，则返回 true。
getIncludeInKey()
Boolean
如果列是表键的一部分，则返回 true。键列不允许空值。
getLength()
整数
注：仅适用于 TextColumns。返回 TextColumn 中所含值的最大长度。
getMandatoryForImports()
True
如果要求该列是数据导入的一部分，则返回 true。
getNonFilterable()
True
如果列不能用作 SQL 筛选器（WHERE 语句）的一部分，则返回 true。
getRemoteColumnType()
String
返回在导入结构脚本中定义的列的远程列类型。
示例


//Consider a sample JSON data set
dataSample = {
     rows: [
        {"Value": 10, "Measure": "", "Test": "No Space", "Effective Date": "2018-11-01"},
        {"Value": 20, "Measure": " ", "Test": "One Space", "Effective Date": "2018-11-01"},
        {"Value": 30, "Measure": "  ", "Test": "Two Spaces", "Effective Date": "2018-11-01"},
        {"Value": 40, "Measure": "   ", "Test": "Three Spaces", "Effective Date": "2018-11-01"},
        {"Value": 50, "Measure": "1 ", "Test": "Aus" + '\\-' + "tin" + '\\-', "Effective Date": "2018-11-01"},
        {"Value": 10, "Measure": "2  ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 20, "Measure": "3   ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 30, "Measure": "4    ", "Test": "Austin", "Effective Date": "2018-12-01"},
        {"Value": 40, "Measure": "5     ", "Test": "Austin", "Effective Date": "2018-12-01"}
    ]
};
ExternalMetadataDefinition = {
    Tables : [
        {
            name : "dataSample",
            displayName : "Sample",
            id:"dataSample",
            parameterId:"2018-01-01",
            columns : [
                {name : "Value", displayName : "Value", type: "float", includeByDefault : true, },
                {name : "Measure", displayName : "Measure", type: "text", includeByDefault : true},
                {name : "Test", displayName : "Test", type: "text", includeByDefault : true},
                {name : "Effective Date", displayName : "Date", type : "datetime", includeByDefault : true}
            ]
        }
    ]
};

function testConnection(context) {
    return true;
}

//Create a table structure
function importStructure(context) {
    var addColumn = function(table, column, order) {
        var recordColumn = table.addColumn(column.name);
        recordColumn.setDisplayName(column.displayName);
        switch (column.type) {
            case "text":
                recordColumn.setTextColumnType(column.length);
                break;
            case "int":
                recordColumn.setIntegerColumnType();
                break;
            case "float":
                recordColumn.setFloatColumnType();
                break;
            case "boolean":
                recordColumn.setBooleanColumnType();
                break;
            case "datetime":
                recordColumn.setDateTimeColumnType();
                break;
            default:
                recordColumn.setTextColumnType(200);
                break;
        }
        recordColumn.setDisplayOrder(order);
        recordColumn.setIncludeByDefault(column.includeByDefault || false);
        recordColumn.setIncludeInKey(column.includeInKey || false);
        recordColumn.setMandatoryForImports(column.mandatoryForImport || false);
        recordColumn.setRemoteColumnType(column.remoteColumnType || "String");
    };
    var builder = context.getStructureBuilder();
    var dataSource=context.getDataSource();
    for (var i = 0; i < ExternalMetadataDefinition.Tables.length; i++) {
        var externalTable = ExternalMetadataDefinition.Tables[i];
        var table = builder.addTable(externalTable.name);
        table.setDisplayName(externalTable.displayName);
        for (var j = 0; j < externalTable.columns.length; j++) {
            addColumn(table, externalTable.columns[j], j + 1);
        }
    }
}

//Examples for ai.datasource.table.column
function importData(context) {
    var columnArray = rowset.getColumns();
    var colIds=[];
    var colDisplayNames=[];
    var colTypes=[];
    var colDisplayOrder=[];
    var colIncludeByDefault=[];
    var colLength=[];
    for (var k = 0; k < columnArray.length; k++) {
        //Example:getColumnType
        colTypes.push(columnArray[k].getDisplayName().toString()+":"+columnArray[k].getColumnType().toString());
        //Example:getDisplayName
        colDisplayNames.push(columnArray[k].getDisplayName().toString());
        //Example:getDisplayOrder
        colDisplayOrder.push(columnArray[k].getDisplayName().toString()+":"+columnArray[k].getDisplayOrder().toString());
        //Example:getId
        colIds.push(columnArray[k].getId().toString());
        //Example:getIncludeByDefault
        colIncludeByDefault.push(columnArray[k].getDisplayName().toString()+":"+columnArray[k].getIncludeByDefault().toString());
        //Example:getLength
        if(columnArray[k].getColumnType()==="TextColumn")
        {
            colLength.push(columnArray[k].getDisplayName().toString()+":"+columnArray[k].getLength());
        }
    }

    ai.log.logInfo("Column Ids are "+colIds);
    //Column Ids are Effective Date,Value,Measure,Test
    ai.log.logInfo("Column Display names are "+colDisplayNames);
    //Column Display names are Date,Value,Measure,Test
    ai.log.logInfo("Column Types are "+colTypes);
    //Column Types are Date: DateTimeColumn, Value:FloatColumn, Measure:TextColumn,Test:TextColumn
    ai.log.logInfo("Column Display Order: "+colDisplayOrder); 
    //Column Display Order: Date:4,Value:1,Measure:2,Test:3
    ai.log.logInfo("Column Included by Default:"+colIncludeByDefault);
    //Column Included by Default:Date:true,Value:true,Measure:true,Test:true
    ai.log.logInfo("Length - "+colLength);
    //Length - Measure:200,Test:200
}

ai.dataSource.table.relationship

函数
方法
参数
退货
描述
getJoinExpression()
String
返回关系的表达式存储 SQL，例如“P.Column123 = R.Column321”。
getJoinType()
整数
返回关系的联接类型。值为 0（内）、1（左外）或 2（右外）。
getDisplayName()
String
返回关系的显示名称。
getRelatedTableId()
String
返回关系的相关表格的远程编号，或者未指定远程编号时显示的名称。
getRelatedTableName()
String
返回关系的相关表格的显示名称。

ai.dataSource.setting

弹性设置是自定义云数据源的子级条目。设置可以是静态的（通过配置值），也可以是参数化的（在脚本运行时，系统会提示用户为设置输入值）。设置用途的示例包括脚本可以访问的 URL、用户名、密码、日期范围或维度。
函数
方法
参数
退货
描述
getDisplayName()
String
返回设置的显示名称。
getValue()
混合
返回设置的参数值。值可以是基本类型，也可以是复杂对象，请参见下文的值类型。
isBoolean()
Boolean
如果设置类型为布尔值，则返回 true。
isDimension()
Boolean
如果设置类型为“维度”，则返回 true。
isInteger()
Boolean
如果设置类型为“整数”，则返回 true。
isPassword()
Boolean
如果设置类型为“密码”，则返回 true。
isPeriodRange()
Boolean
如果设置类型为 PeriodRange，则返回 true。
isText()
Boolean
如果设置类型为“文本”，则返回 true。
示例

//Navigate to Designer Settings tab and drag an Integer Static parameter from the Settings Component pane
//Name the setting Custom Integer and set the value to 100
 var dataSource= context.getDataSource();
 var setting=dataSource.getSetting("Custom Integer" );
 
 //Example: getDisplayName
 var name = setting.getDisplayName(); //Custom Integer

 //Example: getValue
 var value = setting.getValue(); //100

// DataType checkup for the setting.
if(setting.isInteger()){
    ai.log.logInfo("Setting is of the type Integer"); //Setting is of the type Integer
}
//Check for other data types using setting.isPeriodRange(), setting.isInteger(), setting.isBoolean(), setting.isText(), setting.isPassword(), setting.isDimension();
值类型
每个设置的 getValue() 函数都可以返回原始类型或复杂对象。
布尔值设置：
getValue() 以布尔值形式返回值。
文本设置：
getValue() 以字符串形式返回值。
整数设置：
getValue() 以整数形式返回值。
密码设置：
getValue() 以字符串形式返回值。
期间范围设置：
getValue() 以复杂对象形式返回值。此对象的定义如下：
方法
参数
退货
描述
getFromPeriod()
String
返回一个字符串，该字符串定义了已解决的内部表示形式。
Adaptive Planning
 起始期间，可用于传递给 ai.calendar 方法调用。例如“3152|5201611100000”
getToPeriod()
String
返回一个字符串，该字符串定义了已解决的内部表示形式。
Adaptive Planning
“结束期间”，可用于传递给 ai.calendar 方法调用。例如“3152|5201611100000”
getFromPeriodStartDateTime()
String
返回以本地时间表示的“起始期间”开始日期时间的日期时间字符串表示形式。例如"2016-01-01T00:00:00+10:00"
getFromPeriodEndDateTime()
String
返回以本地时间表示的“起始期间”结束日期时间的日期时间字符串表示形式。例如"2016-02-01T00:00:00+10:00"
getToPeriodStartDateTime()
String
返回“结束期间”开始日期时间的日期时间字符串表示形式（以本地时间表示）。例如"2016-06-01T00:00:00+10:00"
getToPeriodEndDateTime()
String
返回以日期时间字符串表示形式表示“结束期间”结束日期时间的日期时间（以本地时间表示）。例如"2016-07-01T00:00:00+10:00"
示例


function importData(context)
{
    var dataSource = context.getDataSource();
    //getFromPeriod
    var getFromPeriod=dataSource.getSetting("Period Range").getValue().getFromPeriod();
    //getToPeriod
    var getToPeriod=dataSource.getSetting("Period Range").getValue().getToPeriod();
    //getFromPeriodStartDateTime
    var getFromPeriodStartDateTime = dataSource.getSetting("Period Range").getValue().getFromPeriodStartDateTime().substring(0, 10);
    ai.log.LogInfo("getFromPeriodStartDateTime"+getFromPeriodStartDateTime); //2017-12-01
    //getFromPeriodEndDateTime
    var getFromPeriodEndDateTime = dataSource.getSetting("Period Range").getValue().getFromPeriodEndDateTime().substring(0, 10);
    ai.log.LogInfo("getFromPeriodEndDateTime"+getFromPeriodEndDateTime); //2017-12-31
    //getToPeriodStartDateTime
    var getToPeriodStartDateTime = dataSource.getSetting("Period Range").getValue().getToPeriodEndDateTime().substring(0, 10);
    ai.log.LogInfo("getToPeriodStartDateTime"+getToPeriodStartDateTime); //2018-01-01
    //getToPeriodEndDateTime
    var getToPeriodEndDateTime = dataSource.getSetting("Period Range").getValue().getToPeriodEndDateTime().substring(0, 10);
    ai.log.LogInfo("getToPeriodEndDateTime"+getToPeriodEndDateTime); //2018-01-30
}

维度设置

getValue() 以复杂对象的形式返回值。此对象的定义如下：
方法
参数
退货
描述
getDimensionName()
String
返回值中定义的维度的名称。
getValueName()
混合
返回值中定义的维度成员的名称。
示例

//Navigate to Designer Settings tab and drag a Static Dimension parameter from the Settings Component pane
//Name the setting "Custom Dimension" and set a value from the Static Dimension Setting dropdown
 var setting=dataSource.getSetting("Custom Dimension" );
 var value = setting.getValue();
 
 //Example: getDisplayName
 var name = value.getDimensionName();
 var settingValue=value.getValueName();

 ai.log.logInfo("Dimension Settings Name: "+name+" and Dimension Settings Value: "+settingValue);
//Dimension Settings Name: Level and Dimension Settings Value: Company B (40% owned)Example for Dimension Settings
//Navigate to Designer Settings tab and drag a Static Dimension parameter from the Settings Component pane
//Name the setting "Custom Dimension" and set a value from the Static Dimension Setting dropdown
var setting=dataSource.getSetting("Custom Dimension" );
var value = setting.getValue();

//Example: getDisplayName
var name = value.getDimensionName();
var settingValue=value.getValueName();

ai.log.logInfo("Dimension Settings Name: "+name+" and Dimension Settings Value: "+settingValue);
//Dimension Settings Name: Level and Dimension Settings Value: Company B (40% owned)

ai.dataSource.table.requiredParameter

在脚本执行期间，有效的“必需参数”会提示用户提供值。然后，您可以在脚本中访问这些值。可以在导入期间创建必需的参数结构。
在执行 ImportData 操作时，脚本中只能访问可通过 setForDataImport(true) 配置的“必选参数”。
函数
方法
参数
退货
描述
getId()
String
返回必需参数的远程编号。
getValue()
混合
返回必需参数的参数的值。值可以是基本类型，也可以是复杂对象，请参见下文的值类型。
isBoolean()
Boolean
如果必需参数的类型为布尔值，则返回 true。
isDimension()
Boolean
如果必需参数的类型为“维度”，则返回 true。
isInteger()
Boolean
如果必需参数的类型为“整数”，则返回 true。
isPassword()
Boolean
如果必需参数的类型为“密码”，则返回 true。
isPeriodRange()
Boolean
如果必需参数的类型为 PeriodRange，则返回 true。
isText()
Boolean
如果必需参数的类型为“文本”，则返回 true。
值类型
每个必需参数的 getValue() 函数都可以返回原始类型或复杂对象。
布尔值必需参数
getValue() 以布尔值形式返回值。
文本为必选参数
getValue() 以字符串形式返回值。
必须为整数的参数
getValue() 以 Integer 形式返回值。
需要密码的参数
getValue() 以字符串形式返回值。
期间范围必需参数
getValue() 以复杂对象的形式返回值。此对象的定义如下：
方法
参数
退货
描述
getFromPeriod()
String
返回一个字符串，用于定义已解析的事件。
Adaptive Planning
 起始期间例如“y2016 M1 月”
getToPeriod()
String
返回一个字符串，用于定义已解析的事件。
Adaptive Planning
 结束期间例如“y2016 M1 月”
getFromPeriodStartDateTime()
String
返回以本地时间表示的“起始期间”开始日期时间的日期时间字符串表示形式。例如"2016-01-01T00:00:00+10:00"
getFromPeriodEndDateTime()
String
返回以本地时间表示的“起始期间”结束日期时间的日期时间字符串表示形式。例如"2016-02-01T00:00:00+10:00"
getToPeriodStartDateTime()
String
返回“结束期间”开始日期时间的日期时间字符串表示形式（以本地时间表示）。例如"2016-06-01T00:00:00+10:00"
getToPeriodEndDateTime()
String
返回以日期时间字符串表示形式表示“结束期间”结束日期时间的日期时间（以本地时间表示）。例如"2016-07-01T00:00:00+10:00"
维度设置
getValue() 以复杂对象的形式返回值。此对象的定义如下：
方法
参数
退货
描述
getDimensionName()
String
返回值中定义的维度的名称。
getValueName()
混合
返回值中定义的维度成员的名称。