{ "abs": { "url": "https://docs.dolphindb.com/en/Functions/a/abs.html", "signatures": [ { "full": "abs(X)", "name": "abs", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [abs](https://docs.dolphindb.com/en/Functions/a/abs.html)\n\n\n\n#### Syntax\n\nabs(X)\n\n#### Parameters\n\n**X** is a scalar/pair/vector/matrix/dictionary/table.\n\n#### Details\n\nReturn the element-by-element absolute value(s) of *X*.\n\nThe `abs` function in DolphinDB has the same functionality as the `abs` functions in Python, NumPy, and `scipy.stats`\n\n, with the following difference: Python/NumPy/`scipy.stats` support calculating the absolute value of complex numbers,whereas DolphinDB’s `abs` function does not support complex numbers. To calculate the absolute value of complex numbers in DolphinDB, you can use the `abs` function provided in the DolphinDB *signal* plugin (see example).\n\n#### Examples\n\n```\nabs(-2.0);\n// output: 2\n\nabs(-2 -3 4);\n// output: [2, 3, 4]\n```\n\nCalculate the absolute value of a complex number using the *signal* plugin.\n\n```\n// Check whether the signal plugin exists in the plugin marketplace\nlistRemotePlugins()\n\n// Download the signal plugin from the marketplace\ninstallPlugin(\"signal\")\n\n// Load the signal plugin\nloadPlugin(\"signal\")\n\n// Create a complex number\nz = complex(3, 4) // 3.0+4.0i\n\n// Calculate the absolute value of the complex number\nabs = signal::abs(z)\n\nabs\n// output: 5\n```\n" }, "acf": { "url": "https://docs.dolphindb.com/en/Functions/a/acf.html", "signatures": [ { "full": "acf(X, maxLag)", "name": "acf", "parameters": [ { "full": "X", "name": "X" }, { "full": "maxLag", "name": "maxLag" } ] } ], "markdown": "### [acf](https://docs.dolphindb.com/en/Functions/a/acf.html)\n\n\n\n#### Syntax\n\nacf(X, maxLag)\n\n#### Details\n\nComputes the autocorrelation of *X* from lag=1 to lag=*maxLag*. Note that the means of the two time series used in the calculation is the mean of *X* instead of the means of the two time series.\n\nThis function is largely consistent with `statsmodels.tsa.stattools.acf` in terms of computing autocorrelation coefficients. The specific implementation differences are as follows:\n\n| Dimension | DolphinDB `acf` | Python `statsmodels.tsa.acf` |\n| ---------------------- | ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |\n| lag parameter | maxLag must be specified | Optional; default is `min(10 * np.log10(nobs), nobs - 1)` |\n| Computation method | Demeaning + normalization | Demeaning + normalization (default); normalization can be adjusted via the *adjusted* parameter |\n| FFT acceleration | Supported (not configurable) | Supported (controlled by the *fft* parameter) |\n| Confidence interval | Not supported | Supports confidence intervals via *alpha* and method selection via *bartlett\\_confint* |\n| Significance test | Not supported | Supported (via the *qstat* parameter) |\n| Missing value handling | Not supported (throws error) | Supported (via the *missing* parameter) |\n| Return value | Vector of autocorrelation coefficients from lag 1 to maxLag | Array of autocorrelation coefficients + optional confidence intervals |\n\n#### Parameters\n\n**X** is a vector.\n\n**maxLag** is a positive integer that specifies the maximum lag for computing the autocorrelation coefficient.\n\n#### Examples\n\n```\nn=10000\nx=array(double, n, n, NULL)\nx[0]=1\nr=rand(0.05, n)-0.025\nfor(i in 0:(n-1)){\n x[i+1]=-0.8*x[i]+r[i]\n}\n\nacf = acf(x, 20)\nplot(acf,chartType=BAR)\n```\n" }, "acos": { "url": "https://docs.dolphindb.com/en/Functions/a/acos.html", "signatures": [ { "full": "acos(X)", "name": "acos", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [acos](https://docs.dolphindb.com/en/Functions/a/acos.html)\n\n\n\n#### Syntax\n\nacos(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse cosine function.\n\nDolphinDB `acos` and TA-Lib `ACOS` are mathematically identical in semantic meaning. The difference is that TA-Lib’s `ACOS` is a Math Transform function whose inputs and outputs are primarily one-dimensional arrays, whereas DolphinDB’s `acos` can operate on scalars, vectors, matrices, or tables, and preserves the structure of the input data.\n\n#### Examples\n\n```\nacos(1.000000 0.540302 -0.416147);\n// output: [0,1,2]\n```\n\nRelated functions: [asin](https://docs.dolphindb.com/en/Functions/a/asin.html), [atan](https://docs.dolphindb.com/en/Functions/a/atan.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html), [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html), [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "acosh": { "url": "https://docs.dolphindb.com/en/Functions/a/acosh.html", "signatures": [ { "full": "acosh(X)", "name": "acosh", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html)\n\n\n\n#### Syntax\n\nacosh(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse hyperbolic cosine function.\n\n#### Examples\n\n```\nacosh(1 2 3);\n// output: [0,1.316958,1.762747]\n```\n\nRelated functions: [asin](https://docs.dolphindb.com/en/Functions/a/asin.html), [acos](https://docs.dolphindb.com/en/Functions/a/acos.html), [atan](https://docs.dolphindb.com/en/Functions/a/atan.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html), [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "adaBoostClassifier": { "url": "https://docs.dolphindb.com/en/Functions/a/adaBoostClassifier.html", "signatures": [ { "full": "adaBoostClassifier(ds, yColName, xColNames, numClasses, [maxFeatures=0], [numTrees=10], [numBins=32], [maxDepth=10], [minImpurityDecrease=0.0], [learningRate=0.1], [algorithm='SAMME.R'], [randomSeed])", "name": "adaBoostClassifier", "parameters": [ { "full": "ds", "name": "ds" }, { "full": "yColName", "name": "yColName" }, { "full": "xColNames", "name": "xColNames" }, { "full": "numClasses", "name": "numClasses" }, { "full": "[maxFeatures=0]", "name": "maxFeatures", "optional": true, "default": "0" }, { "full": "[numTrees=10]", "name": "numTrees", "optional": true, "default": "10" }, { "full": "[numBins=32]", "name": "numBins", "optional": true, "default": "32" }, { "full": "[maxDepth=10]", "name": "maxDepth", "optional": true, "default": "10" }, { "full": "[minImpurityDecrease=0.0]", "name": "minImpurityDecrease", "optional": true, "default": "0.0" }, { "full": "[learningRate=0.1]", "name": "learningRate", "optional": true, "default": "0.1" }, { "full": "[algorithm='SAMME.R']", "name": "algorithm", "optional": true, "default": "'SAMME.R'" }, { "full": "[randomSeed]", "name": "randomSeed", "optional": true } ] } ], "markdown": "### [adaBoostClassifier](https://docs.dolphindb.com/en/Functions/a/adaBoostClassifier.html)\n\n\n\n#### Syntax\n\nadaBoostClassifier(ds, yColName, xColNames, numClasses, \\[maxFeatures=0], \\[numTrees=10], \\[numBins=32], \\[maxDepth=10], \\[minImpurityDecrease=0.0], \\[learningRate=0.1], \\[algorithm='SAMME.R'], \\[randomSeed])\n\n#### Parameters\n\n**ds** is the data sources to be trained. It can be generated with function [sqlDS](https://docs.dolphindb.com/en/Functions/s/sqlDS.html).\n\n**yColName** is a string indicating the name of the category column in the data sources.\n\n**xColNames** is a string scalar/vector indicating the names of the feature columns in the data sources.\n\n**numClasses** is a positive integer indicating the number of categories in the category column. The value of the category column must be integers in \\[0, *numClasses*).\n\n**maxFeatures** (optional) is an integer or a floating number indicating the number of features to consider when looking for the best split. The default value is 0.\n\n* If *maxFeatures* is a positive integer, then consider *maxFeatures* features at each split.\n* If *maxFeatures* is 0, then `sqrt(the number of feature columns)` features are considered at each split.\n* If *maxFeatures* is a floating number between 0 and 1, then `int(maxFeatures * the number of feature columns)` features are considered at each split.\n\n**numTrees** (optional) is a positive integer indicating the number of trees. The default value is 10.\n\n**numBins** (optional) is a positive integer indicating the number of bins used when discretizing continuous features. The default value is 32. Increasing *numBins* allows the algorithm to consider more split candidates and make fine-grained split decisions. However, it also increases computation and communication time.\n\n**maxDepth** (optional) is a positive integer indicating the maximum depth of a tree. The default value is 10.\n\n**minImpurityDecrease** (optional) a node will be split if this split induces a decrease of the Gini impurity greater than or equal to this value. The default value is 0.\n\n**learningRate** (optional) is a positive floating number indicating the contribution of a regressor to the next regressor.\n\n**algorithm** (optional) is a string indicating the algorithm used. It can take the value of either \"SAMME.R\" or \"SAMME\". The default value is \"SAMME.R\".\n\n**randomSeed** (optional) is the seed used by the random number generator.\n\n#### Details\n\nFit an AdaBoost classification model. The result is a dictionary with the following keys: numClasses, minImpurityDecrease, maxDepth, numBins, numTress, maxFeatures, model, modelName, xColNames, learningRate, algorithm, and predict. model is a tuple with the result of the trained trees; modelName is \"AdaBoost Classifier\".\n\nThe fitted model can be used as an input for function [predict](https://docs.dolphindb.com/en/Functions/p/predict.html).\n\n#### Examples\n\nFit an AdaBoost classification model with simulated data:\n\n```\nt = table(100:0, `cls`x0`x1, [INT,DOUBLE,DOUBLE])\nn=5\ncls = take(0, n)\nx0 = norm(0, 10, n)\nx1 = norm(0, 10, n)\ninsert into t values (cls, x0, x1)\ncls = take(1, n)\nx0 = norm(1, 10, n)\nx1 = norm(1, 10, n)\ninsert into t values (cls, x0, x1)\nmodel = adaBoostClassifier(sqlDS(), `y, `x1`x2);\n```\n\nUse the fitted model in forecasting:\n\n```\nt1 = table(0 0.4 0.7 1 as x1, 0.9 0.2 0.1 0 as x2)\npredict(model, t1);\n```\n\nSave the trained model to disk:\n\n```\nsaveModel(model, \"C:/DolphinDB/data/regressionModel.bin\")\n```\n\nLoad a saved model:\n\n```\nloadModel(\"C:/DolphinDB/data/regressionModel.bin\");\n```\n\nRelated functions: [adaBoostClassifier](https://docs.dolphindb.com/en/Functions/a/adaBoostClassifier.html), [randomForestClassifier](https://docs.dolphindb.com/en/Functions/r/randomForestClassifier.html), [randomForestRegressor](https://docs.dolphindb.com/en/Functions/r/randomForestRegressor.html)\n" }, "add": { "url": "https://docs.dolphindb.com/en/Functions/a/add.html", "signatures": [ { "full": "add(X, Y)", "name": "add", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [add](https://docs.dolphindb.com/en/Functions/a/add.html)\n\n\n\n#### Syntax\n\nadd(X, Y)\n\n#### Parameters\n\n**X** and **Y** is a scalar/pair/vector/matrix. If *X* or *Y* is a pair/vector/matrix, the other is a scalar or a pair/vector/matrix of the same size.\n\nComparison of the functionality and implementation of DolphinDB `add` versus `numpy.add` and pandas `Series.add` / `DataFrame.add`:\n\n| Comparison Dimension | DolphinDB `add` | `numpy.add` | pandas `add` |\n| --------------------------- | ------------------------------------------------------------------------------------------------ | --------------------------------------------------------------- | -------------------------------------------------------------------- |\n| Core functionality | Supports element-wise addition for scalars, vectors, matrices, etc. | Supports scalars and ndarrays, follows NumPy broadcasting rules | Index-aligned addition, supports scalar broadcasting |\n| Index alignment | Index sequences and index matrices can be aligned by index | Not supported | Can specify alignment by index or columns |\n| Null/missing value handling | NULL propagation (NULL + any value = NULL); can specify fill value using `withNullFill` function | NaN propagation (NaN + any number = NaN) | Automatically handled; fill value can be specified via *fill\\_value* |\n\n#### Details\n\nReturn the element-by-element sum of X and Y.\n\n#### Examples\n\n```\nadd(3,2)\n// output: 5\n\n1:2+6\n// output: 7:8\n\n1:2+3:4\n// output: 4:6\n\n3+1..3\n// output: [4,5,6]\n\nadd(1..3, 4..6)\n// output: [5,7,9]\n\n(1..3).add(4..6)\n// output: [5,7,9]\n\nx=reshape(1..6, 3:2)\nx\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx+1.5\n```\n\n| 0 | 1 |\n| --- | --- |\n| 2.5 | 5.5 |\n| 3.5 | 6.5 |\n| 4.5 | 7.5 |\n\n```\ny=reshape(5..10, 3:2)\ny\n```\n\n| 0 | 1 |\n| - | -- |\n| 5 | 8 |\n| 6 | 9 |\n| 7 | 10 |\n\n```\nx+y\n```\n\n| 0 | 1 |\n| -- | -- |\n| 6 | 12 |\n| 8 | 14 |\n| 10 | 16 |\n\nRefer to [\"+\" operator](https://docs.dolphindb.com/en/Programming/Operators/OperatorReferences/add.html)\n\nRelated function: [sub](https://docs.dolphindb.com/en/Functions/s/sub.html)\n" }, "addAccessControl": { "url": "https://docs.dolphindb.com/en/Functions/a/addAccessControl.html", "signatures": [ { "full": "addAccessControl(table)", "name": "addAccessControl", "parameters": [ { "full": "table", "name": "table" } ] } ], "markdown": "### [addAccessControl](https://docs.dolphindb.com/en/Functions/a/addAccessControl.html)\n\n\n\n#### Syntax\n\naddAccessControl(table)\n\n#### Details\n\nAdds access control to the shared table or streaming engine created by the current user. Other users can access the target shared table or streaming engine only after the administrator grants them permissions.\n\n**Note:**\n\n1. The function can only be executed by administrators or the shared table/streaming engine creator.\n\n2. If the administrator has added access control to the shared table or streaming engine for other users by using [grant](https://docs.dolphindb.com/en/Functions/g/grant.html)/[deny](https://docs.dolphindb.com/en/Functions/d/deny.html)/[revoke](https://docs.dolphindb.com/en/Functions/r/revoke.html), you do not need to call `addAccessControl`. Users that are not granted permissions by the administrator cannot access the shared table or streaming.\n\n#### Parameters\n\n**table** is a shared table or a streaming engine.\n\n#### Examples\n\nCreate users for access management.\n\n```\nlogin(`admin, `123456)\ncreateUser(`u1, \"111111\");\ncreateUser(`u2, \"222222\");\ncreateUser(`u3, \"333333\");\n```\n\nExample 1: Restrict other users from accessing a streaming engine.\n\n1. Create the agg1 streaming engine as user u1.\n\n ```\n login(`u1, \"111111\")\n share streamTable(1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT]) as trades\n output1 = table(10000:0, `time`sym`sumVolume, [TIMESTAMP, SYMBOL, INT])\n agg1 = createTimeSeriesEngine(name=\"agg1\", windowSize=60000, step=60000, metrics=<[sum(volume)]>, dummyTable=trades, outputTable=output1, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50, useWindowStartTime=false)\n subscribeTable(tableName=\"trades\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true);\n ```\n\n2. Add access control for agg1.\n\n ```\n addAccessControl(agg1)\n ```\n\n3. An error is reported when user u2 inserts data into agg1 or drops agg1.\n\n ```\n // Log on to the server as user u2\n login(`u2, \"222222\")\n\n // Insert data\n insert into trades values(2018.10.08T01:01:01.785,`A,10) // No error\n insert into agg1 values(2018.10.08T01:01:01.785,`A,10) // ERROR: No access to table [agg1]\n\n // Drop streaming engine\n dropStreamEngine(\"agg1\") // No access to drop stream engine agg1\n ```\n\n4. Grant user u2 write permission on agg1.\n\n ```\n login(`admin, `123456)\n grant(\"u2\", TABLE_WRITE, \"agg1\")\n ```\n\n If the server is deployed in cluster mode, the target object must be written as \"nodeAlias:tableName\". Assume that agg1 resides in the dnode1 node.\n\n ```\n grant(\"u2\", TABLE_WRITE, \"dnode1:agg1\")\n ```\n\n5. Then, user u2 can insert data into agg1.\n\n ```\n insert into agg1 values(2018.10.08T01:01:01.785,`A,10)\n ```\n\nExample 2: Restrict other users from accessing a shared table.\n\n```\nlogin(`u1, \"111111\")\nt = table(take(`a`b`c`, 10) as sym, 1..10 as val)\nshare t as st;\naddAccessControl(`st)\n\nlogin(`u3, \"333333\")\nselect * from st // ERROR: No access to shared table [st]\ninsert into st values(`a, 4) // ERROR: No access to shared table [st]\n```\n\n**Related functions**: [grant](https://docs.dolphindb.com/en/Functions/g/grant.html), [deny](https://docs.dolphindb.com/en/Functions/d/deny.html), [revoke](https://docs.dolphindb.com/en/Functions/r/revoke.html)\n" }, "addCacheRulesForComputeGroup": { "url": "https://docs.dolphindb.com/en/Functions/a/addcacherulesforcomputegroup.html", "signatures": [ { "full": "addCacheRulesForComputeGroup(name, tableNames)", "name": "addCacheRulesForComputeGroup", "parameters": [ { "full": "name", "name": "name" }, { "full": "tableNames", "name": "tableNames" } ] } ], "markdown": "### [addCacheRulesForComputeGroup](https://docs.dolphindb.com/en/Functions/a/addcacherulesforcomputegroup.html)\n\nFirst introduced in version: 2.00.183.00.5\n\n\n\n#### Syntax\n\naddCacheRulesForComputeGroup(name, tableNames)\n\n#### Details\n\nAdds cache rules to a compute group, specifying the tables to be cached in the compute group’s cache path.\n\n#### Parameters\n\n**name**: A STRING scalar specifying the name of the compute group to which cache rules are added.\n\n**tableNames**: A STRING scalar or vector specifying the tables to be cached in the compute group’s cache path. The tables are specified in the format of databaseName/tableName, for example \"dfs\\://compute\\_test/tb1\". Wildcards are not supported.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\naddCacheRulesForComputeGroup(\"cgroup1\", \"dfs://compute_test/tb1\")\n\naddCacheRulesForComputeGroup(\"cgroup1\", [\"dfs://compute_test/tb1\", \"dfs://compute_test/tb2\"])\n```\n\n**Related Functions:** [removeCacheRulesForComputeGroup](https://docs.dolphindb.com/en/Functions/r/removecacherulesforcomputegroup.html), [getCacheRulesForComputeGroup](https://docs.dolphindb.com/en/Functions/g/getcacherulesforcomputegroup.html)\n" }, "addColumn": { "url": "https://docs.dolphindb.com/en/Functions/a/addColumn.html", "signatures": [ { "full": "addColumn(table, colNames, colTypes)", "name": "addColumn", "parameters": [ { "full": "table", "name": "table" }, { "full": "colNames", "name": "colNames" }, { "full": "colTypes", "name": "colTypes" } ] } ], "markdown": "### [addColumn](https://docs.dolphindb.com/en/Functions/a/addColumn.html)\n\n\n\n#### Syntax\n\naddColumn(table, colNames, colTypes)\n\n#### Parameters\n\n**table** can be an in-memory table, a stream table, a DFS table (excluding tables using the PKEY engine), or a dimension table.\n\n**colNames** is a STRING scalar/vector indicating the name(s) of the column(s) to be added.\n\n**colTypes** is a scalar/vector indicating the data type(s) of the column(s) to be added.\n\n#### Details\n\nAdd a column or columns to a table. It is the only way to add a column to a stream table, a DFS table (excluding tables using the PKEY engine), or a dimension table. SQL `update` statement is not supported for these cases.\n\nNote that the table should be updated by function `loadTable` after adding a new column into a DFS table not using the PKEY engine or a dimension table with `addColumn`.\n\nTables using the PKEY engine do not support adding columns.\n\nHigh-availability stream tables do not support adding columns.\n\n#### Examples\n\nExample 1. Add columns to a DFS table.\n\n```\nID=1..6\nx=1..6\\5\nt1=table(ID, x)\ndb=database(\"dfs://rangedb\",RANGE, 1 4 7)\npt = db.createPartitionedTable(t1, `pt, `ID)\npt.append!(t1);\naddColumn(pt,[\"price\", \"qty\"],[DOUBLE, INT]);\n```\n\nAfter using `addColumn` and before data with the new schema is inserted, we can still insert data with the old schema.\n\n```\nt2=table(1 as ID, 1.2 as x)\npt.append!(t2)\nselect * from pt;\n```\n\n| ID | x | price | qty |\n| -- | --- | ----- | --- |\n| 1 | 0.2 | | |\n| 2 | 0.4 | | |\n| 3 | 0.6 | | |\n| 1 | 1.2 | | |\n| 4 | 0.8 | | |\n| 5 | 1 | | |\n| 6 | 1.2 | | |\n\nAfter data with the new schema is inserted, however, data with the old schema can no longer be inserted.\n\n```\nt3=table(1 as ID, 1.6 as x, 10.0 as price, 6 as qty)\npt.append!(t3)\nselect * from pt;\n```\n\n| ID | x | price | qty |\n| -- | --- | ----- | --- |\n| 1 | 0.2 | | |\n| 2 | 0.4 | | |\n| 3 | 0.6 | | |\n| 1 | 1.2 | | |\n| 1 | 1.6 | 10 | 6 |\n| 4 | 0.8 | | |\n| 5 | 1 | | |\n| 6 | 1.2 | | |\n\n```\nt4=table(2 as ID, 2.2 as x)\npt.append!(t4); // The data to append contains fewer columns than the schema.\n```\n\nExample 2. Add columns to a stream table.\n\n```\nn=10\nticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n)\nx=rand(1.0, n)\nt=streamTable(ticker, x)\nshare t as st\naddColumn(st,[\"price\", \"qty\"],[DOUBLE, INT])\ninsert into st values(\"MSFT\",12.0,25.46,256)\nselect * from st;\n```\n\n| ticker | x | price | qty |\n| ------ | ----------------- | ----- | --- |\n| MSFT | 0.743241031421349 | | |\n| FB | 0.254624255700037 | | |\n| FB | 0.947473830310628 | | |\n| FB | 0.904140035156161 | | |\n| MSFT | 0.193251194199547 | | |\n| MSFT | 0.416090324753895 | | |\n| MSFT | 0.479371337918565 | | |\n| ORCL | 0.69910929678008 | | |\n| GOOG | 0.131539688445628 | | |\n| MSFT | 0.472390263108537 | | |\n| MSFT | 12 | 25.46 | 256 |\n" }, "addFunctionView": { "url": "https://docs.dolphindb.com/en/Functions/a/addFunctionView.html", "signatures": [ { "full": "addFunctionView(udf|moduleName)", "name": "addFunctionView", "parameters": [ { "full": "udf|moduleName", "name": "udf|moduleName" } ] } ], "markdown": "### [addFunctionView](https://docs.dolphindb.com/en/Functions/a/addFunctionView.html)\n\n\n\n#### Syntax\n\naddFunctionView(udf|moduleName)\n\n#### Parameters\n\n**udf** is either a user-defined function or a tuple containing multiple user-defined functions.\n\n**moduleName** is a STRING scalar indicating a module name.\n\nNote:\n\n* Anonymous functions are not supported.\n* A user-defined function can only take scalars, pairs or regular vectors as default parameters.\n* The module specified by*moduleName*must be placed in the modules directory of the current node.\n* When module files have both *.dos* and *.dom* versions, *.dos* is loaded first.\n* When a module is loaded with `use ` on the current node, and functions under a namespace with the same name are added as function views, the loaded module takes precedence if the function definitions are different.\n\n#### Details\n\nFunction view provides a flexible way to control user access to databases and tables. A function view is a user-defined function that encapsulates statements that access databases. Even if a user does not have the privilege to read the data of a database, the user can execute the function view to obtain the desired calculation result.\n\nSpecify user defined functions that can be executed by certain users although these users may not have TABLE\\_READ access to the datasets that these functions operate on. For example, a user who cannot see individual patient names or ages may nevertheless calculate the number of patients and the average age of patients.\n\nThe specified user defined functions can be used as the value of the parameter *objs* if the parameter *accessType* is set to VIEW\\_EXEC in command [grant](https://docs.dolphindb.com/en/Functions/g/grant.html), [deny](https://docs.dolphindb.com/en/Functions/d/deny.html) or [revoke](https://docs.dolphindb.com/en/Functions/r/revoke.html).\n\nUnlike other user-defined functions that are session isolated, the function view can be shared between sessions. The definition of the function view is persisted to the controller node, so if the DolphinDB cluster is restarted, the previously defined function view can still be used.\n\n`addFunctionView` can only be executed by administrators or users with VIEW\\_OWNER permission.\n\n#### Examples\n\nIn the following example, the user-defined function `getSpread` calculates the average bid-ask spread for a specified stock in the table *dfs\\://TAQ/quotes*. A user (user1) does not have the privilege to read table *dfs\\://TAQ/quotes*. Now define function `getSpread` to be a function view, and grant user1 the privilege to execute the function view. Although user1 cannot read the raw data of table *dfs\\://TAQ/quotes*, now she can execute the function view to calculate the average bid-ask spread of any stock in the table.\n\nPlease note that as table *dfs\\://TAQ/quotes* is a distributed database, the following script needs to be executed by a system administrator. User1 can execute function `getSpread` on any data node/compute node.\n\n```\ndef getSpread(s, d){\n return select avg((ofr-bid)/(ofr+bid)*2) as spread from loadTable(\"dfs://TAQ\",\"quotes\") where symbol=s, date=d\n}\n```\n\n```\naddFunctionView(getSpread)\n\n// grant privileges on a controller\ngrant(\"user1\", VIEW_EXEC, \"getSpread\")\n```\n\nA module test.dos which defines functions `f1` and `f2` is placed under the modules directory:\n\n```\naddFunctionView(\"test\")\n\n// Grant user1 the execution privilege of f1\ngrant(\"user1\", VIEW_EXEC, \"test::f1\")\n// Grant user1 the execution privilege of all functions under test\ngrant(`user1, VIEW_EXEC, \"test::*\")\n\n// A granted user can use the fully qualified name to call a function\ntest::f1()\n```\n\n**Related functions**: [dropFunctionView](https://docs.dolphindb.com/en/Functions/d/dropFunctionView.html), [getFunctionViews](https://docs.dolphindb.com/en/Functions/g/getFunctionViews.html)\n" }, "addGpFunction": { "url": "https://docs.dolphindb.com/en/Functions/a/addGpFunction.html", "signatures": [ { "full": "addGpFunction(engine, func)", "name": "addGpFunction", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "func", "name": "func" } ] } ], "markdown": "### [addGpFunction](https://docs.dolphindb.com/en/Functions/a/addGpFunction.html)\n\n**Note:** This function is not supported by Community Edition. You can [get a trial](https://dolphindb.com/product#downloads-down) of Shark from DolphinDB official website.\n\n#### Syntax\n\naddGpFunction(engine, func)\n\n#### Parameters\n\n**engine** is the engine object returned by `createGPLearnEngine`.\n\n**func**is a user-defined function. Currently it does not support complex assignment, `if` or `for` statement. Only `return` statement can be used to return a combination of the training functions (see Appendix for supported functions). For example:\n\n```\ndef f(x, y){\n return cos(x+y)\n}\n```\n\n#### Details\n\nAdd a user-defined training function to the GPLearn engine.\n\n#### Examples\n\n```\ndef f(x, y){\n return cos(x+y)\n}\naddGpFunction(engine,f)\n```\n\n\n\n#### Appendix\n\nThe following table lists available functions for building and evolving formulas.\n\n| Function | Description |\n| --------------- | ---------------------------------------------------------------------------------------- |\n| add(x,y) | Addition |\n| sub(x,y) | Subtraction |\n| mul(x,y) | Multiplication |\n| div(x,y) | Division. If the absolute value of the divisor is less than 0.001, returns 1. |\n| max(x,y) | Maximum value |\n| min(x,y) | Minimum value |\n| sqrt(x) | Square root of the absolute value |\n| log(x) | Logarithm. If x is less than 0.001, returns 0. |\n| neg(x) | Negation |\n| reciprocal(x) | Reciprocal. If the absolute value of x is less than 0.001, returns 0. |\n| abs(x) | Absolute value |\n| sin(x) | Sine function |\n| cos(x) | Cosine function |\n| tan(x) | Tangent function |\n| sig(x) | Sigmoid function |\n| signum(x) | Returns the sign of x |\n| mcovar(x, y, n) | Covariance of x and y within a sliding window of size n |\n| mcorr(x, y, n) | Correlation of x and y within a sliding window of size n |\n| mstd(x, n) | Sample standard deviation of x within a sliding window of size n |\n| mmax(x, n) | Maximum value of x within a sliding window of size n |\n| mmin(x, n) | Minimum value of x within a sliding window of size n |\n| msum(x, n) | Sum of x within a sliding window of size n |\n| mavg(x, n) | Average of x within a sliding window of size n |\n| mprod(x, n) | Product of x within a sliding window of size n |\n| mvar(x, n) | Sample variance of x within a sliding window of size n |\n| mvarp(x, n) | Population variance of x within a sliding window of size n |\n| mstdp(x, n) | Population standard deviation of x within a sliding window of size n |\n| mimin(x, n) | Index of the minimum value of x within a sliding window of size n |\n| mimax(x, n) | Index of the maximum value of x within a sliding window of size n |\n| mbeta(x, y, n) | Least-squares estimate of the regression coefficient of x on y within a window of size n |\n| mwsum(x, y, n) | Iner product of x and y within a sliding window of size n |\n| mwavg(x, y, n) | Weighted average of x with y as weights within a sliding window of size n |\n| mfirst(x,n) | First element of the window of size n |\n| mlast(x,n) | Last element of the window of size n |\n| mrank(x,asc, n) | Rank of x within the sliding window of size n |\n| ratios(x) | Returns the value of x(n)/x(n−1)x(n) / x(n-1) |\n| deltas(x) | Returns the value of x(n)−x(n−1)x(n) - x(n-1) |\n\nNote: For moving window operators (such as `mmax(x, n)`), the parameter *n*, which represents the window size, is randomly selected from the *windowRange*vector specified in the `createGPLearnEngine` function. In the following example, the training process randomly selects a value from \\[7,14,21] as the window size.\n\n```\nengine = createGPLearnEngine(source, predVec, windowRange=[7,14,21])\n```\n" }, "addGroupMember": { "url": "https://docs.dolphindb.com/en/Functions/a/addGroupMember.html", "signatures": [ { "full": "addGroupMember(userIds, groupIds)", "name": "addGroupMember", "parameters": [ { "full": "userIds", "name": "userIds" }, { "full": "groupIds", "name": "groupIds" } ] } ], "markdown": "### [addGroupMember](https://docs.dolphindb.com/en/Functions/a/addGroupMember.html)\n\n\n\n#### Syntax\n\naddGroupMember(userIds, groupIds)\n\n#### Parameters\n\n**userIds** is a STRING scalar/vector indicating a user name or multiple user names.\n\n**groupIds** is a STRING scalar/vector indicating a group name or multiple group names.\n\n*userIds* and *groupIds* cannot both be vectors.\n\n#### Details\n\nAdd a user to a group or multiple groups, or add multiple users to a group.\n\nIt can only be executed by an administrator.\n\n#### Examples\n\n```\naddGroupMember(`AlexSmith`JoshAllen, `production);\n```\n" }, "addIPBlackList": { "url": "https://docs.dolphindb.com/en/Functions/a/addipblacklist.html", "signatures": [ { "full": "addIPBlackList(ips)", "name": "addIPBlackList", "parameters": [ { "full": "ips", "name": "ips" } ] } ], "markdown": "### [addIPBlackList](https://docs.dolphindb.com/en/Functions/a/addipblacklist.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\naddIPBlackList(ips)\n\n#### Parameters\n\n**ips** is a STRING or IPADDR scalar/vector indicating one or more (up to 65535) IP addresses.\n\n#### Details\n\nAdd IP addresses to the blacklist. The blacklist feature is enabled when the first IP address is added. The whitelist and blacklist cannot be enabled simultaneously. After the blacklist feature is enabled, all the access requests from IP addresses in the blacklist are blocked.\n\nThis function can only be executed by an administrator and takes effect on the cluster.\n\n#### Examples\n\n```\naddIPBlackList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\n```\n\nRelated functions: [removeIPBlackList](https://docs.dolphindb.com/en/Functions/r/removeipblacklist.html), [getIPBlackList](https://docs.dolphindb.com/en/Functions/g/getipblacklist.html)\n" }, "addIPWhiteList": { "url": "https://docs.dolphindb.com/en/Functions/a/addipwhitelist.html", "signatures": [ { "full": "addIPWhiteList(ips)", "name": "addIPWhiteList", "parameters": [ { "full": "ips", "name": "ips" } ] } ], "markdown": "### [addIPWhiteList](https://docs.dolphindb.com/en/Functions/a/addipwhitelist.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\naddIPWhiteList(ips)\n\n#### Parameters\n\n**ips** is a STRING or IPADDR scalar/vector indicating one or more (up to 65535) IP addresses.\n\n#### Details\n\nAdd IP addresses to the whitelist. The whitelist feature is enabled when the first IP address is added. The whitelist and blacklist cannot be enabled simultaneously. After the whitelist feature is enabled, only the access requests from IP addresses in the whitelist are allowed. The local host 127.0.0.1 is included by default.\n\nThis function can only be executed by an administrator and takes effect on the cluster.\n\n#### Examples\n\n```\naddIPWhiteList([\"1.1.1.1\", \"2.2.2.2\", \"3.3.3.3\"])\n```\n\nRelated functions: [removeIPWhiteList](https://docs.dolphindb.com/en/Functions/r/removeipwhitelist.html), [getIPWhiteList](https://docs.dolphindb.com/en/Functions/g/getipwhitelist.html)\n" }, "addMarketHoliday": { "url": "https://docs.dolphindb.com/en/Functions/a/addMarketHoliday.html", "signatures": [ { "full": "addMarketHoliday(marketName, holiday)", "name": "addMarketHoliday", "parameters": [ { "full": "marketName", "name": "marketName" }, { "full": "holiday", "name": "holiday" } ] }, { "full": "addMarketHoliday(marketName, holiday, [dateType = 'holidayDate'])", "name": "addMarketHoliday", "parameters": [ { "full": "marketName", "name": "marketName" }, { "full": "holiday", "name": "holiday" }, { "full": "[dateType = 'holidayDate']", "name": "[dateType = 'holidayDate']" } ] } ], "markdown": "### [addMarketHoliday](https://docs.dolphindb.com/en/Functions/a/addMarketHoliday.html)\n\n\n\n#### Syntax\n\naddMarketHoliday(marketName, holiday)\n\naddMarketHoliday(marketName, holiday, \\[dateType = 'holidayDate'])\n\n#### Parameters\n\n**marketName** is a STRING scalar, indicating the identifier of the trading calendar, e.g., the Market Identifier Code of an exchange, or a user-defined calendar name.\n\n**holiday** is a vector of DATE type, indicating weekday holidays.\n\n**holiday** is a vector of DATE type, indicating holiday dates or trading dates.\n\n* When *dateType*='holidayDate', *holiday* should be specified as the dates of weekday holidays.\n\n* When *dateType*='tradingDate', *holiday* should be specified as trading dates.\n\n**dateType** (optional) is a string, indicating the type of the added file from which the trading calendar is generated. It can take one of the following values: 'holidayDate' (default) and 'tradingDate'.\n\n#### Details\n\nAdds a holiday calendar online to generate a trading calendar.Adds a file of holiday dates or trading dates to generate a trading calendar. A CSV file named *marketName* will be generated in the directory specified by *marketHolidayDir*.\n\nNote:\n\n* It can only be executed by an administrator.\n\n* It only takes effect on the current node. In a cluster, `pnodeRun` can be used to call this function on all data/compute nodes.\n\n* *marketName*must consist of four uppercase letters and cannot be the same as the file name in *marketHolidayDir*.\n\n#### Examples\n\nExample 1: Adding a custom trading calendar with *holiday* containing dates of weekday holidays\n\nThe following example demonstrates how to manually add a trading calendar named \"DCBA\".\n\n```\naddMarketHoliday(\"DCBA\",2022.01.03 2022.01.05)\n```\n\nA file named *DCBA.csv* will be generated in */server/marketHoliday/*, containing all specified holidays.\n\n**Note**: When attempting to create a trading calendar, if you use an identifier (like \"DCBA\") that already exists in the */server/marketHoliday/* directory, the system will block the operation with an error message: `The added market '' already exists`, preventing duplication of trading calendars.\n\n```\ntemporalAdd(2022.01.01,1,\"DCBA\")\n//Output: 2022.01.04\n```\n\n```\nindex = [2022.01.01, 2022.01.02, 2022.01.03, 2022.01.04]\ns = indexedSeries(index, 1..4)\ns.resample(\"DCBA\", sum);\n/* output\nlabel\tcol1\n2021.12.31 6\n2022.01.04 4\n*/\n```\n\nExample 2: Adding a custom trading calendar with *holiday* containing trading dates on weekends\n\nThe following example demonstrates how to manually add a trading calendar named \"AAAA\".\n\n```\ntradingDates=[2024.02.08, 2024.02.09, 2024.02.18, 2024.02.19, 2024.02.20, 2024.02.21]\naddMarketHoliday(marketName=\"AAAA\", holiday=tradingDates, dateType='tradingDate')\n```\n\nA file named *AAAA.csv* will be generated in */server/marketHoliday/*. In the file is a column named \"tradingDate\", which contains data from the vector *tradingDates*.\n\n```\ntemporalAdd(2024.02.09, 1, \"AAAA\") \n// Output: 2024.02.18\n```\n\n```\ntemporalAdd(2024.02.21, 1, \"AAAA\")\n// Dates not included in AAAA.csv will throw an error: The returned date does not exist in trading calendar [AAAA].\n```\n\nRelated functions: [updateMarketHoliday](https://docs.dolphindb.com/en/Functions/u/updateMarketHoliday.html), [getMarketCalendar](https://docs.dolphindb.com/en/Functions/g/getMarketCalendar.html), [getTradingCalendarType](https://docs.dolphindb.com/en/Functions/g/getTradingCalendarType.html).\n" }, "addMCPPrompt": { "url": "https://docs.dolphindb.com/en/Functions/a/addMCPPrompt.html", "signatures": [ { "full": "addMCPPrompt(name, message, [description], [extraInfo])", "name": "addMCPPrompt", "parameters": [ { "full": "name", "name": "name" }, { "full": "message", "name": "message" }, { "full": "[description]", "name": "description", "optional": true }, { "full": "[extraInfo]", "name": "extraInfo", "optional": true } ] } ], "markdown": "### [addMCPPrompt](https://docs.dolphindb.com/en/Functions/a/addMCPPrompt.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\naddMCPPrompt(name, message, \\[description], \\[extraInfo])\n\n#### Parameters\n\n**name** is a STRING scalar indicating the name of the prompt template.\n\n**message** is a STRING scalar indicating the content of the prompt template. It can contain the placeholder `{}`.\n\n**description** (optional) is a STRING scalar indicating the description of the prompt template.\n\n**extraInfo** (optional) is a dictionary with STRING keys and ANY or STRING values used to specify additional information. Currently support \"title\" only.\n\n#### Details\n\nDefines an MCP prompt template.\n\n**Return value**: A string indicating the name of the newly added MCP prompt template.\n\n#### Examples\n\n```\naddMCPPrompt(\n name = \"stock_summary\",\n message = \"Summary the trend of ${stock} from ${startDate} to ${endDate}.\",\n description = \"Generate a natural-language overview of a stock over a time period\",\n extraInfo = {title : \"Stock Trend Summary\"}\n)\n\n//output:'stock_summary'\n```\n" }, "addMCPTool": { "url": "https://docs.dolphindb.com/en/Functions/a/addMCPTool.html", "signatures": [ { "full": "addMCPTool(name, func, [argNames], [argTypes], [description], [extraInfo])", "name": "addMCPTool", "parameters": [ { "full": "name", "name": "name" }, { "full": "func", "name": "func" }, { "full": "[argNames]", "name": "argNames", "optional": true }, { "full": "[argTypes]", "name": "argTypes", "optional": true }, { "full": "[description]", "name": "description", "optional": true }, { "full": "[extraInfo]", "name": "extraInfo", "optional": true } ] } ], "markdown": "### [addMCPTool](https://docs.dolphindb.com/en/Functions/a/addMCPTool.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\naddMCPTool(name, func, \\[argNames], \\[argTypes], \\[description], \\[extraInfo])\n\n#### Parameters\n\n**name** is a STRING scalar, indicating the tool name.\n\n**func** is a user-defined function.\n\n**argNames** is a STRING vector specifying the argument names. Pass `[]` if no parameters are required.\n\n**argTypes** is a STRING vector specifying the data types of arguments, which can be DolphinDB data types or JSON data types. Supported types include:\n\n| DolphinDB Type | JSON Type |\n| -------------- | ----------------- |\n| STRING | \"string\" |\n| TEMPORAL | \"string\" |\n| DOUBLE | \"number\" |\n| BOOL | \"boolean\" |\n| STRING\\[] | \"array\\\" |\n| TEMPORAL\\[] | \"array\\\" |\n| DOUBLE\\[] | \"array\\\" |\n| BOOL\\[] | \"array\\\" |\n\n**description** (optional) A STRING scalar describing the tool.\n\n**extraInfo** (optional) A dictionary where keys are strings and values are of type ANY or STRING, used to specify additional metadata. Currently,the only supported key is \"title\"\n\n#### Details\n\nDefines a new MCP tool.\n\n**Return value**: A string representing the tool name.\n\n#### Examples\n\n```\ndef myTool(x) {\n return x * 2 + 1\n}\n\ninfo = {\n \"title\": \"DolphinDB Tools\"\n}\n\naddMCPTool(name=\"myTool\", func=myTool, argNames=[\"a\"], argTypes=[\"number\"], description=\"This is a tool\", extraInfo=info)\n```\n" }, "addMetrics": { "url": "https://docs.dolphindb.com/en/Functions/a/addMetrics.html", "signatures": [ { "full": "addMetrics(engine, newMetrics, newMetricsSchema, [windowSize], [fill])", "name": "addMetrics", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "newMetrics", "name": "newMetrics" }, { "full": "newMetricsSchema", "name": "newMetricsSchema" }, { "full": "[windowSize]", "name": "windowSize", "optional": true }, { "full": "[fill]", "name": "fill", "optional": true } ] } ], "markdown": "### [addMetrics](https://docs.dolphindb.com/en/Functions/a/addMetrics.html)\n\n\n\n#### Syntax\n\naddMetrics(engine, newMetrics, newMetricsSchema, \\[windowSize], \\[fill])\n\nAlias: extendMetrics\n\n#### Parameters\n\n**engine** is the abstract table object returned by a streaming engine function such as [createTimeSeriesEngine](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.html). Note that `addMetrics` cannot be used in [createAnomalyDetectionEngine](https://docs.dolphindb.com/en/Functions/c/createAnomalyDetectionEngine.html) and [createReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createReactiveStateEngine.html).\n\n**newMetrics** is metacode indicating the new metrics to be calculated by the streaming engine. The metacode can include one or more expressions, built-in or user-defined functions, or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n\n**newMetricsSchema** is a table object specifying the column names and data types of the new metrics in the output table.\n\n**windowSize** (optional) is a positive integer indicating the length of the windows for calculation for the new metrics. It is only used for the time-series engine. It must be one of the values of *windowSize* in the existing time-series engine. The default value is the first value of *windowSize* in the existing time-series engine.\n\n**fill** (optional) is a vector/scalar indicating the filling method to deal with an empty window (in a group). It can be:\n\n* 'none': no result\n\n* 'null': output a null value.\n\n* 'ffill': output the result in the last window.\n\n* specific value: output the specified value. Its type should be the same as metrics output's type.\n\n*fill* could be a vector to specify different filling method for each metric. The size of the vector must be consistent with the number of elements specified in *metrics*. The element in vector cannot be 'none'.\n\n#### Details\n\nDynamically add new measures to a streaming engine.\n\n#### Examples\n\nCalculate the sum of column x with a streaming engine:\n\n```\nshare streamTable(10000:0,`time`id`x, [TIMESTAMP,SYMBOL,INT]) as t\noutput1 = table(10000:0, `time`sum_x, [TIMESTAMP,INT])\nagg1 = createTimeSeriesEngine(name=`agg1, windowSize=100, step=50, metrics=, dummyTable=t, outputTable=output1, timeColumn=`time)\nsubscribeTable(tableName=\"t\", actionName=\"agg1\", offset=0, handler=append!{agg1}, msgAsTable=true)\nn=500\ntime=2019.01.01T00:00:00.000+(1..n)\nid=take(`ABC`DEF, n)\nx=1..n\ninsert into t values(time, id, x);\nselect * from output1;\n```\n\n| time | sum\\_x |\n| ----------------------- | ------ |\n| 2019.01.01T00:00:00.050 | 1,225 |\n| 2019.01.01T00:00:00.100 | 4,950 |\n| 2019.01.01T00:00:00.150 | 9,950 |\n| 2019.01.01T00:00:00.200 | 14,950 |\n| 2019.01.01T00:00:00.300 | 24,950 |\n| 2019.01.01T00:00:00.350 | 29,950 |\n| 2019.01.01T00:00:00.400 | 34,950 |\n| 2019.01.01T00:00:00.450 | 39,950 |\n| 2019.01.01T00:00:00.500 | 44,950 |\n\nNow add a new measure `avg(x)` to the streaming engine. The new measure's column name is avg\\_x and the data type is DOUBLE in the output table.\n\n```\nnewMetricsSchema= table(1:0, [`avg_x], [DOUBLE])\naddMetrics(agg1, , newMetricsSchema);\nn=300\ntime=2019.01.01T00:00:00.500+(1..n)\nid=take(`ABC`DEF, n)\nx=500+1..n\ninsert into t values(time, id, x);\nselect * from output1;\n```\n\n| time | sum\\_x | avg\\_x |\n| ----------------------- | ------ | ------ |\n| 2019.01.01T00:00:00.050 | 1,225 | |\n| 2019.01.01T00:00:00.100 | 4,950 | |\n| 2019.01.01T00:00:00.150 | 9,950 | |\n| 2019.01.01T00:00:00.200 | 14,950 | |\n| 2019.01.01T00:00:00.250 | 19,950 | |\n| 2019.01.01T00:00:00.300 | 24,950 | |\n| 2019.01.01T00:00:00.350 | 29,950 | |\n| 2019.01.01T00:00:00.400 | 34,950 | |\n| 2019.01.01T00:00:00.450 | 39,950 | |\n| 2019.01.01T00:00:00.500 | 44,950 | |\n| 2019.01.01T00:00:00.550 | 49,950 | 525 |\n| 2019.01.01T00:00:00.600 | 54,950 | 550 |\n| 2019.01.01T00:00:00.650 | 59,950 | 599.5 |\n| 2019.01.01T00:00:00.700 | 64,950 | 649.5 |\n| 2019.01.01T00:00:00.750 | 69,950 | 699.5 |\n| 2019.01.01T00:00:00.800 | 74,950 | 749.5 |\n" }, "addNode": { "url": "https://docs.dolphindb.com/en/Functions/a/addNode.html", "signatures": [ { "full": "addNode(host, port, alias, [saveConfig=true], [nodeType='datanode'], [computeGroup]), [zone])", "name": "addNode", "parameters": [ { "full": "host", "name": "host" }, { "full": "port", "name": "port" }, { "full": "alias", "name": "alias" }, { "full": "[saveConfig=true]", "name": "saveConfig", "optional": true, "default": "true" }, { "full": "[nodeType='datanode']", "name": "nodeType", "optional": true, "default": "'datanode'" }, { "full": "[computeGroup])", "name": "computeGroup", "optional": true }, { "full": "[zone]", "name": "zone", "optional": true } ] } ], "markdown": "### [addNode](https://docs.dolphindb.com/en/Functions/a/addNode.html)\n\n\n\n#### Syntax\n\naddNode(host, port, alias, \\[saveConfig=true], \\[nodeType='datanode'], \\[computeGroup]), \\[zone])\n\n#### Parameters\n\n**host** is a STRING scalar or vector indicating the IP address of the node(s).\n\n**port** is a positive integral scalar or vector indicating the port number of the node(s).\n\n**alias** is a STRING scalar or vector indicating the node alias(es).\n\n**saveConfig** (optional) is a Boolean value indicating whether to save the information of the node in the configuration file `cluster.nodes` when adding the node. The default value is true.\n\n**nodeType** (optional) is a STRING scalar or vector indicating the node type(s), which can be 'datanode' or 'computenode'.\n\n**computeGroup** (optional) is a string indicating the compute group to which the compute node belongs to. If not specified, a compute node will be added without joining any compute group, and partition data will not be cached on the node.\n\n**zone** (optional) is a string indicating the zone to which the node belongs to. If the cluster.nodes file has already defined zones, this parameter becomes mandatory and must match one of the zones. It cannot be set to an undefined zone or the default zone.\n\nNote that the length of *host*, *port*, *alias*, *nodeType* must be consistent.\n\n#### Details\n\nAdd node(s) to a cluster. It can only be executed by administrator. The added nodes are not started. You can start the nodes in the cluster management web interface or in the command line.\n\nNote that you need to deploy an agent before adding a node on a new machine.\n\n#### Examples\n\nAdd a compute node “orca4”, and specify its compute group “orca”.\n\n```\naddNode(\"192.168.1.243\", 23796, \"orca4\", true, 'computenode', \"orca\");\n```\n" }, "addRangePartitions": { "url": "https://docs.dolphindb.com/en/Functions/a/addRangePartitions.html", "signatures": [ { "full": "addRangePartitions(dbHandle, newRanges, [level=0], [locations])", "name": "addRangePartitions", "parameters": [ { "full": "dbHandle", "name": "dbHandle" }, { "full": "newRanges", "name": "newRanges" }, { "full": "[level=0]", "name": "level", "optional": true, "default": "0" }, { "full": "[locations]", "name": "locations", "optional": true } ] } ], "markdown": "### [addRangePartitions](https://docs.dolphindb.com/en/Functions/a/addRangePartitions.html)\n\n* **[addGpFunction](https://docs.dolphindb.com/en/Functions/a/addGpFunction.html)**\n\n\n\n#### Syntax\n\naddRangePartitions(dbHandle, newRanges, \\[level=0], \\[locations])\n\n#### Parameters\n\n**dbHandle** is a database handle.\n\n**newRanges** is a vector indicating new partitions. The elements in the vector must be in ascending order. The first element must be the same as the last element or the original partition scheme.\n\n**level** (optional) is a non-negative integer. For a partitioned database with COMPO domain, we need to specify the level of the partitions that `addRangePartitions` applies if it is not for the first level of partitions. This level must be of a RANGE domain. The default value is 0.\n\n**locations** (optional) is a STRING scalar/vector. If the paramater *locations* was specified when the database was created, we can use *locations* to specify where the new partitions located.\n\n#### Details\n\nAppend new values to the partition scheme of a database. This database must be of RANGE domain or of COMPO domain with at least one level of RANGE domain. Note that the new partition can only be added after the last existing partition.\n\n#### Examples\n\nIn the following example, we add 3 new ID partitions \\[100,150), \\[150,200) and \\[200,250) to the partition scheme of a database of COMPO domain.\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(date, ID, x);\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 101);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate,dbID]);\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n\naddRangePartitions(db,101 150 200 250,1)\n// output: 3\n```\n\nBefore appending data to the new partitions, we need to reload the table.\n\n```\ndb=database(\"dfs://compoDB\")\npt=loadTable(db,\"pt\")\n\nt1=table(rand(101..249,n) as ID,rand(2017.08.07..2017.08.11,n) as date,rand(10.0,n) as x)\npt.append!(t1);\n\nselect count(*) from loadTable(\"dfs://compoDB\",\"pt\");\n// output: 2000000\n```\n\nTo add new partitions consecutively without appending new data, we need to reload the database before each `addRangePartitions` operation.\n\n```\ndb=database(\"dfs://compoDB\")\npt=loadTable(db,\"pt\")\n\nt1=table(rand(2017.08.07..2017.08.11,n) as date, rand(101..249,n) as ID, rand(10.0,n) as x)\npt.append!(t1);\n\nselect count(*) from loadTable(\"dfs://compoDB\",\"pt\");\n//output: 2000000\n```\n" }, "addReactiveMetrics": { "url": "https://docs.dolphindb.com/en/Functions/a/addReactiveMetrics.html", "signatures": [ { "full": "addReactiveMetrics(name, metricNames, metrics)", "name": "addReactiveMetrics", "parameters": [ { "full": "name", "name": "name" }, { "full": "metricNames", "name": "metricNames" }, { "full": "metrics", "name": "metrics" } ] } ], "markdown": "### [addReactiveMetrics](https://docs.dolphindb.com/en/Functions/a/addReactiveMetrics.html)\n\n\n\n#### Syntax\n\naddReactiveMetrics(name, metricNames, metrics)\n\n#### Details\n\nDynamically add new factors to a reactive state engine generated by `createNarrowReactiveStateEngine`. The added factors take effect on subsequent incoming data.\n\n#### Parameters\n\n**name**is a string indicating the engine name.\n\n**metricNames** is a STRING scalar or vector, indicating the name of the new factor. The number and order of names must align to that of factors specified in *metrics*.\n\n**metrics** is metacode or a tuple of metacode containing new factors.\n\n#### Examples\n\n```\ndummy = streamTable(1:0, [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT]) \noutputTable = streamTable(1:0,[\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"metricNames\",\"factorValue\"], [STRING,STRING,STRING, TIMESTAMP,TIMESTAMP,STRING,DOUBLE])\nfactor = [, ,]\nNarrowtest = createNarrowReactiveStateEngine(name=\"narrowtest1\",metrics=factor,metricNames=\"factor1\",dummyTable=dummy,outputTable=outputTable,keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\nnum = 5\ntmp = table(take(\"A\" + lpad(string(1..4),4,\"0\"),num) as securityID1,take(\"CC.HH\" + lpad(string(21..34),4,\"0\"),num) as securityID2,take(\"FFICE\" + lpad(string(13..34),4,\"0\"),num) as securityID3, 2023.09.01 00:00:00+(1..num) as createTime, 2023.09.01 00:00:00+(1..num) as updateTime,100.0+(1..num) as upToDatePrice, 130.0+(1..num) as qty,take(1..3,num) as value)\nNarrowtest.append!(tmp)\n\nselect * from outputTable\n\n/*\nsecurityID1\tsecurityID2\tsecurityID3\tcreateTime\tupdateTime\tmetricNames\tfactorValue\nA0001\tCC.HH0021\tFFICE0013\t2023.09.01T00:00:01.000\t2023.09.01T00:00:01.000\tfactor1\t131\nA0002\tCC.HH0022\tFFICE0014\t2023.09.01T00:00:02.000\t2023.09.01T00:00:02.000\tfactor1\t132\nA0003\tCC.HH0023\tFFICE0015\t2023.09.01T00:00:03.000\t2023.09.01T00:00:03.000\tfactor1\t133\nA0004\tCC.HH0024\tFFICE0016\t2023.09.01T00:00:04.000\t2023.09.01T00:00:04.000\tfactor1\t134\nA0001\tCC.HH0025\tFFICE0017\t2023.09.01T00:00:05.000\t2023.09.01T00:00:05.000\tfactor1\t135\n*/\n\nmetrics = []\naddReactiveMetrics(\"narrowtest1\", \"factor2\", metrics)\n\n// After adding a new factor, the arrival of the new data to the engine will output the results of updated metrics\ntmp1 = table(\"A5\" as securityID1,\"CC.HH0033\" as securityID2,\"FFICE0034\" as securityID3, 2023.09.01 00:00:11 as createTime, 2023.09.01 00:00:09 as updateTime,59 as upToDatePrice,100 as qty,13 as value)\nNarrowtest.append!(tmp1)\nselect * from outputTable where securityID1=\"A5\"\n\n/*\nsecurityID1\tsecurityID2\tsecurityID3\tcreateTime\tupdateTime\tmetricNames\tfactorValue\nA5\tCC.HH0033\tFFICE0034\t2023.09.01T00:00:11.000\t2023.09.01T00:00:09.000\tfactor1\t100\nA5\tCC.HH0033\tFFICE0034\t2023.09.01T00:00:11.000\t2023.09.01T00:00:09.000\tfactor2\t59\n*/\n```\n\nRelated functions: [createNarrowReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createNarrowReactiveStateEngine.html),[getReactiveMetrics](https://docs.dolphindb.com/en/Functions/g/getReactiveMetrics.html)\n" }, "addSparseReactiveMetrics": { "url": "https://docs.dolphindb.com/en/Functions/a/addSparseReactiveMetrics.html", "signatures": [ { "full": "addSparseReactiveMetrics(name, metrics)", "name": "addSparseReactiveMetrics", "parameters": [ { "full": "name", "name": "name" }, { "full": "metrics", "name": "metrics" } ] } ], "markdown": "### [addSparseReactiveMetrics](https://docs.dolphindb.com/en/Functions/a/addSparseReactiveMetrics.html)\n\n\n\n#### Syntax\n\naddSparseReactiveMetrics(name, metrics)\n\n#### Details\n\nAdds sparse state computation rules to the specified SparseReactiveStateEngine. The format of the new *metrics* is the same as the *metrics* parameter of `createSparseReactiveStateEngine`.\n\n#### Parameters\n\n**name** is a STRING scalar indicating the name of the SparseReactiveStateEngine to which rules are added.\n\n**metrics** is a table representing the set of rules to be added. Its schema is the same as the *metrics* parameter of `createSparseReactiveStateEngine`: `keyColumn(s), formula, outputMetricKey`.\n\n#### Returns\n\nReturns no value or returns an execution status (subject to the actual product implementation).\n\n#### Examples\n\n```\nnewMetrics = table(\n [\"A003\"] as deviceID,\n [\"mavg(value,3)\"] as formula,\n [\"A003_1\"] as outputMetricKey\n)\naddSparseReactiveMetrics(\"demoengine\", newMetrics)\n```\n\n**Related functions**: [createSparseReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createSparseReactiveStateEngine.html), [getSparseReactiveMetrics](https://docs.dolphindb.com/en/Functions/g/getSparseReactiveMetrics.html), [deleteSparseReactiveMetric](https://docs.dolphindb.com/en/Functions/d/deleteSparseReactiveMetric.html)\n" }, "addValuePartitions": { "url": "https://docs.dolphindb.com/en/Functions/a/addValuePartitions.html", "signatures": [ { "full": "addValuePartitions(dbHandle, newValues, [level=0], [locations])", "name": "addValuePartitions", "parameters": [ { "full": "dbHandle", "name": "dbHandle" }, { "full": "newValues", "name": "newValues" }, { "full": "[level=0]", "name": "level", "optional": true, "default": "0" }, { "full": "[locations]", "name": "locations", "optional": true } ] } ], "markdown": "### [addValuePartitions](https://docs.dolphindb.com/en/Functions/a/addValuePartitions.html)\n\n\n\n#### Syntax\n\naddValuePartitions(dbHandle, newValues, \\[level=0], \\[locations])\n\n#### Parameters\n\n**dbHandle** is a database handle.\n\n**newValues** is a scalar or vector indicating new partitions.\n\n**level** (optional) is a non-negative integer. For a partitioned database with COMPO domain, we need to specify the level of the partitions that `addValuePartitions` applies if it is not for the first level of partitions. This level must be of a VALUE domain. The default value is 0.\n\n**locations** (optional) is a STRING scalar/vector. If the paramater *locations* was specified when the database was created, we can use *locations* to specify where the new partitions located.\n\n#### Details\n\nAppend new values to the partition scheme of a database.\n\nThis database must be of VALUE domain or of COMPO domain with at least one level of VALUE domain.\n\n#### Examples\n\nIn the following example, we append (2017.08.12..2017.08.20) to the partition scheme of a database of COMPO domain.\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbID=database(, RANGE, 0 50 100);\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndb = database(\"dfs://compoDB\", COMPO, [dbID, dbDate]);\npt = db.createPartitionedTable(t, `pt, `ID`date)\npt.append!(t)\n\naddValuePartitions(db,2017.08.12..2017.08.20,1)\n// output: 9\n```\n\nTo add new partitions consecutively without appending new data, we need to reload the database before each `addValuePartitions` operation.\n\n```\ndb=database(\"dfs://compoDB\")\npt=loadTable(db,\"pt\")\n\nt1=table(0..99 as ID,take(2017.08.12,100) as date,rand(10.0,100) as x)\npt.append!(t1)\n\nselect count(*) from loadTable(\"dfs://compoDB\",\"pt\")\n// output: 1000100\n```\n" }, "addVolumes": { "url": "https://docs.dolphindb.com/en/Functions/a/addVolumes.html", "signatures": [ { "full": "addVolumes(volumes)", "name": "addVolumes", "parameters": [ { "full": "volumes", "name": "volumes" } ] } ], "markdown": "### [addVolumes](https://docs.dolphindb.com/en/Functions/a/addVolumes.html)\n\n\n\n#### Syntax\n\naddVolumes(volumes)\n\n#### Parameters\n\n**volumes** is a STRING scalar or vector indicating the volume path(s).\n\n#### Details\n\nDynamically add volume(s) without rebooting the cluster.\n\nNote: This command does not modify the cluster configuration file. Please manually update the configuration file before the next cluster reboot, or data cannot be written to the new volume(s) after reboot.\n\n#### Examples\n\n```\naddVolumes(\"/home/dolphindb/data\")\n```\n" }, "addEventListener": { "url": "https://docs.dolphindb.com/en/Functions/a/add_event_listener.html", "signatures": [ { "full": "addEventListener(handler, [eventType], [condition], [times=\"all\"], [at], [wait], [within], [exceedTime], [name])", "name": "addEventListener", "parameters": [ { "full": "handler", "name": "handler" }, { "full": "[eventType]", "name": "eventType", "optional": true }, { "full": "[condition]", "name": "condition", "optional": true }, { "full": "[times=\"all\"]", "name": "times", "optional": true, "default": "\"all\"" }, { "full": "[at]", "name": "at", "optional": true }, { "full": "[wait]", "name": "wait", "optional": true }, { "full": "[within]", "name": "within", "optional": true }, { "full": "[exceedTime]", "name": "exceedTime", "optional": true }, { "full": "[name]", "name": "name", "optional": true } ] } ], "markdown": "### [addEventListener](https://docs.dolphindb.com/en/Functions/a/add_event_listener.html)\n\n\n\n#### Syntax\n\naddEventListener(handler, \\[eventType], \\[condition], \\[times=\"all\"], \\[at], \\[wait], \\[within], \\[exceedTime], \\[name])\n\n#### Details\n\nDefines or dynamically adds event listeners within a monitor.\n\n#### Parameters\n\n**handler** is a callback function to be invoked when the event listener triggers.\n\n* If *handler* is triggered by each matched event (with *eventType* specified), it is a unary function that takes the matched event as its parameter.\n\n* If *handler* is triggered by a scheduled time interval (without *eventType*), it is a function without any parameters.\n\n```\ndef action1(stockVal){\n // insert attributes of event stockVal to a shared table\n insert into objByName(\"sharedUSPrices\") values([stockVal.price, stockVal.qty])\n}\n```\n\nYou can add listeners dynamically in a *handler*. For example:\n\n```\ndef action1(stockVal){\n insert into objByName(\"sharedUSPrices\") values([stockVal.price, stockVal.qty])\n // add a listener\n addEventListener(handler=action2, eventType=\"Stock\", condition= Stock.price>)\n}\n```\n\n**eventType** (optional) is a string scalar indicating the event to be monitored. If set to \"any\", the *handler* will be triggered for any event that matches the specified *condition.*\n\n**condition** (optional) is metacode of Boolean expression to identify the event or pattern of events that you want to match. For example, when *eventType* is \"Stock\", *condition* can be ` 10 and Stock.qty < 10>`.\n\n**times** (optional) is \"all\" or an integer that specifies the lifetime of an event listener by setting a limit on the number of times the *handler*can be triggered. The default value is \"all\", which means the listener remains active within the CEP engine, continuously monitoring for events and invoking the *handler* until the engine is explicitly dropped.\n\n**at** (optional) is a tuple of length 6 that specifies the scheduled time for triggering the *handler*. The tuple takes the following form: `(seconds, minutes, hours, days_of_the_week, days_of_the_month, months)`. For example, `at = (0, 5, , , , )` means the *handler* will be triggered at the 5th minute of every hour.\n\n**wait**(optional) is of DURATION type, indicating the interval to trigger the *handler*. For example, `wait = 60s` means *handler* is triggered every 60 seconds.\n\n**within** (optional) is a DURATION scalar that specifies the time interval during which the *handler* is triggered by matched events. When *within* is specified, *times*must be set to 1. For example, when `within=60s`,\n\n* If one or more matching events occur within a 60-second interval, the *handler*is invoked for the first matching event and the event listener will be removed once the *handler* is triggered.\n\n* If no matching events occur within this interval, the event listener is automatically removed after 60s.\n\n**exceedTime** (optional) is a DURATION scalar that specifies the time interval during which the *handler* is triggered by the absence of matched events. If *exceedTime* is specified, *times* must be set to 1. For example, `exceedTime=60s`,\n\n* If no matching events occur within a 60-second interval, the *handler*is invoked after 60s. The event listener will be removed once the *handler* is triggered.\n\n* If one or more matching events occur within this interval, the listener is automatically removed.\n\n**name**(optional) is a STRING scalar indicating the unique identifier of the listener. The default naming rules are as follows:\n\n* If *condition* is specified, the default name is the string representation of the condition expression.\n* If *condition*is not specified but *eventType* is specified, the default name is*eventType*.\n* If both *condition*and *eventType* are not specified, the default name is \"timer\".\n* If the generated name duplicates with an existing listener, a numeric suffix will be appended automatically to ensure uniqueness.\n\n**Note:**\n\nEvent listeners can be triggered by:\n\n* **specific events**: *eventType* (required), *condition*;\n\n* **time conditions**: *at* or *wait*;\n\n* **a combination of events and time**: *eventType* (required), *condition*, combined with *within* or *exceedTime.*\n\nWhen defining a listener, do not mix parameters for different trigger conditions. For example, you should not specify an *eventType* and a *wait* time together.\n\n#### Returns\n\nReturns an `EventListener` instance.\n\n#### Examples\n\n```\nclass trades{\n trader :: STRING\n market :: STRING\n code :: STRING\n price :: DOUBLE\n qty :: INT\n eventTime :: TIMESTAMP\n def trades(t, m, c, p, q){\n trader = t\n market = m\n code = c\n price = p\n qty = q\n eventTime = now()\n }\n}\n\nclass mainMonitor:CEPMonitor{\n tradesTable :: ANY\n isBusy :: BOOL\n def mainMonitor(){\n tradesTable = array(ANY, 0)\n isBusy = false\n }\n\n def updateTrades(event)\n\n def updateTrades2(event)\n\n def unOnload(){\n undef('traderDV', SHARED)\n }\n\n def onload(){\n addEventListener(updateTrades, `trades, , \"all\",,,,,\"trades1\")\n addEventListener(updateTrades2, `trades, , \"all\",,,,,\"trades2\")\n traderDV = streamTable(array(STRING, 0) as trader, array(STRING, 0) as market, array(SYMBOL, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(INT, 0) as tradeCount, array(BOOL, 0) as busy, array(DATE, 0) as orderDate, array(TIMESTAMP, 0) as updateTime)\n share(traderDV, 'traderDV')\n createDataViewEngine('traderDV', objByName('traderDV'), `trader, `updateTime, true)\n }\n\n def updateTrades(event) {\n tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n }\n\n def updateTrades2(event) {\n tradesTable.append!([event.trader, event.market, event.code, event.price, event.qty])\n getDataViewEngine('traderDV').append!(table(event.trader as trader, string() as market, string() as code, 0.0 as price, 0 as qty, 0 as tradeCount, false as busy, date(event.eventTime) as orderDate))\n updateDataViewItems('traderDV', event.trader, ['market', 'code', 'price', 'qty', 'tradeCount'], [event.market, event.code, event.price, event.qty, tradesTable.size()])\n }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengineCep = createCEPEngine('cep1', , dummy, [trades], 1, 'eventTime', 10000)\ntrade1 = trades('t1', 'sz', 's001', 11.0, 10)\ngo\nappendEvent(engineCep, trade1)\n\nmonitors = getCEPEngineMonitor('cep1',\"cep1\",\"mainMonitor\")\n\nlisteners = monitors.getEventListener()\nprint(listeners)\n// Terminate listener\nlisteners['trades1'].terminate()\nprint(listeners)\n```\n\n**Related functions**: [getEventListener](https://docs.dolphindb.com/en/Functions/g/get_event_listener.html), [terminate](https://docs.dolphindb.com/en/Functions/t/terminate.html)\n" }, "adfuller": { "url": "https://docs.dolphindb.com/en/Functions/a/adfuller.html", "signatures": [ { "full": "adfuller(X, [maxLag], [regression=\"c\"], [autoLag=\"aic\"], [store=false], [regResults=false])", "name": "adfuller", "parameters": [ { "full": "X", "name": "X" }, { "full": "[maxLag]", "name": "maxLag", "optional": true }, { "full": "[regression=\"c\"]", "name": "regression", "optional": true, "default": "\"c\"" }, { "full": "[autoLag=\"aic\"]", "name": "autoLag", "optional": true, "default": "\"aic\"" }, { "full": "[store=false]", "name": "store", "optional": true, "default": "false" }, { "full": "[regResults=false]", "name": "regResults", "optional": true, "default": "false" } ] } ], "markdown": "### [adfuller](https://docs.dolphindb.com/en/Functions/a/adfuller.html)\n\n\n\n#### Syntax\n\nadfuller(X, \\[maxLag], \\[regression=\"c\"], \\[autoLag=\"aic\"], \\[store=false], \\[regResults=false])\n\n#### Details\n\nPerform Augmented Dickey-Fuller unit root test. It can be used to test for a unit root in a univariate process in the presence of serial correlation.\n\nThe DolphinDB `adfuller` function is consistent with `statsmodels.tsa.stattools.adfuller` in terms of core algorithm and parameter design. The main difference lies in the return value structure:\n\n* DolphinDB returns a structured dictionary with clear field semantics, which is convenient for engineering and programmatic processing.\n* `statsmodels` returns a tuple; a `ResultStore` object can provide more detailed statistical information, making it more suitable for analytical scenarios.\n\n#### Parameters\n\n**X** is a numeric vector indicating the time series data to test. The elements in X cannot be all identical, and null values are not supported.\n\n**maxlag** (optional) is a non-negative integer indicating the maximum lag which is included in test. The default value is `12*(nobs/100)^{1/4}` where nobs is the number of observations.\n\n**regression** (optional) is a string indicating the constant and trend order to include in regression. It can be:\n\n* \"c\" : constant only (default).\n\n* \"ct\" : constant and trend.\n\n* \"ctt\" : constant, and linear and quadratic trend.\n\n* \"n\" : no constant, no trend.\n\n**autoLag** (optional) is a string indicating the method to use when automatically determining the lag length among the values 0, 1, …, *maxlag*. It can be:\n\n* \"aic\": The number of lags is chosen to minimize the Akaike information criterion.\n\n* \"bic\": The number of lags is chosen to minimize the Bayesian information criterion.\n\n* \"tstat\": Start with *maxLag* and drops a lag until the t-statistic on the last lag length is significant using a 5%-sized test.\n\n* \"max\": The number of included lags is set to *maxLag*.\n\n**store** (optional) is a Boolean value. If set to true, the regression result is returned additionally to the adf statistic. The default value is false.\n\n**regResults** (optional) is a Boolean value. If set to true, the full regression results are returned. The default value is false.\n\n#### Returns\n\nA dictionary containing the following keys\n\n* adfStat: A floating-point scalar indicating the test statistic.\n\n* pValue: A floating-point scalar indicating the MacKinnon's approximate p-value based on MacKinnon (1994, 2010).\n\n* usedLag: An integer indicating the number of lags used.\n\n* nobs: An integer indicating the number of observations used for the ADF regression and calculation of the critical values.\n\n* criticalValues: A dictionary containing the critical values for the test statistic at the 1 %, 5 %, and 10 % levels.\n\n* icBest: A floating-point scalar indicating the maximized information criterion if *autoLag*is not max.\n\n* resultStore: A dictionary with results when *regResults*or *store*is set to true.\n\n#### Examples\n\n```\ndata = 234 267 289 301 312 323 334 345 356 367\nadfuller(data);\n```\n\nA dictionary is returned:\n\n```\nadfStat->-4.34190584894534\npValue->0.00037562619202430314\ncriticalValues->[-4.473135048010974,-3.2898806035665293,-2.772382345679012]\nusedLag->0\nnobs->9\nicBest->-195.23465793624445\n```\n" }, "align": { "url": "https://docs.dolphindb.com/en/Functions/a/align.html", "signatures": [ { "full": "align(left, right, [how='outer'], [byRow], [view=true])", "name": "align", "parameters": [ { "full": "left", "name": "left" }, { "full": "right", "name": "right" }, { "full": "[how='outer']", "name": "how", "optional": true, "default": "'outer'" }, { "full": "[byRow]", "name": "byRow", "optional": true }, { "full": "[view=true]", "name": "view", "optional": true, "default": "true" } ] } ], "markdown": "### [align](https://docs.dolphindb.com/en/Functions/a/align.html)\n\n\n\n#### Syntax\n\nalign(left, right, \\[how='outer'], \\[byRow], \\[view=true])\n\n#### Details\n\nAlign the *left* and *right* matrices based on row labels and/or column labels (specified by *byRow*) using the join method specified by *how*. Return a tuple with 2 aligned matrices.\n\nNote:\n\n* The aligned matrices do not keep the attributes of the original matrices. For instance, an indexed matrix will no longer have index after the alignment.\n\n* To add column/row labels to a matrix, call `rename!`. Use the SQL keywords `exec` and `pivot by` to create a matrix with the columns specified in the `pivot by` clause as the matrix labels (see [pivotBy](https://docs.dolphindb.com/en/Programming/SQLStatements/pivotBy.html)).\n\n#### Parameters\n\n**left** and **right** are both matrices with column and/or row labels.\n\n**how** (optional) indicates the join method with which the two matrices are aligned. The matrices are aligned on the column labels and/or row labels. It can be 'outer' (or 'fj'), 'inner' (or 'ej'), 'left' (or 'lj') or 'asof ('aj')'. The default value is 'outer', indicating outer join.\n\n**byRow** (optional) is a Boolean or null value.\n\n* true: align the matrices on row labels.\n\n* false: align the matrices on the column labels.\n\n* Null value (default): align on the row labels and the column labels. Specify how in the format of \"\\,\\\", e.g., `how=\"outer,inner\"`. Do not add a space or special character before or after the comma. If the same alignment method is used on rows and columns, it only needs to be specified once, e.g., `how=\"inner\"`.\n\nNote: The *left* and *right* matrices must both have the required labels (based on the value of *byRow*). The columns with the same label in both tables must have compatible data type. The supported data types and compatibility rules are as follows:\n\n* Integral (INT, SHORT, LONG and CHAR are compatible data types)\n\n* Floating (FLOAT and DOUBLE are compatible )\n\n* Temporal\n\n* STRING and SYMBOL (compatible data types)\n\n**view** (optional) is a Boolean value. The default value is true, indicating the result will be a view of the original matrix (shallow copy) and changes made to the original matrix will be reflected in the view. If set to false, the result will be a new matrix (deep copy).\n\n#### Context\n\nPrior to version 1.30.20/2.00.8, matrices must be converted to indexed matrices/series for binary operations. As the matrix/series will be aligned on index (with \"outer\" join), they must be monotonically increasing.\n\nWith the `align` function, alignment between matrices are more flexible in the following aspects:\n\n* Alignment between non-indexed matrices are supported. The matrices can be aligned on column/row labels which do not have to be monotonically increasing.\n\n* More options for the alignment methods.\n\n#### Examples\n\n```\n// align matrices with overlapping labels\nx1 = [09:00:00, 09:00:01, 09:00:03]\nx2 = [09:00:00, 09:00:03, 09:00:03, 09:00:04]\nm1 = matrix(1 2 3, 2 3 4, 3 4 5).rename!(x1)\nm2 = matrix(11 12 13, 12 13 14, 13 14 15, 14 15 16).rename!(x2)\na, b = align(left=m1, right=m2, how='fj', byRow=false);\na;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 1 | 2 | 3 | 3 | |\n| 2 | 3 | 4 | 4 | |\n| 3 | 4 | 5 | 5 | |\n\n```\nb;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 11 | | 12 | 13 | 14 |\n| 12 | | 13 | 14 | 15 |\n| 13 | | 14 | 15 | 16 |\n\n```\na+b;\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 | 09:00:03 | 09:00:04 |\n| -------- | -------- | -------- | -------- | -------- |\n| 12 | | 15 | 16 | |\n| 14 | | 17 | 18 | |\n| 16 | | 19 | 20 | |\n\n```\nm = align(left=m1, right=m2, how='aj', byRow=false);\nm[0];\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 |\n| -------- | -------- | -------- |\n| 1 | 2 | 3 |\n| 2 | 3 | 4 |\n| 3 | 4 | 5 |\n\n```\nm[1];\n```\n\n| 09:00:00 | 09:00:01 | 09:00:03 |\n| -------- | -------- | -------- |\n| 11 | 11 | 13 |\n| 12 | 12 | 14 |\n| 13 | 13 | 15 |\n\n```\n//create table pt for prices and vt for trading volumes\ntimestamp = [09:00:00, 09:00:02, 09:00:03, 09:00:06, 09:00:08]\nid= ['st1', 'st2', 'st1', 'st1', 'st2']\nprice = [197.8, 197.5, 198.4, 198.6, 198.6]\npt = table(timestamp, id, price)\n\ntimestamp = [09:00:00, 09:00:01, 09:00:02, 09:00:05, 09:00:08]\nid = ['st1', 'st2', 'st2', 'st3', 'st2']\nvol = [200, 300, 150, 200, 180]\nvt = table(timestamp, id, vol)\n\n// convert vt and pt to matrices. Use the columns specified by \"pivot by\" as labels for the matrices\nm1 = exec vol from vt pivot by timestamp, id\nm2 = exec price from pt pivot by timestamp, id\n\n// align the matrices using the full join method\nm = align(left=m1, right=m2, how='aj,fj')\n\n// get the matrix of the total trading value\nre = m[0] * m[1]\nre;\n```\n\n| label | st1 | st2 | st3 |\n| -------- | ----- | ----- | --- |\n| 09:00:00 | 39560 | | |\n| 09:00:01 | | | |\n| 09:00:02 | | 29625 | |\n| 09:00:03 | | | |\n| 09:00:05 | | | |\n| 09:00:08 | | 35748 | |\n" }, "all": { "url": "https://docs.dolphindb.com/en/Functions/Templates/all.html", "signatures": [ { "full": "all(func, args...)", "name": "all", "parameters": [ { "full": "func", "name": "func" }, { "full": "args...", "name": "args..." } ] } ], "markdown": "### [all](https://docs.dolphindb.com/en/Functions/Templates/all.html)\n\n\n\n#### Syntax\n\nall(func, args...)\n\n#### Parameters\n\n**func** is a function.\n\n**args** are the required parameters of *func*. They can be vectors/matrices/tables. They do not need to have the same data form, but they must have the same size. Data size is the number of elements for a vector, the number of columns for a matrix, and the number of rows for a table.\n\n#### Details\n\nApply a function on each element of all arguments. The template runs through each element of a vector, each column of a matrix, and each row of a table. It stops execution and returns a false value as soon as one function call returns a false value. It returns a true value if all function calls return true values.\n\n#### Examples\n\nTemplate `all` on a vector:\n\n```\nx = 1 2 NULL 11 NULL 13 NULL 102 103;\ny = x cut 3;\ny;\n// output: ([1,2,],[11,,13],[,102,103])\n\nall(hasNull, y);\n// output: 1\n// check if all of [1,2,],[11,,13],[,102,103] has null values\n\nx = 1 25 7 15 11 197 16 18 23;\ny = x cut 3;\ny;\n// output: ([1,25,7],[15,11,197],[16,18,23])\n\nall(in, 7 11 23, y);\n// output: 1\n// check if 7 in [1,25,7], 11 in [15,11,197], and 23 in [16,18,23]\n\nall(in, 7 8 23, y);\n// output: 0\n// return false as 8 is not in [15,11,197]\n\nall(lt, 1 2 3, 4 5 6);\n// output: 1\n// check if 1<4, 2<5 and 3<6\n\nall(lt, 1 2 7, 4 5 6);\n// output: 0\n// return false as 7<6 is false\n```\n\nTemplate `all` on a matrix. For a matrix, the template runs through each column.\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nall(in, 1 4 5, x);\n// output: 1\n\nall(in, 1 2 5, x);\n// output: 0\n// return false as 2 is not in the second column of matrix x\n```\n\nTemplate `all` on a table. For a table, the template runs through each row. In the following example, we define a function `varscompare` to compare the values of 2 variables in a table.\n\n```\nx=table(1 2 3 as a, 4 5 6 as b);\nx;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\ndef varscompare(t):t.a0.000515\nfValue->10.15459\nssBetween->70528.066667\ndfBetween->2\nssWithin->93763.4\ndfWithin->27\n*/\n```\n" }, "any": { "url": "https://docs.dolphindb.com/en/Functions/Templates/any.html", "signatures": [ { "full": "any(func, args...)", "name": "any", "parameters": [ { "full": "func", "name": "func" }, { "full": "args...", "name": "args..." } ] } ], "markdown": "### [any](https://docs.dolphindb.com/en/Functions/Templates/any.html)\n\n\n\n#### Syntax\n\nany(func, args...)\n\n#### Parameters\n\n**func** is a function.\n\n**args** are the required parameters of *func*. They can be vectors/matrices/tables. They do not need to have the same data form, but they must have the same size. Data size is the number of elements for a vector, the number of columns for a matrix, and the number of rows for a table.\n\n#### Details\n\nApply a function on each element of all arguments. The template runs through each element of a vector, each column of a matrix, and each row of a table. It stops execution and returns a true value as soon as one function call returns a true value. It returns a false value if all function calls return false values.\n\n#### Examples\n\nTemplate `any` on a vector:\n\n```\nx = 1 2 3 11 12 13 NULL 102 103;\ny = x cut 3;\ny;\n// output: ([1,2,3],[11,12,13],[,102,103])\n\nany(hasNull, y);\n// output: 1\n// check if any of [1,2,3],[11,12,13],[,102,103] has null values;\n\nx=1 25 7 15 11 197 16 18 23;\ny=x cut 3;\ny;\n// output: ([1,25,7],[15,11,197],[16,18,23])\n\nany(in, 7 8 23, y);\n// output: 1\n// return true since 7 is in [1, 25, 7], although 8 is not in [15,11,197]\n\nany(in, 8 20 19, y);\n// output: 0\n// 8 is not in [1,25,7], 20 is not in [15,11,197], and 19 is not in [16,18,23]\n\nany(lt, 4 5 6, 1 2 3);\n// output: 0\n// check if 4<1, 5<2 and 6<3\n\nany(<, 4 5 6, 1 7 3);\n// output: 1\n// return true as 5<7 is true\n```\n\nTemplate `any` on a matrix. For a matrix, the template runs through each column.\n\n```\nx=1..6$2:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nany(in, 6 1 4, x);\n// output: 0\n\nany(in, 3 4 2, x);\n// output: 1\n// return true as 4 is in the second column of matrix x\n```\n\nTemplate `any` on a table. For a table, the template runs through each row. In the following example, we define a function `varscompare` to compare the values of 2 variables in a table.\n\n```\nx=table(1 2 3 as a, 4 5 6 as b);\nx;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\ndef varscompare(t): t.a>t.b;\nany(varscompare, x);\n// output: 0\n\ny=table(1 7 3 as a, 4 5 6 as b);\ny;\n```\n\n| a | b |\n| - | - |\n| 1 | 4 |\n| 7 | 5 |\n| 3 | 6 |\n\n```\nany(varscompare, y);\n// output: 1\n//return true as 7>5 is true\n```\n" }, "append!": { "url": "https://docs.dolphindb.com/en/Functions/a/append!.html", "signatures": [ { "full": "append!(obj, newData)", "name": "append!", "parameters": [ { "full": "obj", "name": "obj" }, { "full": "newData", "name": "newData" } ] } ], "markdown": "### [append!](https://docs.dolphindb.com/en/Functions/a/append!.html)\n\n\n\n#### Syntax\n\nappend!(obj, newData)\n\nAlias: push!\n\n#### Parameters\n\n**obj** is a local variable, and it must be a vector/tuple/matrix/table/set.\n\n**newData** is a scalar/vector/tuple/table/set.\n\n* If *obj* is a vector, *newData* is a scalar, vector, or tuple whose elements are of the same type as *obj*. The result is a vector longer than *obj*.\n\n* If *obj* is a tuple, *newData* is a scalar, vector or tuple:\n * If *newData* is a vector, it is appended to *obj* as one tuple element;\n\n * If *newData* is a tuple, the *appendTupleAsAWhole* configuration parameter controls whether it is appended to *obj* as one tuple element (true) or each of its elements is appended independently (false).\n\n* If *obj* is a matrix, *newData* is a vector whose length must be a multiple of the number of rows of *obj*. The result is a matrix with the same number of rows as *obj* but with more columns.\n\n* If *obj* is a table, *newData* is a table with the same number of columns as *obj*. The result is a table with the same number and name of columns as *obj* but with more rows.\n\n* If *newData* and *obj* are of different data forms, `append!` will attempt to convert *newData* to the same data form as *obj*. If it is not possible, return an error message.\n\n#### Details\n\nAppend *newData* to *obj*. The exclamation mark (!) means in-place change in DolphinDB.\n\nNote: In most cases, the column names and orders in the tables should be consistent. Please first check whether the corresponding columns in *obj* and *newData* have the same names and are arranged in the same order before executing `append!`. The function does not check the consistency of column names or align the columns if they are not arranged in the same order. It is executed as long as the corresponding columns are of the same data types.\n\n#### Examples\n\n```\nx = 1 2 3\nx.append!(4)\nx\n// output: [1,2,3,4]\n\nappend!(x, 5 6)\nx\n//output: [1,2,3,4,5,6]\n\nx.append!(7.2)\nx\n//output: [1,2,3,4,5,6,7]\n// converted DOUBLE 7.2 to INT 7\n\nx.append!(`XOM)\n// Error: Incompatible type. Expected: INT, Actual: STRING\n\nx=array(int, 0, 10) // x is an empty vector\nx\n//output: []\n\nx.append!(1)\nx\n//output: [1]\n\nx=array(symbol, 0, 100)\nappend!(x, `TEST)\nx\n//output\n[\"TEST\"]\n\nx=1..6$3:2\nx\n\nx = (1,\"X\")\ny = (2,\"Y\")\nx.append!(y)\nprint(x)\n// when appendTupleAsAWhole = true\n(1,\"X\",(2,\"Y\"))\n// when appendTupleAsAWhole = false\n(1,\"X\",2,\"Y\")\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\nx.append!(7..12)\nx\n```\n\n| 0 | 1 | 2 | 3 |\n| - | - | - | -- |\n| 1 | 4 | 7 | 10 |\n| 2 | 5 | 8 | 11 |\n| 3 | 6 | 9 | 12 |\n\n```\nx=set(1 2 3 4)\nx.append!(6)\nx\n// output: set(6,1,2,3,4)\n\nt1=table(1 2 3 as x, 4 5 6 as y)\nt2=table(1.1 2.2 3.3 as a, 4.4 5.5 6.6 as b)\nt1.append!(t2)\nt1\n```\n\n| x | y |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n| 1 | 4 |\n| 2 | 6 |\n| 3 | 7 |\n\nUse `append!` to add data to a DFS table. The following example should be executed in a DFS cluster.\n\n```\nn=1000000\nt=table(rand(`IBM`MS`APPL`AMZN,n) as symbol, rand(10.0, n) as value)\ndb = database(\"dfs://rangedb_tradedata\", RANGE, `A`F`M`S`ZZZZ)\nTrades = db.createPartitionedTable(t, \"Trades\", \"symbol\")\n```\n\nWe have created an empty table Trades with the schema of t. Next, we append the empty table Trades with data from table t.\n\n```\nTrades.append!(t)\nselect count(*) from Trades;\n// output: 1000000\n```\n\nTo append table Trades with another table:\n\n```\nn=500000\nt1=table(rand(`FB`GE`MSFT,n) as symbol, rand(100.0, n) as value)\nTrades.append!(t1)\nselect count(*) from Trades\n// output: 1500000\n```\n" }, "appendEventWithResponse": { "url": "https://docs.dolphindb.com/en/Functions/a/appendeventwithresponse.html", "signatures": [ { "full": "appendEventWithResponse(engine, event, responseType, [timeout=5000], [condition], [returnType=\"instance\"])", "name": "appendEventWithResponse", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "event", "name": "event" }, { "full": "responseType", "name": "responseType" }, { "full": "[timeout=5000]", "name": "timeout", "optional": true, "default": "5000" }, { "full": "[condition]", "name": "condition", "optional": true }, { "full": "[returnType=\"instance\"]", "name": "returnType", "optional": true, "default": "\"instance\"" } ] } ], "markdown": "### [appendEventWithResponse](https://docs.dolphindb.com/en/Functions/a/appendeventwithresponse.html)\n\nFirst introduced in version: 3.00.5\n\n\n\n#### Syntax\n\nappendEventWithResponse(engine, event, responseType, \\[timeout=5000], \\[condition], \\[returnType=\"instance\"])\n\n#### Details\n\nA synchronous event-processing function for CEP engines. It sends an event to the engine and blocks the current thread until a matching response event is received or the wait times out.\n\nUnlike [appendEvent](https://docs.dolphindb.com/en/Streaming/RoutingEvents.md#) that operates asynchronously, this function adopts a synchronous request-response pattern.\n\n#### Parameters\n\n**engine** is a CEP engine handle or name.\n\n**event** is a class object of the event instance or a dictionary. If it is a dictionary, the event instances will be automatically constructed with the key-value pairs provided. The keys of the dictionary must include the \"eventType\" and all fields declared by the event type.\n\n**responseType** is a STRTING scalar specifying the expected type of the response event.\n\n**timeout** (optional) is an INT scalar specifying the maximum wait time for the response in milliseconds. The default is 5000 ms.\n\n**condition** (optional) is metacode of Boolean expression to ifilter response events, e.g. ``. If *condition* is specified, both the event type and the filter condition must be satisfied for an event to be accepted.\n\n**returnType**is a STRING scalar specifying the format of the returned response event. The options include:\n\n* \"dict\": Returns the response event as a dictionary.\n\n* \"instance\" (default): Returns the response event as an event instance.\n\n#### Returns\n\nThe return value depends on the *returnType* parameter:\n\n* If *returnType*=\"dict\", the function returns a dictionary.\n* If *returnType*=\"instance\", the function returns an event instance.\n\n#### Examples\n\nThis example demonstrates how to implement strategy start requests with synchronous responses.\n\nAn external caller sends a StartRequest event to the CEP engine to initiate a strategy start request. The CEP monitor receives and processes the event, executes the corresponding startup logic, and returns the result via a StartResponse event.\n\nThe caller uses the `appendEventWithResponse` function to synchronously wait for the startup response of a specific strategy instance, matched by instanceId, thereby implementing an event-based request–response interaction pattern.\n\n```\ntry { \n dropStreamEngine(`cep) \n} catch(ex) { print(ex) }\n\ntry {\n dropStreamEngine(`streamEventSerializer)\n} catch(ex) { print(ex) }\n\n\nclass StartRequest{\n instanceId :: STRING\n strategyParams :: INT\n def StartRequest(instanceId_, strategyParams_){\n instanceId = instanceId_\n strategyParams = strategyParams_\n }\n}\n\nclass StartResponse{\n instanceId :: STRING\n status :: STRING\n def StartResponse(instanceId_, status_){\n instanceId = instanceId_\n status = status_\n }\n}\n\nclass Stratege:CEPMonitor {\n\t// Custructor\n\tdef Stratege(){\n\t}\n def startStratege(StartRequestEvent){\n // Start a strategy instance\n }\n\tdef processStartRequest(StartRequestEvent){\n startStratege(StartRequestEvent)\n // Send a strategy start success response\n emitEvent(StartResponse(StartRequestEvent.instanceId, \"success\")) \n }\n\tdef onload() {\n // Register an event listener for strategy start requests\n\t\taddEventListener(handler=processStartRequest, eventType=\"StartRequest\", times=\"all\")\n\t}\n}\n\ndummy = table(array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nshare streamTable(array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as outputTable\nserializer = streamEventSerializer(name=`streamEventSerializer, eventSchema=[StartResponse], outputTable=outputTable)\n// Create a CEP engine\nengine = createCEPEngine(name='cep1', monitors=, dummyTable=dummy, eventSchema=[StartRequest], outputTable=serializer)\n\n// Send a strategy start request and synchronously wait for the successful startup response of strategy instance instance_001\nrequest = StartRequest(`instance_001, 100)\nresponse = appendEventWithResponse(engine=getStreamEngine(`cep1), event=request, responseType=\"StartResponse\", timeout=3000, condition=)\n```\n\n**Related function:** [appendEvent](https://docs.dolphindb.com/en/Streaming/RoutingEvents.md#)\n" }, "appendForJoin": { "url": "https://docs.dolphindb.com/en/Functions/a/appendForJoin.html", "signatures": [ { "full": "appendForJoin(engine, isLeftTable, data)", "name": "appendForJoin", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "isLeftTable", "name": "isLeftTable" }, { "full": "data", "name": "data" } ] } ], "markdown": "### [appendForJoin](https://docs.dolphindb.com/en/Functions/a/appendForJoin.html)\n\n\n\n#### Syntax\n\nappendForJoin(engine, isLeftTable, data)\n\n#### Parameters\n\n**engine** is a streaming join engine, which is the abstract table object returned by function `createAsofJoinEngine`, `createEquiJoinEngine`, `createWindowJoinEngine`, `createLeftSemiJoinEngine`, or `createLookupJoinEngine`.\n\n**isLeftTable** is a Boolean value indicating whether to insert into the left table or right table.\n\n**data** is the data to be ingested into the streaming engine.\n\n#### Details\n\nInsert data into a streaming join engine.\n\nPlease note that the parameter *handler* of function [subscribeTable](https://docs.dolphindb.com/en/Functions/s/subscribeTable.html) must be `appendForJoin`, [getLeftStream](https://docs.dolphindb.com/en/Functions/g/getLeftStream.html), or [getRightStream](https://docs.dolphindb.com/en/Functions/g/getRightStream.html) while subscribing to a stream table of a streaming join engine.\n\n#### Examples\n\n```\nleftTable=table(1:0, `timestamp`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\nrightTable=table(1:0, `timestamp`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\noutput=table(100:0, `timestamp`sym`price`val`total, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE, DOUBLE])\najEngine=createAsofJoinEngine(\"test1\", leftTable, rightTable, output, <[price, val, price*val]>, `sym, `timestamp, false, 7)\n\ntmp1=table(take(2012.01.01T00:00:00.000+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 20) as timestamp, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\ntmp2=table(take(2012.01.01T00:00:00.000+[1, 2, 3, 4, 4, 4, 4, 4, 4, 4], 20) as timestamp, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as val)\n\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.001))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.001))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.002))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.002))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.003))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.003))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.004))\nappendForJoin(ajEngine, false, (select * from tmp2 where timestamp=2012.01.01T00:00:00.004))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.005))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.006))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.007))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.008))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.009))\nappendForJoin(ajEngine, true, (select * from tmp1 where timestamp=2012.01.01T00:00:00.010))\n\nsleep(5000)\n```\n" }, "appendForPrediction": { "url": "https://docs.dolphindb.com/en/Functions/a/appendforprediction.html", "signatures": [ { "full": "appendForPrediction(engine, data)", "name": "appendForPrediction", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "data", "name": "data" } ] } ], "markdown": "### [appendForPrediction](https://docs.dolphindb.com/en/Functions/a/appendforprediction.html)\n\n#### Syntax\n\nappendForPrediction(engine, data)\n\n#### Arguments\n\n**engine** is a string indicating the name of the yield curve engine or the engine object returned by `createYieldCurveEngine`.\n\n**data** is a table object containing data to be predicted. Its schema must match the *predictDummyTable*parameter specified in `createYieldCurveEngine`.\n\n#### Details\n\nAppend data to the predictDummyTable of a yield curve engine (`createYieldCurveEngine`) for prediction.\n\n#### Examples\n\nCreate a yield curve engine.\n\n```\ndummyTable = table(1:0, `symbol`sendingtime`askDirtyPrice1`bidDirtyPrice1`midDirtyPirce1`askyield1`bidyield1`midyield1`timetoMaturity`assetType`datasource`clearRate, \n [SYMBOL, TIMESTAMP,DECIMAL32(3),DECIMAL32(3),DECIMAL32(3),DECIMAL32(3),DECIMAL32(3),DECIMAL32(3),DOUBLE,INT,INT,STRING])\nassetType=[0,1,2]\nfitMethod=[,\n ,\n ]\n\nmodelOutput=table(1:0, `time`assetType`dataSource`clearRate`model,\n [TIMESTAMP,INT,INT,SYMBOL,BLOB])\npredictOutput=table(1:0, `time`assetType`dataSource`clearRate`x`y,[TIMESTAMP,INT,INT,SYMBOL,DOUBLE,DOUBLE])\n\nengine = createYieldCurveEngine(name=\"test\", dummyTable=dummyTable,assetType=assetType,fitMethod=fitMethod,\n keyColumn=`assetType`dataSource`clearRate, modelOutput=modelOutput,\n frequency=10,predictInputColumn=`timetoMaturity,predictTimeColumn=`sendingtime, \n predictOutput=predictOutput,fitAfterPredict=false)\n \ndata = table(take(`a`b`c, 30) as symbol, take(now(), 30) as time, decimal32(rand(10.0, 30),3) as p1, decimal32(rand(10.0, 30),3) as p2, decimal32(rand(10.0, 30),3) as p3, decimal32(rand(10.0, 30),3) as p4, decimal32(rand(10.0, 30),3) as p5, decimal32(rand(10.0, 30),3) as p6, (rand(10.0, 30)+10).sort() as timetoMaturity, take(0 1 2, 30) as assetType, take([1], 30) as datasource, take(\"1\", 30) as clearRate)\nengine.append!(data) \n```\n\nUse the `appendForPrediction` function to add data to the predictOutput table and retrieve the prediction results.\n\n```\nappendForPrediction(engine, data) \n//Output: 30 \n```\n\n**Related Function**: [createYieldCurveEngine](https://docs.dolphindb.com/en/Functions/c/createyieldcurveengine.html)\n" }, "appendMktData": { "url": "https://docs.dolphindb.com/en/Functions/a/appendMktData.html", "signatures": [ { "full": "appendMktData(engine, data, [eventTime])", "name": "appendMktData", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "data", "name": "data" }, { "full": "[eventTime]", "name": "eventTime", "optional": true } ] } ], "markdown": "### [appendMktData](https://docs.dolphindb.com/en/Functions/a/appendMktData.html)\n\n\n\n#### Syntax\n\nappendMktData(engine, data, \\[eventTime])\n\n#### Details\n\nWrites market data to either a market data engine or a pricing engine.\n\n* For a market data engine, the written data is used to update the cached historical data.\n* For a pricing engine, the written data is applied to update pricing calculations.\n\n#### Parameters\n\n**engine** is the handle of a market data engine/pricing engine.\n\n**data** is an MKTDATA scalar/vector or a dictionary, indicating the market data to be written.\n\n**eventTime** (optional) is a NANOTIMESTAMP scalar indicating the time at which the event occurs. This parameter is used only when `engineConfig.outputTime` is set to true.\n\n#### Returns\n\nA LONG scalar.\n\n#### Examples\n\nExample 1. Writing market data to a market data engine.\n\nCreate a market data engine.\n\n```\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\nreferenceDate = 2025.07.01\nconfig1 = {\"name\": \"USDCNY\", \"type\": \"FxSpotRate\"}\nconfig2 = {\"name\": \"EURUSD\", \"type\": \"FxSpotRate\"}\nconfig3 = {\"name\": \"EURCNY\", \"type\": \"FxSpotRate\"}\nengine = createMktDataEngine(\"MKTDATA_ENGINE\", referenceDate, [config1, config2, config3])\n```\n\nWrite a single MKTDATA record (scalar).\n\n```\nfxSpot1 = {\n \"mktDataType\": \"Price\",\n \"referenceDate\": referenceDate,\n \"spotDate\": 2025.07.03,\n \"priceType\": \"FxSpotRate\",\n \"value\": 7.12,\n \"unit\": \"USDCNY\"\n}\nmktData1 = parseMktData(fxSpot1)\n\nappendMktData(engine, mktData1)\n```\n\nWrite multiple MKTDATA records (vector).\n\n```\nfxSpot2 = {\n \"mktDataType\": \"Price\",\n \"referenceDate\": referenceDate,\n \"priceType\": \"FxSpotRate\",\n \"value\": 7.88,\n \"unit\": \"EURCNY\"\n}\nfxSpot3 = {\n \"mktDataType\": \"Price\",\n \"referenceDate\": referenceDate,\n \"priceType\": \"FxSpotRate\",\n \"value\": 1.10,\n \"unit\": \"EURUSD\"\n}\nmktData2 = parseMktData(fxSpot2)\nmktData3 = parseMktData(fxSpot3)\nappendMktData(engine, [mktData1, mktData2, mktData3]) \n```\n\nInspect the generated market data.\n\n```\nre = getMktData(engine, \"Price\", referenceDate, \"EURUSD\")\nprint(re)\n\n// output: {\"mktDataType\": \"Price\",\"priceType\": \"FxSpotRate\",\"spotDate\": \"2025.07.03\",\"referenceDate\": \"2025.07.01\",\"value\": 1.1,\"unit\": \"EURUSD\",\"version\": 2,\"underlying\": \"EURUSD\"}\n```\n\nExample 2. Specifying *eventTime* when outputTime is enabled\n\nWhen the engine is configured with `outputTime=true`, the *eventTime* parameter must be provided when inserting data using `appendMktData`.\n\n```\n// Clean up the environment (if the engine already exists)\ntry{dropStreamEngine(\"MKTDATA_ENGINE\")}catch(ex){}\n\n// Set the reference date and market data configurations\nreferenceDate = 2025.07.01\nconfig1 = {\"name\": \"USDCNY\", \"type\": \"FxSpotRate\"}\nconfig2 = {\"name\": \"EURUSD\", \"type\": \"FxSpotRate\"}\nconfig3 = {\"name\": \"EURCNY\", \"type\": \"FxSpotRate\"}\n\n// Create engine configuration with outputTime enabled\nengineConfig = {\n \"outputTime\": true\n}\n\n// Create a market data engine\nengine = createMktDataEngine(\n name=\"MKTDATA_ENGINE\",\n referenceDate=referenceDate,\n mktDataConfig=[config1, config2, config3],\n engineConfig=engineConfig \n)\n\n// Create MKTDATA object\nfxSpot1 = {\n \"mktDataType\": \"Price\",\n \"referenceDate\": referenceDate,\n \"spotDate\": 2025.07.03,\n \"priceType\": \"FxSpotRate\",\n \"value\": 7.12,\n \"unit\": \"USDCNY\"\n}\nmktData1 = parseMktData(fxSpot1)\n\n// Use appendMktData and explicitly specify the eventTime parameter\neventTime = now() \nappendMktData(engine, mktData1, eventTime)\n\nre = getMktData(engine, \"Price\", referenceDate, \"USDCNY\")\nprint(re)\n\n// output: {\"mktDataType\": \"Price\",\"priceType\": \"FxSpotRate\",\"spotDate\": \"2025.01.03\",\"referenceDate\": \"2025.01.01\",\"value\": 7.12,\"unit\": \"USDCNY\",\"version\": 2,\"underlying\": \"USDCNY\"}\n```\n\n**Related functions**: [createMktDataEngine](https://docs.dolphindb.com/en/Functions/c/createMktDataEngine.html), [createPricingEngine](https://docs.dolphindb.com/en/Functions/c/createPricingEngine.html), [parseMktData](https://docs.dolphindb.com/en/Functions/p/parseMktData.html), [getMktData](https://docs.dolphindb.com/en/Functions/g/getMktData.html)\n" }, "appendMsg": { "url": "https://docs.dolphindb.com/en/Functions/a/appendMsg.html", "signatures": [ { "full": "appendMsg(engine, msgBody, msgId)", "name": "appendMsg", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "msgBody", "name": "msgBody" }, { "full": "msgId", "name": "msgId" } ] } ], "markdown": "### [appendMsg](https://docs.dolphindb.com/en/Functions/a/appendMsg.html)\n\n\n\n#### Syntax\n\nappendMsg(engine, msgBody, msgId)\n\n#### Parameters\n\n**engine** is a built-in streaming engine, i.e., the abstract table object return by functions such as [createReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createReactiveStateEngine.html)\n\n**msgBody** is the messages to be ingested into the streaming engine.\n\n**msgId** is the ID of the last message that has been ingested into the streaming engine. The ID starts from the beginning of the subscription.\n\n#### Details\n\nIf *snapshot* is enabled and *RaftGroup* is disabled for a streaming engine, the *handler* parameter of function [subscribeTable](https://docs.dolphindb.com/en/Functions/s/subscribeTable.html) must be `appendMsg` to inject the data into the engine.\n\n#### Examples\n\n```\nshare streamTable(10000:0,`time`sym`price, [TIMESTAMP,SYMBOL,DOUBLE]) as trades\noutput1 =table(10000:0, `time`sym`avgPrice, [TIMESTAMP,SYMBOL,DOUBLE]);\n\nengine1 = createTimeSeriesEngine(name=`engine1, windowSize=100, step=50, metrics=, dummyTable=trades, outputTable=output1, timeColumn=`time, keyColumn=`sym, snapshotDir=\"C:/DolphinDB/Data/snapshotDir\", snapshotIntervalInMsgCount=100)\nsubscribeTable(tableName=\"trades\", actionName=\"engine1\", offset=0, handler=appendMsg{engine1}, msgAsTable=true, handlerNeedMsgId=true)\n\nn=500\ntimev=2021.03.12T15:00:00.000 + (1..n join 1..n)\nsymv = take(`A, n) join take(`B, n)\npricev = (100+cumsum(rand(1.0,n)-0.5)) join (200+cumsum(rand(1.0,n)-0.5))\nt=table(timev as time, symv as sym, pricev as price).sortBy!(`time)\ntrades.append!(t)\n\nselect * from output1\n```\n" }, "appendOrcaStreamTable": { "url": "https://docs.dolphindb.com/en/Functions/a/appendOrcaStreamTable.html", "signatures": [ { "full": "appendOrcaStreamTable(name, data)", "name": "appendOrcaStreamTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "data", "name": "data" } ] } ], "markdown": "### [appendOrcaStreamTable](https://docs.dolphindb.com/en/Functions/a/appendOrcaStreamTable.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nappendOrcaStreamTable(name, data)\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**data** is a table object containing the data to be inserted.\n\n#### Details\n\nAppends data to an orca stream table.\n\n**Note:** This function does not support regular (non-Orca) stream tables.\n\n#### Examples\n\nInsert the snapshot table into an orca stream table.\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\n}\ngo;\nuse catalog test\n\nt = table(1..100 as id, 1..100 as value, take(09:29:00.000..13:00:00.000, 100) as timestamp)\ng = createStreamGraph(\"factor\")\nbaseStream = g.source(\"snapshot\", 1024:0, schema(t).colDefs.name, schema(t).colDefs.typeString)\n .reactiveStateEngine([, ])\n .setEngineName(\"rse\")\n .buffer(\"end\")\n \ng.submit()\n\nappendOrcaStreamTable(\"snapshot\", t)\n// Be equivalent to appendOrcaStreamTable(\"test.orca_table.snapshot\", t)\n```\n\nWe can verify the inserted data with a SQL query like `SELECT * FROM .orca_table.`. The `` part is optional—if omitted, the system will use the current catalog automatically.\n\n```\nselect * from orca_table.end\n```\n\n| cumsum\\_value | timestamp |\n| ------------- | ------------ |\n| 1 | 09:29:00.000 |\n| 3 | 09:29:00.001 |\n| 6 | 09:29:00.002 |\n| 10 | 09:29:00.003 |\n| 15 | 09:29:00.004 |\n| 21 | 09:29:00.005 |\n| 28 | 09:29:00.006 |\n| 36 | 09:29:00.007 |\n| 45 | 09:29:00.008 |\n| 55 | 09:29:00.009 |\n| … | … |\n" }, "appendTuple!": { "url": "https://docs.dolphindb.com/en/Functions/a/appendtuple.html", "signatures": [ { "full": "appendTuple!(X, Y, [wholistic=false])", "name": "appendTuple!", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" }, { "full": "[wholistic=false]", "name": "wholistic", "optional": true, "default": "false" } ] } ], "markdown": "### [appendTuple!](https://docs.dolphindb.com/en/Functions/a/appendtuple.html)\n\n\n\n#### Syntax\n\nappendTuple!(X, Y, \\[wholistic=false])\n\n#### Parameters\n\n**X** is a tuple.\n\n**Y** is a tuple.\n\n**wholistic** is a Boolean. The default value is false.\n\n#### Details\n\nAppend *Y* to *X*:\n\n* If *wholistic* = true, *Y* is appended as one tuple element;\n\n* If *wholistic*= false, each element of *Y* is appended independently.\n\nIf *X* is a columnar tuple, *wholistic* must be set to false, and the elements of *Y* must have the same data type as those of *X*.\n\n#### Examples\n\n```language-python\n$ x = (1,\"X\")\n$ y = ([2,3],\"Y\")\n$ x.appendTuple!(y,true)\n$ print(x)\n// output: (1,\"X\",([2,3],\"Y\"))\n\n$ x.appendTuple!(y,false)\n$ print(x)\n// output: (1,\"X\",([2,3],\"Y\"),[2,3],\"Y\")\n\n$ x = [[1,2,3],4]\n$ x.setColumnarTuple!()\n$ x.appendTuple!((5,6),false)\n$ print(x)\n// output: ([1,2,3],4,5,6)\n```\n" }, "appendEvent": { "url": "https://docs.dolphindb.com/en/Functions/a/append_event.html", "signatures": [ { "full": "appendEvent(engine, events)", "name": "appendEvent", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "events", "name": "events" } ] } ], "markdown": "### [appendEvent](https://docs.dolphindb.com/en/Functions/a/append_event.html)\n\n\n\n#### Syntax\n\nappendEvent(engine, events)\n\n#### Details\n\nThe `appendEvent` function allows direct event appending to event input queue, avoiding serialization and deserialization compared to writing data through heterogeneous tables.\n\n#### Parameters\n\n**engine**is the engine object returned by `createCEPEngine` or `streamEventSerializer`.\n\n**events**is a class object of the event instance or a dictionary. If it is a dictionary, the event instances will be automatically constructed with the key-value pairs provided. The keys of the dictionary must include the event type (specified with *eventSchema*) and all of its event fields.\n\n#### Examples\n\nDefine an event Orders contianing the following fields: sym, val0, val1, and val2.\n\n```\nclass Orders{\n eventTime :: TIMESTAMP \n sym :: STRING\n val0 :: INT\n val1 :: FLOAT\n val2 :: DOUBLE\n def Orders(s,v0,v1,v2){\n sym = s\n val0 = v0\n val1 = v1\n val2 = v2\n eventTime = now()\n }\n}\n```\n\nDefined a monitor:\n\n```\nclass mainMonitor:CEPMonitor {\n ordersTable :: ANY \n def mainMonitor(){\n ordersTable = array(ANY, 0) \n } \n\n def updateOrders(event) {\n ordersTable.append!([event.sym, event.val0, event.val1, event.val2])\n }\n def onload(){\n addEventListener(updateOrders, 'Orders',,'all') \n }\n}\n```\n\nCreate a CEP engine:\n\n```\ndummy = table(array(TIMESTAMP, 0) as eventTime,array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\nengine=createCEPEngine(name=\"test_CEP\",monitors=,dummyTable=dummy,eventSchema=Orders,timeColumn='eventTime')\n```\n\nAppend events to the engine:\n\n* *events* is specified as an instance of an event:\n\n ```\n appendEvent(`test_CEP,Orders(\"a000\", 3, 3.0, 30.0))\n ```\n\n* *events* is specified as a dictionary:\n\n ```\n d=dict(['eventType',\"sym\", \"val0\",\"val1\", \"val2\", \"eventTime\"],[\"Orders\",'a000',5,float(3.6),double(29.3),2025.09.24T11:35:22.789])\n appendEvent(`test_CEP,d)\n ```\n\n**Related function:** [addEventListener](https://docs.dolphindb.com/en/Functions/a/add_event_listener.html), [createCEPEngine](https://docs.dolphindb.com/en/Functions/c/create_cep_engine.html), [emitEvent](https://docs.dolphindb.com/en/Functions/e/emit_event.html), [routeEvent](https://docs.dolphindb.com/en/Functions/r/route_event.html), [sendEvent](https://docs.dolphindb.com/en/Functions/s/send_event.html)\n" }, "arima": { "url": "https://docs.dolphindb.com/en/Functions/a/arima.html", "signatures": [ { "full": "arima(ds, endogColName, order, [seasonalOrder], [exog], [trend], [enforceStationarity=true], [enforceInvertibility=true], [concentrateScale=false], [trendOffset=1])", "name": "arima", "parameters": [ { "full": "ds", "name": "ds" }, { "full": "endogColName", "name": "endogColName" }, { "full": "order", "name": "order" }, { "full": "[seasonalOrder]", "name": "seasonalOrder", "optional": true }, { "full": "[exog]", "name": "exog", "optional": true }, { "full": "[trend]", "name": "trend", "optional": true }, { "full": "[enforceStationarity=true]", "name": "enforceStationarity", "optional": true, "default": "true" }, { "full": "[enforceInvertibility=true]", "name": "enforceInvertibility", "optional": true, "default": "true" }, { "full": "[concentrateScale=false]", "name": "concentrateScale", "optional": true, "default": "false" }, { "full": "[trendOffset=1]", "name": "trendOffset", "optional": true, "default": "1" } ] } ], "markdown": "### [arima](https://docs.dolphindb.com/en/Functions/a/arima.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\narima(ds, endogColName, order, \\[seasonalOrder], \\[exog], \\[trend], \\[enforceStationarity=true], \\[enforceInvertibility=true], \\[concentrateScale=false], \\[trendOffset=1])\n\n#### Parameters\n\n**ds** is an in-memory table or a list of data sources containing the univariate time series data for analysis.\n\n**endogColName** is a string specifying the column name in *ds* that contains the univariate time series to be analyzed.\n\n**order** is a vector of three non-negative integers representing the (p,d,q) order of the ARIMA model for the autoregressive (AR), differences, and moving average (MA) components.\n\n**seasonalOrder** (optional) is a vector of four non-negative integers representing the (P, D, Q, s) order of the seasonal ARIMA model for the AR parameters, differences, MA parameters, and periodicity. The default value is \\[0, 0, 0, 0], indicating no seasonality.\n\n**exog** (optional) is a numerical matrix representing exogenous variables. Each column of the matrix represents the time series data of an exogenous variable, and the number of rows must equal the number of rows in *ds*.\n\n**trend** (optional) is a string used to control the deterministic trend. It can be\n\n* 'n' - no constant or trend (default if *d* > 0 or D > 0)\n* 'c' - only constant (default if *d* = 0 and D = 0)\n* 't' - only linear trend\n* 'ct' - constant and linear trend\n\n**enforceStationarity**(optional) is a boolean scalar indicating whether to enforce stationarity on the AR component. The default value is true.\n\n**enforceInvertibility**(optional) is a boolean scalar indicating whether to enforce invertibility on the MA component. The default value is true.\n\n**concentrateScale**(optional) is a boolean scalar indicating whether to concentrate the scale (variance of the error term) out of the likelihood, which reduces the number of estimated parameters by one. Applicable only when considering estimation by numerical maximum likelihood. The default value is false.\n\n**trendOffset** (optional) is an integer specifying the offset at which to start time trend values. The default value is 1, so if *trend*='t', the trend values will be 1, 2, ..., nobs.\n\n**maxIter**(optional) is a positive integer indicating the maximum number of iterations. The default value is 500.\n\n#### Details\n\nThe Autoregressive Integrated Moving Average (ARIMA) model is used to analyze univariate time series, which consists of three main components: autoregressive (AR), integrated (I), and moving average (MA).\n\nThe `arima` function is used for ARIMA-like modeling and can be used to construct the following time series analysis models:\n\n* Autoregressive model, *AR*: Captures the relationship between data and its historical values.\n* Moving Average model, *MA*: Focuses on handling random fluctuations.\n* Autoregressive Moving Average model, *ARMA*: Combines AR and MA components.\n* Autoregressive Integrated Moving Average model,*ARIMA*\n* Seasonal model, *SARIMA*: Handles data with periodic patterns.\n* Regression with errors, *ARIMAX*: Incorporates external regressors with error terms modeled by ARIMA-like structures.\n\n**Return value**: A dictionary representing the analysis results of the ARIMA model with the following keys:\n\n* params: A vector of floating-point numbers representing the parameters estimated by the ARIMA model.\n* llf: A floating-point scalar representing the log-likelihood value of the ARIMA model.\n* aic: A floating-point scalar representing the Akaike Information Criterion.\n* bic: A floating-point scalar representing the Bayesian Information Criterion.\n* hqic: A floating-point scalar representing the Hannan-Quinn Information Criterion.\n\n#### Examples\n\nThe following script uses quarterly economic indicator data from 1959 to 2009 to fit an ARIMA model to real GDP (`realgdp`). Based on analysis, it is assumed that the appropriate model is ARIMA(1,0,0), meaning an autoregressive model with order 1, no differencing, and no moving average component.\n\n```\ndata = loadText(\"./macrodata.csv\")\nres = arima(data, \"realgdp\", [1,0,0]);\nres;\n/* \nparams->[0.007795600187477,0.306055792984419,0.000069811276429]\nllf->679.783769203580163\naic->-1353.567538407160327\nbic->-1343.64273531495678\nhqic->-1349.551945119058927\n*/\n```\n\n[macrodata.csv](https://docs.dolphindb.com/en/Functions/resources/arima/macrodata.csv)\n" }, "array": { "url": "https://docs.dolphindb.com/en/Functions/a/array.html", "signatures": [ { "full": "array(dataType|template, [initialSize], [capacity], [defaultValue])", "name": "array", "parameters": [ { "full": "dataType|template", "name": "dataType|template" }, { "full": "[initialSize]", "name": "initialSize", "optional": true }, { "full": "[capacity]", "name": "capacity", "optional": true }, { "full": "[defaultValue]", "name": "defaultValue", "optional": true } ] } ], "markdown": "### [array](https://docs.dolphindb.com/en/Functions/a/array.html)\n\n\n\n#### Syntax\n\narray(dataType|template, \\[initialSize], \\[capacity], \\[defaultValue])\n\n#### Parameters\n\n**dataType** is the data type for the vector.\n\n**template** is an existing vector. The existing vector serves as a template and its data type determines the new vector's data type.\n\n**initialSize** (optional) is the initial size (in terms of the number of elements) of the vector.\n\n**capacity** (optional) is the amount of memory (in terms of the number of elements) allocated to the array. When the number of elements exceeds capacity, the system will first allocate memory of 1.2\\~2 times of capacity, copy the data to the new memory space, and release the original memory.\n\n**defaultValue** (optional) is the default value of the vector. It must be a scalar. If *defaultValue* is not specified, it defaults to NULL for STRING and SYMBOL values, and 0 for other data types.\n\n#### Details\n\nReturn a vector.\n\nDifferences from Python’s `numpy.array` and `pandas.array`: `numpy.array` converts *object* to an ndarray and can infer or specify *dtype*, dimensions, memory order, and copy behavior. `pandas.array` creates a pandas ExtensionArray from a sequence, focusing on nullable/extension *dtype* inference. DolphinDB’s `array` creates a DolphinDB vector by a specified data type or template and can specify *initialSize*, *capacity*, and *defaultValue*.\n\n#### Examples\n\n```\nx=array(int, 10, 100, 1) // initial size is 10; capacity is 100; default value is 1\nx\n// output: [1,1,1,1,1,1,1,1,1,1]\n\nx=array(int, 0) // initialize an empty vector\nx\n// output: []\n\nx.append!(1..10)\n// output: [1,2,3,4,5,6,7,8,9,10]\n\ny=array(x)\ny\n// output: [0,0,0,0,0,0,0,0,0,0]\n\nsyms=array(symbol, 0, 100) // an empty symbol vector with capacity of 100\ntypestr syms\n// output: FAST SYMBOL VECTOR\n```\n" }, "arrayVector": { "url": "https://docs.dolphindb.com/en/Functions/a/arrayVector.html", "signatures": [ { "full": "arrayVector(index, value)", "name": "arrayVector", "parameters": [ { "full": "index", "name": "index" }, { "full": "value", "name": "value" } ] } ], "markdown": "### [arrayVector](https://docs.dolphindb.com/en/Functions/a/arrayVector.html)\n\n\n\n#### Syntax\n\narrayVector(index, value)\n\n#### Parameters\n\n**index** is a vector of positive integers, which must be strictly monotonically increasing.\n\n**value** is a vector. Its data type must be supported by [arrayVector](https://docs.dolphindb.com/en/Programming/DataTypesandStructures/DataForms/Vector/arrayVector.html)\n\n#### Details\n\nConvert *value* into an array vector by spliting it based on the elements in *index*. The number of elements in *index* indicates the number of rows of array vector. Each element in *index* corresponds to the position in *value* (starting from 1), which is the last element of each new vector. See how an array vector is converted in the following figure:\n\n![](https://docs.dolphindb.com/en/images/arrayVector01.png)\n\nNote: The maximum value in *index* can be no greater than the length of *value*.\n\n#### Examples\n\n```\narrayVector(2 3 4, [1,2,3,4])\n// output: [[1,2],[3],[4]]\n\narrayVector(1 4 7, [1.0,2.1,4.1,6.8,0.5,2.2,2])\n// output: [[1],[2.1,4.1,6.8],[0.5,2.2,2]]\n\nvalue = 2022.01.01 + 0..20\nindex = 7 14 21\narrayVector(index, value)\n// output: [[2022.01.01,2022.01.02,2022.01.03,2022.01.04,2022.01.05,2022.01.06,2022.01.07],[2022.01.08,2022.01.09,2022.01.10,2022.01.11,2022.01.12,2022.01.13,2022.01.14],[2022.01.15,2022.01.16,2022.01.17,2022.01.18,2022.01.19,2022.01.20,2022.01.21]]\n```\n\nRelated function: [fixedLengthArrayVector](https://docs.dolphindb.com/en/Functions/f/fixedLengthArrayVector.html)\n" }, "asFreq": { "url": "https://docs.dolphindb.com/en/Functions/a/asFreq.html", "signatures": [ { "full": "asFreq(X, rule, [closed], [label], [origin='start_day'])", "name": "asFreq", "parameters": [ { "full": "X", "name": "X" }, { "full": "rule", "name": "rule" }, { "full": "[closed]", "name": "closed", "optional": true }, { "full": "[label]", "name": "label", "optional": true }, { "full": "[origin='start_day']", "name": "origin", "optional": true, "default": "'start_day'" } ] } ], "markdown": "### [asFreq](https://docs.dolphindb.com/en/Functions/a/asFreq.html)\n\n\n\n#### Syntax\n\nasFreq(X, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\nAlias: asfreq\n\n#### Parameters\n\n**X** is an indexed matrix or indexed series. The index must be of temporal type.\n\n**rule** is a string that can take the following values:\n\n| Value of *rule* | Corresponding DolphinDB function |\n| --------------- | -------------------------------- |\n| \"B\" | businessDay |\n| \"W\" | weekEnd |\n| \"WOM\" | weekOfMonth |\n| \"LWOM\" | lastWeekOfMonth |\n| \"M\" | monthEnd |\n| \"MS\" | monthBegin |\n| \"BM\" | businessMonthEnd |\n| \"BMS\" | businessMonthBegin |\n| \"SM\" | semiMonthEnd |\n| \"SMS\" | semiMonthBegin |\n| \"Q\" | quarterEnd |\n| \"QS\" | quarterBegin |\n| \"BQ\" | businessQuarterEnd |\n| \"BQS\" | businessQuarterBegin |\n| \"REQ\" | FY5253Quarter |\n| \"A\" | yearEnd |\n| \"AS\" | yearBegin |\n| \"BA\" | businessYearEnd |\n| \"BAS\" | businessYearBegin |\n| \"RE\" | FY5253 |\n| \"D\" | date |\n| \"H\" | hourOfDay |\n| \"min\" | minuteOfHour |\n| \"S\" | secondOfMinute |\n| \"L\" | millisecond |\n| \"U\" | microsecond |\n| \"N\" | nanosecond |\n| \"SA\" | semiannualEnd |\n| \"SAS\" | semiannualBegin |\n\nThe strings above can also be used with positive integers for parameter *rule*. For example, \"2M\" means the end of every two months. In addition, *rule* can also be set as the identifier of the trading calendar, e.g., the Market Identifier Code of an exchange, or a user-defined calendar name. Positive integers can also be used with identifiers. For example, \"2XNYS\" means every two trading days of New York Stock Exchange.\n\n*rule* can also be a vector of temporal type.\n\n**closed** is a string indicating which boundary of the interval is closed.\n\n* The default value is 'left' for all values of *rule* except for 'M', 'A', 'Q', 'BM', 'BA', 'BQ', and 'W' which all have a default of 'right'.\n\n* The default is 'right' if *origin* is 'end' or 'end\\_day'.\n\n**label** is a string indicating which boundary is used to label the interval.\n\n* The default value is 'left' for all values of *rule* except for 'M', 'A', 'Q', 'BM', 'BA', 'BQ', and 'W' which all have a default of 'right'.\n\n* The default is 'right' if *origin* is 'end' or 'end\\_day'.\n\n**origin** is a string or a scalar of the same data type as *X*, indicating the timestamp where the intervals start. It can be 'epoch', start', 'start\\_day', 'end', 'end\\_day' or a user-defined time object. The default value is 'start\\_day'.\n\n* 'epoch': *origin* is 1970-01-01\n\n* 'start': *origin* is the first value of the timeseries\n\n* 'start\\_day': *origin* is 00:00 of the first day of the timeseries\n\n* 'end': *origin* is the last value of the timeseries\n\n* 'end\\_day': *origin* is 24:00 of the last day of the timeseries\n\n#### Details\n\nConvert *X* to specified frequency. Different from [resample](https://docs.dolphindb.com/en/Functions/r/resample.html), aggregate functions cannot be used in `asfreq`.\n\n#### Examples\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.31, 2000.04.16, 2000.05.06, 2000.08.31]\ns = indexedSeries(index, 1..8)\ns\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.01 | 1 |\n| 2000.01.31 | 2 |\n| 2000.02.15 | 3 |\n| 2000.02.20 | 4 |\n| 2000.03.31 | 5 |\n| 2000.04.16 | 6 |\n| 2000.05.06 | 7 |\n| 2000.08.31 | 8 |\n\n```\ns.asfreq(\"M\") // M = monthEnd\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.02.29 | |\n| 2000.03.31 | 5 |\n| 2000.04.30 | |\n| 2000.05.31 | |\n| 2000.06.30 | |\n| 2000.07.31 | |\n| 2000.08.31 | 8 |\n\n```\ns.asfreq(\"2M\") // 2M = every 2 months month-end\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.03.31 | 5 |\n| 2000.05.31 | |\n| 2000.07.31 | |\n\n```\nindex = [2020.01.01, 2020.01.03, 2020.01.06]\ns = indexedSeries(index, 1..3)\ns\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.06 | 3 |\n\n```\ns.asfreq(\"D\") // D = date\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.02 | |\n| 2020.01.03 | 2 |\n| 2020.01.04 | |\n| 2020.01.05 | |\n| 2020.01.06 | 3 |\n\n```\ns.asfreq(\"2D\") // 2D = every 2 days\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.05 | |\n\n```\nindex = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)\ns = indexedSeries(index, 3*(0..8))\ns.asfreq(\"8min\") // Convert to 8-minute frequency, with closed=`left by default (left-closed right-open)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:28:00 | |\n| 2022.10.01T23:36:00 | |\n| 2022.10.01T23:44:00 | 6 |\n| 2022.10.01T23:52:00 | |\n| 2022.10.02T00:00:00 | |\n| 2022.10.02T00:08:00 | |\n| 2022.10.02T00:16:00 | |\n| 2022.10.02T00:24:00 | |\n\n```\n// Set closed=`right for left-open right-closed interval\ns.asfreq(rule=`8min,closed=`right)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:36:00 | |\n| 2022.10.01T23:44:00 | 6 |\n| 2022.10.01T23:52:00 | |\n| 2022.10.02T00:00:00 | |\n| 2022.10.02T00:08:00 | |\n| 2022.10.02T00:16:00 | |\n| 2022.10.02T00:24:00 | |\n| 2022.10.02T00:32:00 | |\n\n```\n// Set origin=`end to align backward from the last time point\ns.asfreq(rule=`8min,closed=`right,origin=`end)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:30:00 | 0 |\n| 2022.10.01T23:38:00 | |\n| 2022.10.01T23:46:00 | |\n| 2022.10.01T23:54:00 | |\n| 2022.10.02T00:02:00 | |\n| 2022.10.02T00:10:00 | |\n| 2022.10.02T00:18:00 | |\n| 2022.10.02T00:26:00 | 24 |\n\n```\n// Set label=`right to label the right boundary of the interval, with closed=`left by default\ns.asFreq(rule=`8min,label=`right)\n```\n\n| label | 0 |\n| ------------------- | - |\n| 2022.10.01 23:36:00 |   |\n| 2022.10.01 23:44:00 | 6 |\n| 2022.10.01 23:52:00 |   |\n| 2022.10.02 00:00:00 |   |\n| 2022.10.02 00:08:00 |   |\n| 2022.10.02 00:16:00 |   |\n| 2022.10.02 00:24:00 |   |\n| 2022.10.02 00:32:00 |   |\n" }, "asfreq": { "url": "https://docs.dolphindb.com/en/Functions/a/asfreq1.html", "signatures": [ { "full": "asFreq(X, rule, [closed], [label], [origin='start_day'])", "name": "asFreq", "parameters": [ { "full": "X", "name": "X" }, { "full": "rule", "name": "rule" }, { "full": "[closed]", "name": "closed", "optional": true }, { "full": "[label]", "name": "label", "optional": true }, { "full": "[origin='start_day']", "name": "origin", "optional": true, "default": "'start_day'" } ] } ], "markdown": "### [asfreq](https://docs.dolphindb.com/en/Functions/a/asfreq1.html)\n\nAlias for [asFreq](https://docs.dolphindb.com/en/Functions/a/asFreq.html)\n\n\nDocumentation for the `asFreq` function:\n### [asFreq](https://docs.dolphindb.com/en/Functions/a/asFreq.html)\n\n\n\n#### Syntax\n\nasFreq(X, rule, \\[closed], \\[label], \\[origin='start\\_day'])\n\nAlias: asfreq\n\n#### Parameters\n\n**X** is an indexed matrix or indexed series. The index must be of temporal type.\n\n**rule** is a string that can take the following values:\n\n| Value of *rule* | Corresponding DolphinDB function |\n| --------------- | -------------------------------- |\n| \"B\" | businessDay |\n| \"W\" | weekEnd |\n| \"WOM\" | weekOfMonth |\n| \"LWOM\" | lastWeekOfMonth |\n| \"M\" | monthEnd |\n| \"MS\" | monthBegin |\n| \"BM\" | businessMonthEnd |\n| \"BMS\" | businessMonthBegin |\n| \"SM\" | semiMonthEnd |\n| \"SMS\" | semiMonthBegin |\n| \"Q\" | quarterEnd |\n| \"QS\" | quarterBegin |\n| \"BQ\" | businessQuarterEnd |\n| \"BQS\" | businessQuarterBegin |\n| \"REQ\" | FY5253Quarter |\n| \"A\" | yearEnd |\n| \"AS\" | yearBegin |\n| \"BA\" | businessYearEnd |\n| \"BAS\" | businessYearBegin |\n| \"RE\" | FY5253 |\n| \"D\" | date |\n| \"H\" | hourOfDay |\n| \"min\" | minuteOfHour |\n| \"S\" | secondOfMinute |\n| \"L\" | millisecond |\n| \"U\" | microsecond |\n| \"N\" | nanosecond |\n| \"SA\" | semiannualEnd |\n| \"SAS\" | semiannualBegin |\n\nThe strings above can also be used with positive integers for parameter *rule*. For example, \"2M\" means the end of every two months. In addition, *rule* can also be set as the identifier of the trading calendar, e.g., the Market Identifier Code of an exchange, or a user-defined calendar name. Positive integers can also be used with identifiers. For example, \"2XNYS\" means every two trading days of New York Stock Exchange.\n\n*rule* can also be a vector of temporal type.\n\n**closed** is a string indicating which boundary of the interval is closed.\n\n* The default value is 'left' for all values of *rule* except for 'M', 'A', 'Q', 'BM', 'BA', 'BQ', and 'W' which all have a default of 'right'.\n\n* The default is 'right' if *origin* is 'end' or 'end\\_day'.\n\n**label** is a string indicating which boundary is used to label the interval.\n\n* The default value is 'left' for all values of *rule* except for 'M', 'A', 'Q', 'BM', 'BA', 'BQ', and 'W' which all have a default of 'right'.\n\n* The default is 'right' if *origin* is 'end' or 'end\\_day'.\n\n**origin** is a string or a scalar of the same data type as *X*, indicating the timestamp where the intervals start. It can be 'epoch', start', 'start\\_day', 'end', 'end\\_day' or a user-defined time object. The default value is 'start\\_day'.\n\n* 'epoch': *origin* is 1970-01-01\n\n* 'start': *origin* is the first value of the timeseries\n\n* 'start\\_day': *origin* is 00:00 of the first day of the timeseries\n\n* 'end': *origin* is the last value of the timeseries\n\n* 'end\\_day': *origin* is 24:00 of the last day of the timeseries\n\n#### Details\n\nConvert *X* to specified frequency. Different from [resample](https://docs.dolphindb.com/en/Functions/r/resample.html), aggregate functions cannot be used in `asfreq`.\n\n#### Examples\n\n```\nindex = [2000.01.01, 2000.01.31, 2000.02.15, 2000.02.20, 2000.03.31, 2000.04.16, 2000.05.06, 2000.08.31]\ns = indexedSeries(index, 1..8)\ns\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.01 | 1 |\n| 2000.01.31 | 2 |\n| 2000.02.15 | 3 |\n| 2000.02.20 | 4 |\n| 2000.03.31 | 5 |\n| 2000.04.16 | 6 |\n| 2000.05.06 | 7 |\n| 2000.08.31 | 8 |\n\n```\ns.asfreq(\"M\") // M = monthEnd\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.02.29 | |\n| 2000.03.31 | 5 |\n| 2000.04.30 | |\n| 2000.05.31 | |\n| 2000.06.30 | |\n| 2000.07.31 | |\n| 2000.08.31 | 8 |\n\n```\ns.asfreq(\"2M\") // 2M = every 2 months month-end\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2000.01.31 | 2 |\n| 2000.03.31 | 5 |\n| 2000.05.31 | |\n| 2000.07.31 | |\n\n```\nindex = [2020.01.01, 2020.01.03, 2020.01.06]\ns = indexedSeries(index, 1..3)\ns\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.06 | 3 |\n\n```\ns.asfreq(\"D\") // D = date\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.02 | |\n| 2020.01.03 | 2 |\n| 2020.01.04 | |\n| 2020.01.05 | |\n| 2020.01.06 | 3 |\n\n```\ns.asfreq(\"2D\") // 2D = every 2 days\n```\n\n| lable | 0 |\n| ---------- | - |\n| 2020.01.01 | 1 |\n| 2020.01.03 | 2 |\n| 2020.01.05 | |\n\n```\nindex = temporalAdd(2022.10.01 23:30:00,7*(0..8),`m)\ns = indexedSeries(index, 3*(0..8))\ns.asfreq(\"8min\") // Convert to 8-minute frequency, with closed=`left by default (left-closed right-open)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:28:00 | |\n| 2022.10.01T23:36:00 | |\n| 2022.10.01T23:44:00 | 6 |\n| 2022.10.01T23:52:00 | |\n| 2022.10.02T00:00:00 | |\n| 2022.10.02T00:08:00 | |\n| 2022.10.02T00:16:00 | |\n| 2022.10.02T00:24:00 | |\n\n```\n// Set closed=`right for left-open right-closed interval\ns.asfreq(rule=`8min,closed=`right)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:36:00 | |\n| 2022.10.01T23:44:00 | 6 |\n| 2022.10.01T23:52:00 | |\n| 2022.10.02T00:00:00 | |\n| 2022.10.02T00:08:00 | |\n| 2022.10.02T00:16:00 | |\n| 2022.10.02T00:24:00 | |\n| 2022.10.02T00:32:00 | |\n\n```\n// Set origin=`end to align backward from the last time point\ns.asfreq(rule=`8min,closed=`right,origin=`end)\n```\n\n| label | col1 |\n| ------------------- | ---- |\n| 2022.10.01T23:30:00 | 0 |\n| 2022.10.01T23:38:00 | |\n| 2022.10.01T23:46:00 | |\n| 2022.10.01T23:54:00 | |\n| 2022.10.02T00:02:00 | |\n| 2022.10.02T00:10:00 | |\n| 2022.10.02T00:18:00 | |\n| 2022.10.02T00:26:00 | 24 |\n\n```\n// Set label=`right to label the right boundary of the interval, with closed=`left by default\ns.asFreq(rule=`8min,label=`right)\n```\n\n| label | 0 |\n| ------------------- | - |\n| 2022.10.01 23:36:00 |   |\n| 2022.10.01 23:44:00 | 6 |\n| 2022.10.01 23:52:00 |   |\n| 2022.10.02 00:00:00 |   |\n| 2022.10.02 00:08:00 |   |\n| 2022.10.02 00:16:00 |   |\n| 2022.10.02 00:24:00 |   |\n| 2022.10.02 00:32:00 |   |\n" }, "asin": { "url": "https://docs.dolphindb.com/en/Functions/a/asin.html", "signatures": [ { "full": "asin(X)", "name": "asin", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [asin](https://docs.dolphindb.com/en/Functions/a/asin.html)\n\n\n\n#### Syntax\n\nasin(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse sine (arcsine) function.\n\nDolphinDB `sine` and TA-Lib `ASIN` are mathematically identical in semantic meaning. The difference is that TA-Lib’s `ASIN` is a Math Transform function whose inputs and outputs are primarily one-dimensional arrays, whereas DolphinDB’s `sine` can operate on scalars, vectors, matrices, or tables, and preserves the structure of the input data.\n\n#### Examples\n\n```\nasin(0 0.5 1);\n// output: [0,0.523599,1.570796]\n```\n\nRelated functions: [acos](https://docs.dolphindb.com/en/Functions/a/acos.html), [atan](https://docs.dolphindb.com/en/Functions/a/atan.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html), [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html), [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "asinh": { "url": "https://docs.dolphindb.com/en/Functions/a/asinh.html", "signatures": [ { "full": "asinh(X)", "name": "asinh", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html)\n\n\n\n#### Syntax\n\nasinh(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse hyperbolic sine function.\n\n#### Examples\n\n```\nasinh(0.841471 0.909297 0.141120);\n// output: [0.764725,0.815761,0.140656]\n```\n\nRelated functions: [asin](https://docs.dolphindb.com/en/Functions/a/asin.html), [acos](https://docs.dolphindb.com/en/Functions/a/acos.html), [atan](https://docs.dolphindb.com/en/Functions/a/atan.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html), [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "asis": { "url": "https://docs.dolphindb.com/en/Functions/a/asis.html", "signatures": [ { "full": "asis(obj)", "name": "asis", "parameters": [ { "full": "obj", "name": "obj" } ] } ], "markdown": "### [asis](https://docs.dolphindb.com/en/Functions/a/asis.html)\n\n\n\n#### Syntax\n\nasis(obj)\n\n#### Parameters\n\n**obj** can be of any data type.\n\n#### Details\n\nReturn a reference of *obj*.\n\n#### Examples\n\n```\na = 1 2 3\nb = asis(a)\na[0] = 0\nb\n// output: [0, 2, 3]\n\nb[1] = 4\na;\n// output: [0, 4, 3]\n```\n\nRelated Functions: [copy](https://docs.dolphindb.com/en/Functions/c/copy.html), [deepCopy](https://docs.dolphindb.com/en/Functions/d/deepCopy.html)\n" }, "asof": { "url": "https://docs.dolphindb.com/en/Functions/a/asof.html", "signatures": [ { "full": "asof(X, Y)", "name": "asof", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [asof](https://docs.dolphindb.com/en/Functions/a/asof.html)\n\n\n\n#### Syntax\n\nasof(X, Y)\n\n#### Parameters\n\n**X** must be a vector sorted in ascending order, or an indexed series/matrix whose row index is sorted in ascending order.\n\n**Y** is a scalar/vector/tuple/matrix/dictionary/table/array vector. If *X* is an indexed series/matrix, *Y* must be a vector.\n\n#### Details\n\nIf *X* is a vector, for each element y in *Y*, return the index of the last element in *X* that is no greater than y. If nothing is found, return -1.\n\nIf *X* is an indexed series/matrix, for each element y in *Y*, search the row index of *X* for the last index no greater than y, and return the data in the corresponding row. If no row index is found, return NULL.\n\n**Return value**: If *X* is a vector, the result is INT and has the same form as *Y*. If *X* is an indexed series, the result is an indexed series whose row index is *Y*. If *X* is an indexed matrix, the result is an indexed matrix whose row index is *Y* and column labels are the same as *X*.\n\n#### Examples\n\nExample 1. *X* is a vector.\n\n```\nasof(1..100, 60 200 -10)\n// output: [59,99,-1]\n\n0 0 0 1 1 1 1 2 2 3 asof 1\n// output: 6\n```\n\nExample 2. *X* is an indexed series.\n\n```\nindex = [2023.05.04, 2023.05.06, 2023.05.10]\ns = indexedSeries(index, 1..3)\ny = [2023.05.03, 2023.05.04, 2023.05.05, 2023.05.09, 2023.05.12]\nasof(s, y)\n```\n\n| label | #0 |\n| ---------- | -- |\n| 2023.05.03 | |\n| 2023.05.04 | 1 |\n| 2023.05.05 | 1 |\n| 2023.05.09 | 2 |\n| 2023.05.12 | 3 |\n\nExample 3. *X* is an indexed matrix.\n\n```\nindex = [2023.05.04, 2023.05.06, 2023.05.10]\nm = matrix(1..3, 11..13).rename!(index, `A`B).setIndexedMatrix!()\ny = [2023.05.03, 2023.05.04, 2023.05.05, 2023.05.09, 2023.05.12]\nasof(m, y)\n```\n\n| label | A | B |\n| ---------- | - | -- |\n| 2023.05.03 | | |\n| 2023.05.04 | 1 | 11 |\n| 2023.05.05 | 1 | 11 |\n| 2023.05.09 | 2 | 12 |\n| 2023.05.12 | 3 | 13 |\n" }, "at": { "url": "https://docs.dolphindb.com/en/Functions/a/at.html", "signatures": [ { "full": "at(X, [index])", "name": "at", "parameters": [ { "full": "X", "name": "X" }, { "full": "[index]", "name": "index", "optional": true } ] } ], "markdown": "### [at](https://docs.dolphindb.com/en/Functions/a/at.html)\n\n\n\n#### Syntax\n\nat(X, \\[index])\n\n#### Parameters\n\nIf only one parameter is specified:\n\n* **X** is a Boolean expression/vector or an integer vector.\n\nIf both parameters are specified:\n\n* **X** is a scalar/vector (including tuplesand array vectors)/matrix/table/dictionary/pair/function;\n* **index** is a Boolean expression/Boolean value/scalar/vector (including tuplesand array vectors)/pair.\n\n#### Details\n\nIn the first case:\n\n* If *X* is a Boolean expression/vector, `at` returns the indexes of the elements of *X* that are true.\n\n* If *X* is an integer vector, `at` returns a vector where each index in *X* is repeated according to its corresponding value. Its functionality is equivalent to `take(til(count(X)), X)`. For example, `at(3 0 2)` returns `[0,0,0,2,2]`. If a value at some position is non-positive, that position is skipped.\n\nIn the second case:\n\n* If *index* is a Boolean expression, `at` returns the elements in *X* that correspond to the elements in *Y* that are true. Function `at` is equivalent to brackets operator `[]`. For example, `X.at(X>3)` is equivalent to `X[X>3]`.\n\n* If *index* is a vector, `at` retrieves the elements from *X* at the positions as specified by each element of *index*.\n\n* If *index* is a tuple, each element in the tuple specifies an index into the corresponding dimension of *X*. `at` retrieves the element(s) at the specified position as specified by the indices. For example, when *X* is a matrix, *index* must be a tuple of two elements - the first element indicates the row index, and the second element indicates the column index.\n\n* If *index* is a pair like a:b, `at` returns the elements from *X* in the range \\[a,b).\n\n* If *index* is an array vector, each row of index specifies indices to retrieve from *X*. The result is an array vector with the same dimension as *index*.\n\nNote: When *index* refers to column/row index, or an index range, for elements outside the bounds of the *X* (i.e. outside of \\[0, size(X)-1]), the corresponding positions in *X* will return null values.\n\nIf *X* is a function, *index* specifies the arguments of *X*. When*index* is a tuple, each element of the tuple is passed as an argument to *X*.\n\n#### Examples\n\n```\nx = 2 3 -1 0 1\nat(x)\n// output:[0,0,1,1,1,4]\n\nx=5 7 0 4 2 3\nat(x>3)\n// output: [0,1,3] \n// at position 0, 1, and 3, x>3 is true.\n\n// compare with x>3:\nx>3;\n// output: [1,1,0,1,0,0]\n\nx[x>3]\n// output: [5,7,4]\n\nx at x>3\n// output: [5,7,4]\n\nx=5 7 0 0 0 3\nat(x==0)\n// output: [2,3,4]\n\nx[x==0]\n// output: [0,0,0]\n\nshares=500 1000 1000 600 2000\nprices=25.5 97.5 19.2 38.4 101.5\nprices[shares>800]\n// output: [97.5,19.2,101.5]\n\nprices at shares>800\n// output: [97.5,19.2,101.5]\n\nm=(1..6).reshape(2:3)\nm;\n```\n\n| 0 | 1 | 2 |\n| - | - | - |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nat(m>3)\n// output: [3,4,5]\n\nm[m>3] // equal to m at m>3\n```\n\n| col1 | col2 | col3 |\n| ---- | ---- | ---- |\n| | | 5 |\n| | 4 | 6 |\n\nNote the difference between using a vector versus a tuple for *index*:\n\n```\nm at [0,2] // locate column 0 and 2\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 5 |\n| 2 | 6 |\n\n```\nm at (0,2) // locate element at a specific column and a specific row\n// output: 5\n```\n\n```\nm at 0:2 // locate column 0 and 1\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 3 |\n| 2 | 4 |\n\nWhen *index* is an array vector:\n\n```\na = array\\(INT\\[\\], 0, 10\\).append!\\(\\[0 2 3, 0 5, 0 8 8, 9 10\\]\\)\nb =\\[1, 2, 3\\]\n\nat\\(b, a\\)\n// output: \\[\\[1,3, \\], \\[1, \\], \\[1, , \\], \\[ , \\]\\]\n\nat\\(a,a>3\\)\n// output: \\[,\\[5\\],\\[8,8\\],\\[9,10\\]\\]\n```\n\nWhen *X*is a function, and *index* is a tuple to be passed as an argument:\n\n```\nscore = (60, 70);\nat(add,score)\n//output: 130\n```\n" }, "atan": { "url": "https://docs.dolphindb.com/en/Functions/a/atan.html", "signatures": [ { "full": "atan(X)", "name": "atan", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [atan](https://docs.dolphindb.com/en/Functions/a/atan.html)\n\n\n\n#### Syntax\n\natan(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse tangent (arctan) function.\n\nDifference from Python TA-Lib’s `ATAN`: Both functions calculate the inverse tangent and return radians. TA-Lib’s `ATAN(close)` is a Math Transform function for vector input and returns an array, whereas DolphinDB’s `atan(X)` accepts a scalar, vector, matrix, or table and preserves the input form.\n\n#### Examples\n\n```\natan 0.000000 1.557408 -2.185040;\n// output: [0,1,-1.141593]\n```\n\nRelated functions: [asin](https://docs.dolphindb.com/en/Functions/a/asin.html), [acos](https://docs.dolphindb.com/en/Functions/a/acos.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html), [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html), [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "atanh": { "url": "https://docs.dolphindb.com/en/Functions/a/atanh.html", "signatures": [ { "full": "atanh(X)", "name": "atanh", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [atanh](https://docs.dolphindb.com/en/Functions/a/atanh.html)\n\n\n\n#### Syntax\n\natanh(X)\n\n#### Parameters\n\n**X** is a scalar/vector/matrix/table.\n\n#### Details\n\nThe inverse hyperbolic tangent function.\n\n#### Examples\n\n```\natanh 0.000000 0.557408 -0.185040;\n// output: [0,0.629065,-0.187196]\n```\n\nRelated functions: [asin](https://docs.dolphindb.com/en/Functions/a/asin.html), [acos](https://docs.dolphindb.com/en/Functions/a/acos.html), [atan](https://docs.dolphindb.com/en/Functions/a/atan.html), [sin](https://docs.dolphindb.com/en/Functions/s/sin.html), [cos](https://docs.dolphindb.com/en/Functions/c/cos.html), [tan](https://docs.dolphindb.com/en/Functions/t/tan.html), [asinh](https://docs.dolphindb.com/en/Functions/a/asinh.html), [acosh](https://docs.dolphindb.com/en/Functions/a/acosh.html), [sinh](https://docs.dolphindb.com/en/Functions/s/sinh.html), [cosh](https://docs.dolphindb.com/en/Functions/c/cosh.html), [tanh](https://docs.dolphindb.com/en/Functions/t/tanh.html)\n" }, "atImax": { "url": "https://docs.dolphindb.com/en/Functions/a/atImax.html", "signatures": [ { "full": "atImax(location, value)", "name": "atImax", "parameters": [ { "full": "location", "name": "location" }, { "full": "value", "name": "value" } ] } ], "markdown": "### [atImax](https://docs.dolphindb.com/en/Functions/a/atImax.html)\n\n\n\n#### Syntax\n\natImax(location, value)\n\n#### Parameters\n\n**location** and **value** are vectors/matrices/tables of the same dimensions.\n\n#### Details\n\nFind the position of the element with the largest value in *location*, and return the value of the element in the same position in *value*. If there are multiple identical maximums in *location*, return the position of the first maximum.\n\nIf *location* and *value* are matrices, conduct the aforementioned calculation with each column of *location* and the corresponding column of *value*.\n\n`atImax(location, value)` is equivalent to `value[imax(location)]`.\n\n#### Examples\n\n```\natImax(3 5 1 2, 9 7 5 3)\n// output: 7\n\nm1=matrix(9 2 1 5 6 9, 3 1 3 NULL 5 2, 2 8 1 2 3 4)\nm2=matrix(1..6, 1..6, 1..6)\natImax(m1,m2)\n// output: [1,5,2]\n```\n\nRelated functions: [imax](https://docs.dolphindb.com/en/Functions/i/imax.html), [atImin](https://docs.dolphindb.com/en/Functions/a/atImin.html)\n" }, "atImin": { "url": "https://docs.dolphindb.com/en/Functions/a/atImin.html", "signatures": [ { "full": "atImin(location, value)", "name": "atImin", "parameters": [ { "full": "location", "name": "location" }, { "full": "value", "name": "value" } ] } ], "markdown": "### [atImin](https://docs.dolphindb.com/en/Functions/a/atImin.html)\n\n\n\n#### Syntax\n\natImin(location, value)\n\n#### Parameters\n\n**location** and **value** are vectors/matrices/tables of the same dimensions.\n\n#### Details\n\nFind the position of the element with the smallest value in *location*, and return the value of the element in the same position in *value*. If there are multiple identical minimums in *location*, return the position of the first minimum.\n\nIf *location* and *value* are matrices, conduct the aforementioned calculation with each column of *location* and the corresponding column of *value*.\n\n`atImin(location, value)` is equivalent to `value[imin(location)]`.\n\n#### Examples\n\n```\natImin(3 5 1 2, 9 7 5 3)\n// output: 5\n\nm1=matrix(9 2 1 5 6 9, 3 1 3 NULL 5 2, 2 8 1 2 3 4)\nm2=matrix(1..6, 1..6, 1..6)\natImin(m1,m2)\n// output: [3,2,3]\n```\n\nRelated functions: [imin](https://docs.dolphindb.com/en/Functions/i/imin.html), [atImax](https://docs.dolphindb.com/en/Functions/a/atImax.html)\n" }, "attributeNames": { "url": "https://docs.dolphindb.com/en/Functions/a/attributeNames.html", "signatures": [ { "full": "attributeNames(obj)", "name": "attributeNames", "parameters": [ { "full": "obj", "name": "obj" } ] } ], "markdown": "### [attributeNames](https://docs.dolphindb.com/en/Functions/a/attributeNames.html)\n\n\n\n#### Syntax\n\nattributeNames(obj)\n\n#### Parameters\n\n**obj** is a class instance.\n\n#### Details\n\nGet all attributes of the class instance.\n\n**Return value**: A STRING vector.\n\n#### Examples\n\n```\nclass Person {\n\t\n\tname :: STRING\n\tage :: INT\n\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\n\np = Person(\"Sam\", 12)\nattributeNames(p)\n\n// output: [\"name\",\"age\"]\n```\n" }, "attributeTypes": { "url": "https://docs.dolphindb.com/en/Functions/a/attributeTypes.html", "signatures": [ { "full": "attributeTypes(obj)", "name": "attributeTypes", "parameters": [ { "full": "obj", "name": "obj" } ] } ], "markdown": "### [attributeTypes](https://docs.dolphindb.com/en/Functions/a/attributeTypes.html)\n\nFirst introduced in versions: 3.00.4.2, 3.00.3.2\n\n\n\n#### Syntax\n\nattributeTypes(obj)\n\n#### Details\n\nGets all attributes and corresponding types of a class or class instance.\n\n#### Parameters\n\n**obj** is a class or class instance.\n\n#### Returns\n\nA table with the following columns:\n\n* attr: The attribute name.\n* type: The data type of the attribute.\n\n#### Examples\n\n```\nclass Person {\n\tname :: STRING\n\tage :: INT\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\np1 = Person(\"Sam\", 12)\nattributeTypes(p1) // or attributeTypes(Person)\n```\n\n| attr | type |\n| ---- | ------ |\n| name | STRING |\n| age | INT |\n\n**Related functions**: [attributeNames](https://docs.dolphindb.com/en/Functions/a/attributeNames.html), [attributeValues](https://docs.dolphindb.com/en/Functions/a/attributeValues.html)\n" }, "attributeValues": { "url": "https://docs.dolphindb.com/en/Functions/a/attributeValues.html", "signatures": [ { "full": "attributeValues(obj)", "name": "attributeValues", "parameters": [ { "full": "obj", "name": "obj" } ] } ], "markdown": "### [attributeValues](https://docs.dolphindb.com/en/Functions/a/attributeValues.html)\n\n\n\n#### Syntax\n\nattributeValues(obj)\n\n#### Parameters\n\n**obj** is a class instance.\n\n#### Details\n\nGet all attributes and corresponding values of the class instance.\n\n**Return value**: A dictionary with attribute-value pairs.\n\n#### Examples\n\n```\nclass Person {\n\tname :: STRING\n\tage :: INT\n\tdef Person(name_, age_) { \n\t\tname = name_\n\t\tage = age_\n\t}\n}\np1 = Person(\"Sam\", 12)\nattributeValues(p1)\n\n/* output: \nname->Sam\nage->12\n*/\n\np2 = Person(\"Andy\", 16)\nattributeValues(p2)\n\n/* output: \nname->Andy\nage->16\n*/\n```\n" }, "autocorr": { "url": "https://docs.dolphindb.com/en/Functions/a/autocorr.html", "signatures": [ { "full": "autocorr(X, lag)", "name": "autocorr", "parameters": [ { "full": "X", "name": "X" }, { "full": "lag", "name": "lag" } ] } ], "markdown": "### [autocorr](https://docs.dolphindb.com/en/Functions/a/autocorr.html)\n\n\n\n#### Syntax\n\nautocorr(X, lag)\n\n#### Parameters\n\n**location** is a vector.\n\n**lag** is a positive integer.\n\n#### Details\n\nCalculate the autocorrelation of *X*. Note that the means of the two time series used in the calculation is the mean of *X* instead of the means of the two time series.\n\n#### Examples\n\n```\nn=10000\nx=array(double, n, n, NULL)\nx[0]=1\nr=rand(0.05, n)-0.025\nfor(i in 0:(n-1)){\n x[i+1]=-0.8*x[i]+r[i]\n}\n\nautocorr(x, 1)\n// output: -0.808343\n\nautocorr(x, 2)\n// output: 0.661018\n```\n" }, "avg": { "url": "https://docs.dolphindb.com/en/Functions/a/avg.html", "signatures": [ { "full": "avg(X)", "name": "avg", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [avg](https://docs.dolphindb.com/en/Functions/a/avg.html)\n\n\n\n#### Syntax\n\navg(X)\n\n#### Parameters\n\n**X** is a scalar/pair/vector/matrix/table.\n\n#### Details\n\nCalculate the average of *X*.\n\n* If *X* is a vector, calculate the average of *X*.\n* If *X* is a matrix, calculate the average of each column and return a vector.\n* If *X* is a table, calculate the average of each column and return a table.\n\nThe calculation skips null values.\n\n#### Examples\n\n```\navg(1 2 3 NULL)\n// output: 2\n\nm=matrix(1 2 3, 4 5 6)\nm\n```\n\n| 0 | 1 |\n| - | - |\n| 1 | 4 |\n| 2 | 5 |\n| 3 | 6 |\n\n```\navg(m)\n// output: [2,5]\n```\n" }, "backup": { "url": "https://docs.dolphindb.com/en/Functions/b/backup.html", "signatures": [ { "full": "backup(backupDir, dbPath|sqlObj, [force=false], [parallel=false], [snapshot=true], [tableName], [partition], [keyPath])", "name": "backup", "parameters": [ { "full": "backupDir", "name": "backupDir" }, { "full": "dbPath|sqlObj", "name": "dbPath|sqlObj" }, { "full": "[force=false]", "name": "force", "optional": true, "default": "false" }, { "full": "[parallel=false]", "name": "parallel", "optional": true, "default": "false" }, { "full": "[snapshot=true]", "name": "snapshot", "optional": true, "default": "true" }, { "full": "[tableName]", "name": "tableName", "optional": true }, { "full": "[partition]", "name": "partition", "optional": true }, { "full": "[keyPath]", "name": "keyPath", "optional": true } ] } ], "markdown": "### [backup](https://docs.dolphindb.com/en/Functions/b/backup.html)\n\n\n\n#### Syntax\n\nbackup(backupDir, dbPath|sqlObj, \\[force=false], \\[parallel=false], \\[snapshot=true], \\[tableName], \\[partition], \\[keyPath])\n\n#### Details\n\nBack up all or specified partitions of a distributed table. Return an integer indicating the number of partitions that have been backed up successfully. It must be executed by a logged-in user.\n\nNote:\n\n* For a database created with *chunkGranularity*='DATABASE', it can only be backed up with SQL statements.\n\n* If backup files already exist under the *backupDir*, the next backup must adopt the same method (by specifying *dbPath* or *sqlObj*). Otherwise the backup would fail.\n\n* If *backupDir*is an AWS S3 directory, the configuration file of the data node must specify *preloadModules*=plugins::awss3, and configure *s3AccessKeyId*, *s3SecretAccessKey*and *s3Region*.\n\nThe following table compares the 2 types of backup:\n\n| Feature | copying files (specifying parameter *dbPath*) | SQL statements (specifying parameter *sqlObj*) |\n| --------------------------------------------------- | --------------------------------------------- | ---------------------------------------------- |\n| back up an entire database | √ | × |\n| data consistency | fully guaranteed | partially guaranteed |\n| incremental backup of modified and added partitions | √ | √ |\n| incremental backup of deleted partitions | √ | × |\n| resume data transmission from a breakpoint | √ | × |\n| back up data with filter conditions | × | √ |\n| performance | lower memory usage | higher memory usage |\n\n#### Parameters\n\n**backupDir** is a string indicating the directory to save the backup. For an AWS S3 directory, it must begin with `s3://`.\n\n**dbPath** is a string indicating the database path. If specified, back up the database by copying partitions. If *backupDir*is an AWS S3 directory, only *dbPath*can be specified.\n\n**sqlObj** is metacode of SQL statements indicating the data to be backed up. If specified, only the queried data is backed up.\n\n**force** (optional) is a Boolean value. True means to perform a full backup, otherwise to perform an incremental backup.\n\n**parallel** (optional) is a Boolean value indicating whether to back up partitions in parallel. The default value is false.\n\nThe following parameters only take effect when *dbPath* is specified:\n\n**snapshot** (optional) is a Boolean value indicating whether to synchronize the deletion of tables/partitions to the backup database. It only takes effect when the parameter partition is empty. The default value is true, indicating the system will remove the deleted table/partitions from the backup files.\n\n**tableName** (optional) is a STRING scalar or vector indicating the name of table to be backed up. If unspecified, all tables of the database are backed up.\n\n**partition** (optional) indicates the partitions to be backed up. It can be:\n\n* a STRING scalar or vector indicating the path(s) to one or multiple partitions of a database, and each path starts with \"/\". Note that for a compo-partitioned database, the path must include all partition levels.\n\n* filter condition(s). A filter condition can be a scalar or vector where each element represents a partition.\n\n * For a single-level partitioning database, it is a scalar.\n\n * For a compo-partitioned database, it is a tuple composed of filter conditions with each element for a partition level. If a partition level has no filter condition, the corresponding element in the tuple is empty.\n\n* unspecified to indicate all partitions.\n\n**keyPath** (optional, Linux only) is a STRING scalar that specifies the path to the TDE key file used for backup encryption. If left empty, no encryption will be applied.\n\n#### Returns\n\nAn integer scalar.\n\n#### Examples\n\nCreate a DFS database *dfs\\://compoDB*\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\n\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID=database(, RANGE, 0 50 100);\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t)\n```\n\nExample 1. Back up the table pt.\n\n```\nbackup(backupDir=\"/home/DolphinDB/backup\", sqlObj=2017.08.10>, force=true);\n// output: 2\n```\n\nExample 3. Back up data in the date partition 2017.08.09 of table pt.\n\nThe database created above is a composite partitioned database: the first level is a VALUE partition on `date`, and the second level is a RANGE partition on `ID`. Here *partition* specifies the date value `2017.08.09`, so `backup` directly matches the first-level partition `20170809` and backs up all its second-level partitions, i.e., `/20170809/0_50` and `/20170809/50_100`. It does not filter rows by date during backup.\n\n```\nbackup(backupDir=\"/home/DolphinDB/backup\", dbPath=\"dfs://compoDB\", force=true, tableName=`pt, partition=2017.08.09)\n```\n\nExample 4. Back up tables in a database.\n\n(1) Back up tables\n\n```\n// create table pt1 under database dfs://compoDB\npt1 = db.createPartitionedTable(t, `pt1, `date`ID)\npt1.append!(t)\n\n// back up 2 tables\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true);\n// output: 20\n```\n\n(2) Back up specified partitions\n\n```\n// back up 5 partitions of table pt\npartitions=[\"/20170807/0_50\",\"/20170808/0_50\",\"/20170809/0_50\",\"/20170810/0_50\",\"/20170811/0_50\"]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output: 5\n```\n\n(3) Back up partitions with filter conditions. Note that for a range domain, any value within the range can be specified to indicate the entire partition.\n\n```\n// back up the second-level partition 50_100 under the first-level partition 20170807\npartitions=[2017.08.07,50]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output: 1\n\n// back up the second-level partition 50_100 under all first-level partitions\npartitions=[,[0]]\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,tableName=`pt,partition=partitions);\n// output: 5 \n```\n\nExample 5. The following examples explains how to use the parameter *snapshot*\n\n```\n// delete partition \"/20170811/0_50\" form table pt\ndb.dropPartition(\"/20170811/0_50\",`pt)\n\n// back up again and set snapshot=false\nbackup(backupDir=\"/home/DolphinDB/backup1\",dbPath=\"dfs://compoDB\",force=true,snapshot=false,tableName=`pt);\n// output: 9\n\n// restore from the backup and you can see that partition \"/20170811/0_50\" was not deleted\nrestore(backupDir=\"/home/DolphinDB/backup1\",dbPath=\"dfs://compoDB\",tableName=`pt,partition=\"%\",force=true)\n[\"dfs://compoDB/20170807/0_50/9m9\",\"dfs://compoDB/20170807/50_100/9m9\",\"dfs://compoDB/20170808/0_50/9m9\",\"dfs://compoDB/20170808/50_100/9m9\",\"dfs://compoDB/20170809/0_50/9m9\",\"dfs://compoDB/20170809/50_100/9m9\",\"dfs://compoDB/20170810/0_50/9m9\",\"dfs://compoDB/20170810/50_100/9m9\",\"dfs://compoDB/20170811/0_50/9m9\",\"dfs://compoDB/20170811/50_100/9m9\"]\n\n//delete partition \"/20170811/0_50\" form table pt\ndb.dropPartition(\"/20170811/0_50\",`pt)\n\n// back up again and set snapshot=true\nbackup(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",force=true,snapshot=true,tableName=`pt);\n// output: 9\n \n// restore from the backup and you can see that partition \"/20170811/0_50\" was deleted\nrestore(backupDir=\"/home/DolphinDB/backup\",dbPath=\"dfs://compoDB\",tableName=`pt,partition=\"%\",force=true)\n// output: [\"dfs://compoDB/20170807/0_50/9m9\",\"dfs://compoDB/20170807/50_100/9m9\",\"dfs://compoDB/20170808/0_50/9m9\",\"dfs://compoDB/20170808/50_100/9m9\",\"dfs://compoDB/20170809/0_50/9m9\",\"dfs://compoDB/20170809/50_100/9m9\",\"dfs://compoDB/20170810/0_50/9m9\",\"dfs://compoDB/20170810/50_100/9m9\",\"dfs://compoDB/20170811/50_100/9m9\"]\n```\n\nRelated functions: [backupDB](https://docs.dolphindb.com/en/Functions/b/backupDB.html), [backupTable](https://docs.dolphindb.com/en/Functions/b/backupTable.html), [restore](https://docs.dolphindb.com/en/Functions/r/restore.html), [migrate](https://docs.dolphindb.com/en/Functions/m/migrate.html)\n" }, "backupDB": { "url": "https://docs.dolphindb.com/en/Functions/b/backupDB.html", "signatures": [ { "full": "backupDB(backupDir, dbPath, [keyPath])", "name": "backupDB", "parameters": [ { "full": "backupDir", "name": "backupDir" }, { "full": "dbPath", "name": "dbPath" }, { "full": "[keyPath]", "name": "keyPath", "optional": true } ] } ], "markdown": "### [backupDB](https://docs.dolphindb.com/en/Functions/b/backupDB.html)\n\n\n\n#### Syntax\n\nbackupDB(backupDir, dbPath, \\[keyPath])\n\n#### Details\n\nBack up the specific database to the specified directory.\n\nThe function is equivalent to `backup(backupDir, dbPath, force=false, sparallel=true, snapshot=true)`.\n\n#### Parameters\n\n**backupDir** is a string indicating the directory to save the backup.\n\n**dbPath** is a string indicating the database path.\n\n**keyPath** (optional, Linux only) is a STRING scalar that specifies the path to the TDE key file used for backup encryption. If left empty, no encryption will be applied.\n\n#### Return\n\nAn INT scalar, indicating the number of databases that were backed up.\n\n#### Examples\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n//create 2 tables\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\n// Specify the directory to store the backup data.\n// The following is an example; please modify the path as needed.\nbackupDir = \"/home/test/dolphindb/server/backup/\"\n\nbackupDB(backupDir, dbName)\n```\n\nRelated functions: [backup](https://docs.dolphindb.com/en/Functions/b/backup.html), [backupTable](https://docs.dolphindb.com/en/Functions/b/backupTable.html), [restore](https://docs.dolphindb.com/en/Functions/r/restore.html), [restoreDB](https://docs.dolphindb.com/en/Functions/r/restoreDB.html), [restoreTable](https://docs.dolphindb.com/en/Functions/r/restoreTable.html), [migrate](https://docs.dolphindb.com/en/Functions/m/migrate.html)\n" }, "backupSettings": { "url": "https://docs.dolphindb.com/en/Functions/b/backupSettings.html", "signatures": [ { "full": "backupSettings(fileName, [userPermission=true], [functionView=true])", "name": "backupSettings", "parameters": [ { "full": "fileName", "name": "fileName" }, { "full": "[userPermission=true]", "name": "userPermission", "optional": true, "default": "true" }, { "full": "[functionView=true]", "name": "functionView", "optional": true, "default": "true" } ] } ], "markdown": "### [backupSettings](https://docs.dolphindb.com/en/Functions/b/backupSettings.html)\n\n#### Syntax\n\nbackupSettings(fileName, \\[userPermission=true], \\[functionView=true])\n\n#### Details\n\nBack up all settings on users, permissions, and function views to specified directory.\n\nThis function can only be executed by an administrator on the controller. It can be used with `restoreSettings` to back up and restore user settings when migrating databases.\n\n#### Parameters\n\n**fileName**is a STRING scalar specifying the backup file path. It can be an absolute path or relative path to *\\*.\n\n**userPermission** (optional) is a Boolean scalar, indicating whether to back up user permissions. The default value is true.\n\n**functionView** (optional) is a Boolean scalar, indicating whether to back up function views. The default value is true.\n\n#### Returns\n\nA vector containing all backup user names and function views.\n\n#### Examples\n\n```\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=true, functionView=true)\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=true, functionView=false)\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=false, functionView=true)\nbackupSettings(fileName=\"/home/ddb/backup/permission.back\", userPermission=false, functionView=false)\n```\n\n**Related function**: [restoreSettings](https://docs.dolphindb.com/en/Functions/r/restoreSettings.html)\n\n" }, "backupTable": { "url": "https://docs.dolphindb.com/en/Functions/b/backupTable.html", "signatures": [ { "full": "backupTable(backupDir, dbPath, tableName, [keyPath])", "name": "backupTable", "parameters": [ { "full": "backupDir", "name": "backupDir" }, { "full": "dbPath", "name": "dbPath" }, { "full": "tableName", "name": "tableName" }, { "full": "[keyPath]", "name": "keyPath", "optional": true } ] } ], "markdown": "### [backupTable](https://docs.dolphindb.com/en/Functions/b/backupTable.html)\n\n\n\n#### Syntax\n\nbackupTable(backupDir, dbPath, tableName, \\[keyPath])\n\n#### Details\n\nBack up a table to the specified directory.\n\nThe function is equivalent to `backup(backupDir, dbPath, force=false, parallel=true, snapshot=true, tableName)`.\n\n#### Parameters\n\n**backupDir** is a string indicating the directory to save the backup.\n\n**dbPath** is a string indicating the database path.\n\n**tableName** is a string indicating the table name.\n\n**keyPath** (optional, Linux only) is a STRING scalar that specifies the path to the TDE key file used for backup encryption. If left empty, no encryption will be applied.\n\n#### Return\n\nAn INT scalar, indicating the number of tables that were backed up.\n\n#### Examples\n\n```\ndbName = \"dfs://compoDB2\"\nn=1000\nID=rand(\"a\"+string(1..10), n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10, n)\nt=table(ID, date, x)\ndb1 = database(, VALUE, 2017.08.07..2017.08.11)\ndb2 = database(, HASH,[INT, 20])\nif(existsDatabase(dbName)){\n dropDatabase(dbName)\n}\ndb = database(dbName, COMPO,[ db1,db2])\n\n//create 2 tables\npt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)\npt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)\n\nbackupTable(backupDir,dbName,`pt1)\n// output: 50\n```\n\nRelated functions: [backup](https://docs.dolphindb.com/en/Functions/b/backup.html), [backupDB](https://docs.dolphindb.com/en/Functions/b/backupDB.html), [restore](https://docs.dolphindb.com/en/Functions/r/restore.html), [restoreDB](https://docs.dolphindb.com/en/Functions/r/restoreDB.html), [restoreTable](https://docs.dolphindb.com/en/Functions/r/restoreTable.html), [migrate](https://docs.dolphindb.com/en/Functions/m/migrate.html)\n" }, "bar": { "url": "https://docs.dolphindb.com/en/Functions/b/bar.html", "signatures": [ { "full": "bar(X, interval, [closed='left'])", "name": "bar", "parameters": [ { "full": "X", "name": "X" }, { "full": "interval", "name": "interval" }, { "full": "[closed='left']", "name": "closed", "optional": true, "default": "'left'" } ] } ], "markdown": "### [bar](https://docs.dolphindb.com/en/Functions/b/bar.html)\n\n\n\n#### Syntax\n\nbar(X, interval, \\[closed='left'])\n\n#### Details\n\n`bar` can group *X* based on the length specified by *interval*. If *X* is a vector,return a vector with the same length as *X*.\n\n#### Parameters\n\n**X** is an integral/temporal scalar or vector.\n\n**interval** is an integral/DURATION type scalar greater than 0 or a vector of the same length as *X*.\n\nWhen *interval* is of type DURATION, the following time units are supported (case-sensitive): w, d, H, m, s, ms, us, ns.\n\nNote: As time units *y* and *M* are not supported in interval, to group *X* by year or month, convert the data format of *X* with function [month](https://docs.dolphindb.com/en/Functions/m/month.html) or [year](https://docs.dolphindb.com/en/Functions/y/year.html). Specify the interval as an integer for calculation. You can refer to Example 2.\n\n**closed** (optional) is a string which can take 'left' (default) or 'right', indicating whether an element of *X* that is divisible by interval is the left boundary (the first element of the group) or the right boundary (the last element of the group) of a group.\n\n* *closed* = 'left': X-(X % interval), indicating that the value with a remainder of 0 is specified as the left boundary of a group.\n\n* *closed* = 'right': iif((X % interval) == 0, X, X + (interval-(X % interval))), indicating that the value with a remainder of 0 is specified as the right boundary of a group.\n\n#### Returns\n\nAn object with the same data type and form as *X*.\n\n#### Examples\n\n```\nbar(100,3); // 100-(100%3)=100-1=99\n// output: 99\n\nbar(0..15, 3)\n// output: [0,0,0,3,3,3,6,6,6,9,9,9,12,12,12,15]\n\nx=[7,4,5,8,9,3,3,5,2,6,12,1,0,-5,32]\nbar(x, 5)\n// output: [5,0,5,5,5,0,0,5,0,5,10,0,0,-5,30]\n\nt=table(2021.01.01T01:00:00..2021.01.01T01:00:29 as time, rand(1.0, 30) as x)\nselect max(x) from t group by bar(time,5s)\n```\n\n| bar\\_time | max\\_x |\n| ------------------- | -------- |\n| 2021.01.01T01:00:00 | 0.539024 |\n| 2021.01.01T01:00:05 | 0.793327 |\n| 2021.01.01T01:00:10 | 0.958522 |\n| 2021.01.01T01:00:15 | 0.96987 |\n| 2021.01.01T01:00:20 | 0.827086 |\n| 2021.01.01T01:00:25 | 0.617353 |\n\nIn the following example, to group data by every 3 months, convert *X* with the `month` function, and specify *duration* as an integer in `bar`.\n\n```\nt=table(take(2018.01.01T01:00:00+1..10,10) join take(2018.02.01T02:00:00+1..10,10) join take(2018.03.01T08:00:00+1..10,10) join take(2018.04.01T08:00:00+1..10,10) join take(2018.05.01T08:00:00+1..10, 10) as time, rand(1.0, 50) as x)\nselect max(x) from t group by bar(month(time), 3);\n```\n\n| bar | max\\_x |\n| -------- | ------ |\n| 2018.01M | 0.9868 |\n| 2018.04M | 0.9243 |\n\nThe following example groups data by week and calculates the maximum values for each week. Depending on parameter *closed*, the results are different.\n\n```\nt=table(2022.01.01 + 1..20 as time, rand(100, 20) as x)\n```\n\n| time | x |\n| ---------- | -- |\n| 2022.01.02 | 6 |\n| 2022.01.03 | 29 |\n| 2022.01.04 | 71 |\n| 2022.01.05 | 56 |\n| 2022.01.06 | 93 |\n| 2022.01.07 | 34 |\n| 2022.01.08 | 77 |\n| 2022.01.09 | 18 |\n| 2022.01.10 | 62 |\n| 2022.01.11 | 33 |\n| 2022.01.12 | 34 |\n| 2022.01.13 | 64 |\n| 2022.01.14 | 80 |\n| 2022.01.15 | 63 |\n| 2022.01.16 | 17 |\n| 2022.01.17 | 66 |\n| 2022.01.18 | 85 |\n| 2022.01.19 | 27 |\n| 2022.01.20 | 77 |\n| 2022.01.21 | 27 |\n\n```\nselect max(x) from t group by bar(time, 7d);\n```\n\n| bar\\_time | max\\_x |\n| ---------- | ------ |\n| 2021.12.30 | 71 |\n| 2022.01.06 | 93 |\n| 2022.01.13 | 85 |\n| 2022.01.20 | 77 |\n\n```\nprint select max(x) from t group by bar(time, 7d, closed='right');\n```\n\n| bar\\_time | max\\_x |\n| ---------- | ------ |\n| 2021.01.06 | 93 |\n| 2022.01.13 | 77 |\n| 2022.01.20 | 85 |\n| 2022.01.27 | 27 |\n\nWhen calculating 1-minute OHLC bars, the data type needs to be converted to LONG if n needs to be converted to NANOTIMESTAMP, otherwise an integer overflow will occur.\n\n```\nn = 1000000\nnano = (09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!()\nprice = 100+cumsum(rand(0.02, n)-0.01)\nvolume = rand(1000, n)\nsymbol = rand(`600519`000001`600000`601766, n)\ntradeNano = table(symbol, nano, price, volume).sortBy!(`symbol`nano)\nundef(`nano`price`volume`symbol)\nbarMinutes = 7\nitv = barMinutes*60*long(1000000000)\n\nOHLC_nano=select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from tradeNano group by symbol, bar(nano, itv) as barStart\n```\n\nRelated function: [dailyAlignedBar](https://docs.dolphindb.com/en/Functions/d/dailyAlignedBar.html)\n" }, "base64Decode": { "url": "https://docs.dolphindb.com/en/Functions/b/base64Decode.html", "signatures": [ { "full": "base64Decode(X)", "name": "base64Decode", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [base64Decode](https://docs.dolphindb.com/en/Functions/b/base64Decode.html)\n\n\n\n#### Syntax\n\nbase64Decode(X)\n\n#### Details\n\nDecode *X* from Base64 format to binary data.\n\n#### Parameters\n\n**X** is a STRING scalar or vector.\n\n#### Returns\n\nA BLOB scalar or vector.\n\n#### Examples\n\n```\nbase64Decode(base64Encode(`hello))\nhello\n\nbase64Decode(base64Encode(`hello`world))\n[\"hello\",\"world\"]\n```\n\nRelated function: [base64Ebcode](https://docs.dolphindb.com/en/Functions/b/base64Encode.html)\n" }, "base64Encode": { "url": "https://docs.dolphindb.com/en/Functions/b/base64Encode.html", "signatures": [ { "full": "base64Encode(X)", "name": "base64Encode", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [base64Encode](https://docs.dolphindb.com/en/Functions/b/base64Encode.html)\n\n\n\n#### Syntax\n\nbase64Encode(X)\n\n#### Details\n\nEncode *X* to Base64 format.\n\n#### Parameters\n\n**X** is a STRING scalar or vector.\n\n#### Returns\n\nA STRING scalar or vector.\n\n#### Examples\n\n```\nbase64Encode(`hello) \n// output: aGVsbG8=\n\nbase64Encode(`hello`world) \n// output: [\"aGVsbG8=\",\"d29ybGQ=\"]\n\nbase64Encode(\"\")\n// output: \"\"\n```\n\nRelated function: [base64Decode](https://docs.dolphindb.com/en/Functions/b/base64Decode.html)\n" }, "beta": { "url": "https://docs.dolphindb.com/en/Functions/b/beta.html", "signatures": [ { "full": "beta(Y, X)", "name": "beta", "parameters": [ { "full": "Y", "name": "Y" }, { "full": "X", "name": "X" } ] } ], "markdown": "### [beta](https://docs.dolphindb.com/en/Functions/b/beta.html)\n\n\n\n#### Syntax\n\nbeta(Y, X)\n\n#### Details\n\nReturn the coefficient estimate of an ordinary-least-squares regression of *Y* on *X* (with intercept).\n\nDifference from Python’s `scipy.stats.beta`: `scipy.stats.beta` is a beta continuous random variable object for calculating probability density, distribution functions, random variates, and related statistics. DolphinDB’s `beta` is a statistical regression function that returns the OLS regression coefficient of *Y* on *X*.\n\nDifference from Python TA-Lib’s `BETA`: TA-Lib’s `BETA(high, low, timeperiod=5)` is a rolling technical-analysis statistic. It calculates beta on the rate-of-change series of *high* and *low* over each window. DolphinDB’s `beta(Y, X)` calculates one OLS regression coefficient over the full input when vectors are specified. To reproduce TA-Lib’s indicator behavior, use DolphinDB’s TA module `ta::beta`.\n\n#### Parameters\n\n**Y** and **X** are vectors of the same length.\n\n#### Returns\n\nA DOUBLE scalar/vector/table.\n\n#### Examples\n\n```\nx=1 3 5 7 11 16 23\ny=0.1 4.2 5.6 8.8 22.1 35.6 77.2;\n\nbeta(y,x);\n// output: 3.378632\n```\n" }, "between": { "url": "https://docs.dolphindb.com/en/Functions/b/between.html", "signatures": [ { "full": "between(X, Y)", "name": "between", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [between](https://docs.dolphindb.com/en/Functions/b/between.html)\n\n\n\n#### Syntax\n\nbetween(X, Y)\n\n#### Details\n\nCheck if each element of *X* is between the pair indicated by *Y* (both boundaries are inclusive). The result is of the same dimension as *X*.\n\n#### Parameters\n\n**X** is a scalar/pair/vector/matrix.\n\n**Y** is a pair indicating a range.\n\n#### Returns\n\nBOOL type with the same data form as *X*.\n\n#### Examples\n\n```\nbetween([1, 5.5, 6, 8], 1:6);\n// output: [1,1,1,0] // 1, 5.5 and 6 are between 1 and 6, but 8 is not.\n\nbetween(1 2.4 3.6 2 3.9, 2.4:3.6);\n// output: [0,1,1,0,0]\n```\n\n`between` can be used with `select` to filter columns:\n\n```\nt = table(`abb`aac`aaa as sym, 1.8 2.3 3.7 as price);\nselect * from t where price between 1:3;\n```\n\n\n
\n\nsym\n\n\n\nprice\n\n
\n\nabb\n\n\n\n1.8\n\n
\n\naac\n\n\n\n2.3\n\n
The following example explains how null values of *Y* are handled.\n\nIf the configuration parameter *nullAsMinValueForComparison* is set to true, null values are treated as the minimum value of the current data type. Otherwise null values are processed as NULL and the comparison returns NULL.\n\n`between` can also be used with template [nullCompare](https://docs.dolphindb.com/en/Functions/Templates/nullCompare.html), and the result of comparison involving null values is always NULL, regardless of the *nullAsMinValueForComparison* setting.\n\n```\nbetween(10,:10)\n// output: true // when nullAsMinValueForComparison=true\n\nbetween(10,:10)\n// output: NULL // when nullAsMinValueForComparison=false\n\nnullCompare(between, 10, :10)\n// output: NULL\n```\n" }, "bfill!": { "url": "https://docs.dolphindb.com/en/Functions/b/bfill!.html", "signatures": [ { "full": "bfill!(obj, [limit])", "name": "bfill!", "parameters": [ { "full": "obj", "name": "obj" }, { "full": "[limit]", "name": "limit", "optional": true } ] } ], "markdown": "### [bfill!](https://docs.dolphindb.com/en/Functions/b/bfill!.html)\n\n\n\n#### Syntax\n\nbfill!(obj, \\[limit])\n\n#### Details\n\n* If *obj* is a vector: back fill the null values in *obj* with the next non-null value.\n\n* If *obj* is a matrix or a table: back fill the null values in each column of *obj* with the next non-null value.\n\n#### Parameters\n\n**obj** is a vector, matrix, or table.\n\n**limit** (optional) is a positive integer indicating the number of null values to be filled.\n\n#### Returns\n\nReturns the object with null values filled, with the same type and form as *obj*.\n\n#### Examples\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill!()\nx;\n// output: [1,2,3,4,4,4,4,5,6]\n\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill!(1)\nx;\n// output: [1,2,3,,,4,4,5,6]\n\ndate=[2012.06.12,,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[40.56,26.56,,,50.76]\nqty=[2200,4500,1200,5600,]\ntimestamp=[09:34:07,,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty)\n\nbfill!(t)\nt\n```\n\n| date | timestamp | sym | price | qty |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07 | IBM | 40.56 | 2200 |\n| 2012.06.13 | 09:36:42 | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42 | IBM | 50.76 | 1200 |\n| 2012.06.14 | 09:36:51 | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59 | MSFT | 50.76 | |\n\nIf only certain columns need to be filled instead of all columns, please use [update](https://docs.dolphindb.com/en/Programming/SQLStatements/update.html) statement and [bfill](https://docs.dolphindb.com/en/Functions/b/bfill.html) function. For details, please refer to [bfill](https://docs.dolphindb.com/en/Functions/b/bfill.html).\n" }, "bfill": { "url": "https://docs.dolphindb.com/en/Functions/b/bfill.html", "signatures": [ { "full": "bfill(obj, [limit])", "name": "bfill", "parameters": [ { "full": "obj", "name": "obj" }, { "full": "[limit]", "name": "limit", "optional": true } ] } ], "markdown": "### [bfill](https://docs.dolphindb.com/en/Functions/b/bfill.html)\n\n\n\n#### Syntax\n\nbfill(obj, \\[limit])\n\n#### Details\n\n* If *obj* is a vector: back fill the null values in *obj* with the next non-null value.\n* If *obj* is an array vector:\n * For an empty row, fill it with the first non-empty row that follows it.\n * For null values in a column, fill them with the first non-null value that follows within the same column.\n* If *obj* is a matrix or a table: back fill the null values in each column of *obj*with the next non-null value. according to the above rules.\n\nThis operation creates a new object and does not change the input *obj*. Function [bfill!](https://docs.dolphindb.com/en/Functions/b/bfill!.html) changes the input *obj*.\n\n#### Parameters\n\n**obj** is a vector/matrix/table/array vector.\n\n**limit** (optional) is a positive integer indicating the maximum number of consecutive null values to be filled. It cannot be specified when *obj* is an array vector.\n\n#### Returns\n\nReturns the object with null values filled, with the same type and form as *obj*.\n\n#### Examples\n\n```\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill();\n// output: [1,2,3,4,4,4,4,5,6]\n\nx=1 2 3 NULL NULL NULL 4 5 6\nx.bfill(1);\n// output: [1,2,3,,,4,4,5,6]\n\nx.bfill!(2);\nx;\n// output: [1,2,3,,4,4,4,5,6]\n\ndate=[2012.06.12,2012.06.12,2012.06.13,2012.06.14,2012.06.15]\nsym=[\"IBM\",\"MSFT\",\"IBM\",\"MSFT\",\"MSFT\"]\nprice=[,,26.56,,50.76]\nqty=[,,4500,5600,6800]\ntimestamp=[09:34:07,09:35:26,09:36:42,09:36:51,09:36:59]\nt=table(date,timestamp,sym,price,qty)\nt;\n```\n\n| date | timestamp | sym | price | qty |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07 | IBM | | |\n| 2012.06.12 | 09:35:26 | MSFT | | |\n| 2012.06.13 | 09:36:42 | IBM | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51 | MSFT | | 5600 |\n| 2012.06.15 | 09:36:59 | MSFT | 50.76 | 6800 |\n\n```\nt.bfill()\n```\n\n| date | timestamp | sym | price | qty |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07 | IBM | 26.56 | 4500 |\n| 2012.06.12 | 09:35:26 | MSFT | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42 | IBM | 26.56 | 4500 |\n| 2012.06.14 | 09:36:51 | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59 | MSFT | 50.76 | 6800 |\n\n```\nselect date, timestamp, sym, price.bfill() as price, qty.bfill() as qty from t context by sym;\n```\n\n| date | timestamp | sym | price | qty |\n| ---------- | --------- | ---- | ----- | ---- |\n| 2012.06.12 | 09:34:07 | IBM | 26.56 | 4500 |\n| 2012.06.13 | 09:36:42 | IBM | 26.56 | 4500 |\n| 2012.06.12 | 09:35:26 | MSFT | 50.76 | 5600 |\n| 2012.06.14 | 09:36:51 | MSFT | 50.76 | 5600 |\n| 2012.06.15 | 09:36:59 | MSFT | 50.76 | 6800 |\n\nIn the following example, the third row of the array vector x is empty, so it is filled with the fourth row \\[8, 9, 10]; the first element of the third column is null, so it is filled with the next non-null value 10 in that column.\n\n```\nx = array(INT[], 0).append!([1 2 NULL, 4 5, NULL, 8 9 10])\nx\n// output:[[1,2,NULL],[4,5],[NULL],[8,9,10]]\nbfill(x)\n// output:[[1,2,10],[4,5],[8,9,10],[8,9,10]]\n```\n" }, "bigarray": { "url": "https://docs.dolphindb.com/en/Functions/b/bigarray.html", "signatures": [ { "full": "bigarray(dataType|template, [initialSize], [capacity], [defaultValue])", "name": "bigarray", "parameters": [ { "full": "dataType|template", "name": "dataType|template" }, { "full": "[initialSize]", "name": "initialSize", "optional": true }, { "full": "[capacity]", "name": "capacity", "optional": true }, { "full": "[defaultValue]", "name": "defaultValue", "optional": true } ] } ], "markdown": "### [bigarray](https://docs.dolphindb.com/en/Functions/b/bigarray.html)\n\n\n\n#### Syntax\n\nbigarray(dataType|template, \\[initialSize], \\[capacity], \\[defaultValue])\n\n#### Details\n\nBig arrays are specially designed for advanced users in big data analysis. Regular arrays use continuous memory. If there is not enough continuous memory, an out of memory exception will occur. A big array consists of many small memory blocks instead of one large block of memory. Therefore big arrays help relieve the memory fragmentation issue. This, however, may come with light performance penalty for certain operations. For most users who don't need to worry about the memory fragmentation issue, they should use regular arrays instead of big arrays.\n\nA big array's minimum size or capacity is 16 MB. Users can declare a big array with the function `bigarray`. Functions and operations on regular arrays also apply to big arrays.\n\nWhen we call the [array](https://docs.dolphindb.com/en/Functions/a/array.html) function, if there are not enough continuous memory blocks available, or if the memory occupied by the array exceeds a certain threshold (the default threshold is 256 MB), the system creates a big array instead.\n\n#### Parameters\n\n**dataType** is the data type for the big array.\n\n**template** is an existing vector. The existing vector serves as a template and its data type determines the new big array's data type.\n\n**initialSize** (optional) is the initial size (in terms of the number of elements) of the big array. If the first parameter is a data type, then initialSize is required; if the first parameter is an existing big array, then initialSize is optional;\n\n**capacity** (optional) is the amount of memory (in terms of the number of elements) allocated to the big array. When the number of elements exceeds capacity, the system will first allocate memory of 1.2\\~2 times of capacity, copy the data to the new memory space, and release the original memory.\n\n**defaultValue** (optional) is the default value of the big array. For many data types, the default values are 0. For string and symbol, the default values are null values.\n\n#### Returns\n\nA big array with the data type specified by *dataType*/*template*.\n\n#### Examples\n\n```language-python\nx=bigarray(int,10,10000000);\nx;\n// output: [0,0,0,0,0,0,0,0,0,0]\n\n// default value is set to 1\nx=bigarray(int,10,10000000,1);\nx;\n// output: [1,1,1,1,1,1,1,1,1,1]\n\nx=bigarray(int,0,10000000).append!(1..100);\nx[0];\n// output: 1\n\nsum x;\n// output: 5050\n\nx[x>50&&x<60];\n// output: [51,52,53,54,55,56,57,58,59]\n\nx=array(double, 40000000);\ntypestr x;\n// output: HUGE DOUBLE VECTOR\n```\n\nPerformance comparison of arrays and big arrays:\n\n```language-python\n// for sequential operations, the performance of arrays and that of big arrays are nearly identical. \nn=20000000\nx=rand(10000, n)\ny=rand(1.0, n)\nbx= bigarray(int, 0, n).append!(x)\nby= bigarray(double,0,n).append!(y);\n\ntimer(100) wavg(x,y);\n// Time elapsed: 4869.74 ms\ntimer(100) wavg(bx,by);\n// Time elapsed: 4762.89 ms\n\ntimer(100) x*y;\n// Time elapsed: 7525.22 ms\ntimer(100) bx*by;\n// Time elapsed: 7791.83 ms\n\n// for random access, big arrays have light performance penalty.\nindices = shuffle 0..(n-1);\ntimer(10) x[indices];\n// Time elapsed: 2942.29 ms\ntimer(10) bx[indices];\n// Time elapsed: 3547.22 ms\n```\n" }, "binaryExpr": { "url": "https://docs.dolphindb.com/en/Functions/b/binaryExpr.html", "signatures": [ { "full": "binaryExpr(X, Y, optr)", "name": "binaryExpr", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" }, { "full": "optr", "name": "optr" } ] } ], "markdown": "### [binaryExpr](https://docs.dolphindb.com/en/Functions/b/binaryExpr.html)\n\n\n\n#### Syntax\n\nbinaryExpr(X, Y, optr)\n\n#### Details\n\nConnect *X* and *Y* with the binary operator specified in *optr* to generate metacode of a binary expression. You can execute the metacode with function [eval](https://docs.dolphindb.com/en/Functions/e/eval.html).\n\n#### Parameters\n\n**X** can be a scalar/vector/matrix.\n\n**Y** is a scalar or a vector of the same type as *X*.\n\n**optr** is a binary operator.\n\n#### Returns\n\nA CODE metacode.\n\n#### Examples\n\n```\nbinaryExpr(1, 1, +).eval()\n// output: 2\n\nbinaryExpr(1 2.2 3, 1 2 3, *).eval()\n// output: [1 4.4 9]\n\nbinaryExpr(`id`st`nm, `fff, +).eval()\n// output: [\"idfff\",\"stfff\",\"nmfff\"]\n\n\na = matrix(1 2, 3 4)\nb = matrix(4 2, 5 1)\nbinaryExpr(a, b, dot).eval()\n```\n\n| #0 | #1 |\n| -- | -- |\n| 10 | 8 |\n| 16 | 14 |\n\nRelated function: [unifiedExpr](https://docs.dolphindb.com/en/Functions/u/unifiedExpr.html)\n" }, "binsrch": { "url": "https://docs.dolphindb.com/en/Functions/b/binsrch.html", "signatures": [ { "full": "binsrch(X, Y)", "name": "binsrch", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [binsrch](https://docs.dolphindb.com/en/Functions/b/binsrch.html)\n\n\n\n#### Syntax\n\nbinsrch(X, Y)\n\n#### Details\n\n`binsrch` means binary search. For each element in *Y*, `binsrch` locates its position in *X*. If nothing is found, it returns -1(s).\n\nFor optimal performance, we should use `binsrch` to search a short *Y* within a long sorted vector *X*. To search a large vector against another large unsorted vector, we should use function [find](https://docs.dolphindb.com/en/Functions/f/find.html), which is implemented using a hash table. However, building a hash table takes time and memory. Please also check the related function [in](https://docs.dolphindb.com/en/Functions/i/in.html).\n\n#### Parameters\n\n**X** must be a vector sorted in ascending order.\n\n**Y** is a scalar/vector/tuple/matrix/array vector/dictionary/table.\n\n#### Returns\n\nINT type with the same data form as *Y*.\n\n#### Examples\n\n```\n1..100 binsrch 12 6 88 102;\n// output: [11,5,87,-1]\n```\n" }, "bitAnd": { "url": "https://docs.dolphindb.com/en/Functions/b/bitAnd.html", "signatures": [ { "full": "bitAnd(X, Y)", "name": "bitAnd", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [bitAnd](https://docs.dolphindb.com/en/Functions/b/bitAnd.html)\n\n\n\n#### Syntax\n\nbitAnd(X, Y)\n\nor\n\nX & Y\n\n#### Details\n\nReturn the result of the *bitAnd* operation.\n\n#### Parameters\n\n**X** and **Y** are numeric scalar, vectors, matrices or tables.\n\n#### Returns\n\nAn object with the same data type and form as *X*/*Y*.\n\n#### Examples\n\n```\nx=1 0 1;\ny=0 1 1;\nx&y;\n// output: [0,0,1]\n```\n" }, "bitNot": { "url": "https://docs.dolphindb.com/en/Functions/b/bitNot.html", "signatures": [ { "full": "bitNot(X)", "name": "bitNot", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [bitNot](https://docs.dolphindb.com/en/Functions/b/bitNot.html)\n\n\n\n#### Syntax\n\nbitNot(X)\n\n#### Details\n\nReturn the result of a bitwise logical NOT operation.\n\n#### Parameters\n\n**X** is a numeric scalar/vector/matrix/table.\n\n#### Returns\n\nAn object with the same data type and form as *X*.\n\n#### Examples\n\n```\nbitNot(3)\n// output: -4\n\nav = array(INT[], 0, 10).append!([1 2 3, 4 5])\nbitNot(av)\n// output: [[-2,-3,-4],[-5,-6]]\n```\n" }, "bitOr": { "url": "https://docs.dolphindb.com/en/Functions/b/bitOr.html", "signatures": [ { "full": "bitOr(X, Y)", "name": "bitOr", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [bitOr](https://docs.dolphindb.com/en/Functions/b/bitOr.html)\n\n\n\n#### Syntax\n\nbitOr(X, Y)\n\nor\n\nX | Y\n\n#### Details\n\nReturn the result of the *bitOr* operation.\n\n#### Parameters\n\n**X** and **Y** are numeric scalar, vectors, matrices or tables.\n\n#### Returns\n\nAn object with the same data type and form as *X*.\n\n#### Examples\n\n```\nx=1 0 1;\ny=0 1 1;\nx | y;\n// output: [1,1,1]\n```\n" }, "bitXor": { "url": "https://docs.dolphindb.com/en/Functions/b/bitXor.html", "signatures": [ { "full": "bitXor(X, Y)", "name": "bitXor", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [bitXor](https://docs.dolphindb.com/en/Functions/b/bitXor.html)\n\n\n\n#### Syntax\n\nbitXor(X, Y)\n\nor\n\nX ^ Y\n\n#### Details\n\nReturn the result of the *bitXOr* operation.\n\n#### Parameters\n\n**X** and **Y** are numeric scalars, vectors, matrices or tables.\n\n#### Returns\n\nAn object with the same data type and form as *X*/*Y*.\n\n#### Examples\n\n```\nx=1 0 1;\ny= 0 1 1;\nx^y;\n// output: [1,1,0]\n```\n" }, "blob": { "url": "https://docs.dolphindb.com/en/Functions/b/blob.html", "signatures": [ { "full": "blob(X)", "name": "blob", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [blob](https://docs.dolphindb.com/en/Functions/b/blob.html)\n\n\n\n#### Syntax\n\nblob(X)\n\n#### Details\n\nConvert the data type of *X* to BLOB.\n\n**Note**: Values of BLOB type do not participate in calculations.\n\n#### Parameters\n\n**X** is a STRING scalar/vector.\n\n#### Returns\n\nA scalar/vector of type BLOB.\n\n#### Examples\n\n```\nstr=\"hello\"\nblob(str)\n// output: hello\n\nt=table(1..10 as id, \"A\"+string(1..10) as sym, 2012.01.01..2012.01.10 as date, rand(100.0, 10) as val, rand(uuid(), 10) as uid)\nstr=toJson(t)\nblob(str)\n```\n\nAfter a long string is converted to BLOB, it can be used as a column of an in-memory table:\n\n```\nd = dict(1..10000, rand(1.0, 10000))\nstr=toStdJson(d);\nt=table(blob(str) as jsonStr)\n```\n\nThe BLOB type is also supported by DFS tables.\n\n```\ndbPath=\"dfs://testBlobDB\"\nif(existsDatabase(dbPath)){\ndropDatabase(dbPath)\n}\nn=2000000\nt=table(n:0,`date`id`type`num`blob,[DATETIME,INT,SYMBOL,DOUBLE,BLOB])\ndb1=database(\"\",VALUE,2020.01.01..2020.01.10)\ndb2=database(\"\",HASH,[INT,10])\n\ndb=database(dbPath,COMPO,[db1,db2])\npt1=createPartitionedTable(db,t,`pt1,`date`id)\n\ndate=concatDateTime(take(2020.01.01..2020.01.10,n),take(00:00:00..23:23:59,n))\nid=rand(1..1000,n)\ntype=rand(`A`B`C`D`E,n)\nnum=rand(100.0,n)\n\nblob=take(blob(string(1..10)),n)\n\nt1=table(date,id,type,num,blob)\npt1.append!(t1)\nselect * from pt1\n```\n" }, "bondAccrInt": { "url": "https://docs.dolphindb.com/en/Functions/b/bondAccrInt.html", "signatures": [ { "full": "bondAccrInt(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, [benchmark='Excel'])", "name": "bondAccrInt", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "issuePrice", "name": "issuePrice" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "settlement", "name": "settlement" }, { "full": "[benchmark='Excel']", "name": "benchmark", "optional": true, "default": "'Excel'" } ] } ], "markdown": "### [bondAccrInt](https://docs.dolphindb.com/en/Functions/b/bondAccrInt.html)\n\n#### Syntax\n\nbondAccrInt(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, \\[benchmark='Excel'])\n\n#### Details\n\n`bondAccrInt` returns the accrued interest of a security. Accrued interest is the interest on a bond or loan that has accumulated since the principal investment, or since the previous coupon payment if there has been one already.\n\nThe clean price is the price of a bond excluding any interest accrued since bond's issuance and the most recent coupon payment. Comparatively, the dirty price is the price of a bond including the accrued interest. Therefore,\n\nClean Price = Dirty Price − Accrued Interest\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity** is a DATE scalar or vector indicating the maturity date.\n\n**issuePrice**is a numeric scalar or vector of the same length as *start* indicating the bond’s issue price. For discount bonds, the actual issue price must be specified (typically less than 100); for other bonds, it is usually 100.\n\n**coupon** is a numeric scalar or vector indicating the annual coupon rate. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention** is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360\n* \"ActualActualISMA\" (default): actual/actual (ISMA rule)\n* \"Actual360\": actual/360\n* \"Actual365\": actual/365\n* \"Thirty360EU\": European 30/360\n* \"ActualActualISDA\" (default): actual/actual (ISDA rule)\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**settlement** is a DATE scalar or vector indicating the settlement date.\n\n**benchmark**(optional) is a STRING scalar indicating the reference algorithm. Currently, only \"Excel\" (the algorithm used in Excel) is supported.\n\n#### Returns\n\nA scalar or vector of DOUBLE type.\n\n#### Examples\n\n```\nbondAccrInt(start=2024.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.1, frequency=2, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\", settlement=2024.05.15)\n\n// output: 3.75\n```\n\nRelated function: [bondDirtyPrice](https://docs.dolphindb.com/en/Functions/b/bondDirtyPrice.html)\n\n" }, "bondCalculator": { "url": "https://docs.dolphindb.com/en/Functions/b/bondCalculator.html", "signatures": [ { "full": "bondCalculator(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, calendar, businessDayConvention, settlement, price, priceType, [calcRisk=false], [benchmark='Qeubee'])", "name": "bondCalculator", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "issuePrice", "name": "issuePrice" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "calendar", "name": "calendar" }, { "full": "businessDayConvention", "name": "businessDayConvention" }, { "full": "settlement", "name": "settlement" }, { "full": "price", "name": "price" }, { "full": "priceType", "name": "priceType" }, { "full": "[calcRisk=false]", "name": "calcRisk", "optional": true, "default": "false" }, { "full": "[benchmark='Qeubee']", "name": "benchmark", "optional": true, "default": "'Qeubee'" } ] } ], "markdown": "### [bondCalculator](https://docs.dolphindb.com/en/Functions/b/bondCalculator.html)\n\nFirst introduced in version: 2.00.163.00.3\n\n\n\n#### Syntax\n\nbondCalculator(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, calendar, businessDayConvention, settlement, price, priceType, \\[calcRisk=false], \\[benchmark='Qeubee'])\n\n#### Details\n\nThis function performs mutual conversion among a bond's yield to maturity, clean price, and dirty price, and supports the calculation of duration and convexity, and other risk indicators.\n\n#### Arguments\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity**is a scalar or vector of DATE type of the same length as *start*, indicating the bond's maturity date.\n\n**issuePrice**is a numeric scalar or vector of the same length as *start* indicating the bond’s issue price. For discount bonds, the actual issue price must be specified (typically less than 100); for other bonds, it is usually 100.\n\n**coupon**is a numeric scalar or vector indicating the coupon rate of the bond. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention**is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360.\n* \"ActualActual\": actual/actual.\n* \"Actual360\": actual/360.\n* \"Actual365\": actual/365.\n* \"Thirty360EU\": European 30/360.\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**calendar** is a STRING scalar indicating the trading calendar. Currently, only \"CFET\" is supported, representing the bond trading calendar of the China Interbank Bond Market (for bonds ending with .IB).\n\n**businessDayConvention** is a STRING scalar indicating how cash flows that fall on a non-trading day are treated. Currently, only \"Unadjusted\" is supported.\n\n**settlement**is a scalar or vector of DATE type, indicating the bond's settlement date. The settlement date is the date after the issue date when the security is traded to the buyer.\n\n**price**is a numeric scalar or vector whose meaning depends on the value of *priceType*:\n\n* When *priceType* is \"YTM\", *price* indicates the bond's yield to maturity.\n* When *priceType* is \"CleanPrice\", *price* indicates the bond's clean price.\n* When *priceType* is \"DirtyPrice\", *price* indicates the bond's dirty price.\n\n**priceType**is a STRING scalar or vector used to specify the type of the bond price (*price*). It can be:\n\n* \"YTM\": Yield to Maturity.\n\n* \"CleanPrice\": Clean price.\n\n* \"DirtyPrice\": Dirty price.\n\n**calcRisk**(optional) is a BOOLEAN value.\n\n* When set to false (default): Returning only dirty price, clean price, accrued interest, and yield to maturity (YTM).\n* When set to true: Macaulay duration, modified duration, convexity, and price value of a basis point (PVBP) are also returned.\n\n**benchmark**(optional) is a STRING scalar indicating the he algorithm benchmark. Currently, only \"Qeubee\" (for domestic bond calculation) is supported.\n\n#### Returns\n\nA dictionary or tuple.\n\n#### Examples\n\nExample 1: Calculate the price, yield to maturity, accrued interest, and risk metrics for a fixed-rate bond.\n\n```\nbondCalculator(start=2022.07.15, maturity=2072.07.15, issuePrice=100, coupon=0.034, frequency=\"Semiannual\", dayCountConvention=\"ActualActual\", bondType=\"FixedRate\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\npvbp->0.3902\nytm->0.0200\nmacaulayDuration->27.4761\ndirtyPrice->143.4689\naccruedInterest->0.7983\ncleanPrice->142.6705\nmodifiedDuration->27.2041\nconvexity->1025.4003\n*/\n\n\nbondCalculator(start=2022.07.15, maturity=2072.07.15, issuePrice=100, coupon=0.034, frequency=\"Semiannual\", dayCountConvention=\"ActualActual\", bondType=\"FixedRate\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2072.04.18, price=100.2143, priceType=\"CleanPrice\", calcRisk=false);\n\n/* Output:\naccruedInterest->0.8780\ncleanPrice->100.2143\nytm->0.0250\ndirtyPrice->101.0923\n*/\n```\n\nExample 2: Calculate the price, yield to maturity, accrued interest for a zero-coupon bond.\n\n```\nbondCalculator(start=2025.01.09, maturity=2026.02.05, issuePrice=100, coupon=0.0119, frequency=\"Annual\", dayCountConvention=\"ActualActual\", bondType=\"ZeroCoupon\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.025, priceType=\"YTM\", calcRisk=false);\n\n/* Output:\naccruedInterest->0.2966\ncleanPrice->98.9355\nytm->0.0250\ndirtyPrice->99.2322\n*/\n```\n\nExample 3. Calculate the price, yield to maturity, accrued interest, and risk metrics of a discount bond.\n\n```\nbondCalculator(start=2025.02.13, maturity=2025.05.15, issuePrice=99.663, coupon=0.0, frequency=\"Once\", dayCountConvention=\"ActualActual\", bondType=\"Discount\", calendar=\"CFET\", businessDayConvention=\"Unadjusted\", settlement=2025.04.10, price=0.02, priceType=\"YTM\", calcRisk=true);\n\n/* Output:\npvbp->0.0009\nytm->0.0200\nmacaulayDuration->0.0958\ndirtyPrice->99.8085\naccruedInterest->0.2073\ncleanPrice->99.6012\nmodifiedDuration->0.0957\nconvexity->0.0183\n*/  \n```\n\nExample 4. Calculate the price, yield to maturity, accrued interest, and risk metrics for multiple bonds at once.\n\n```\nresult = bondCalculator(start=[2025.02.13, 2025.01.09, 2022.07.15], maturity=[2025.05.15, 2026.02.05, 2072.07.15], issuePrice=[99.663, 100, 100], coupon=[0.0, 0.0119, 0.034], frequency=[\"Once\", \"Annual\", \"Semiannual\"], dayCountConvention=[\"ActualActual\", \"ActualActual\", \"ActualActual\"], bondType=[\"Discount\", \"ZeroCoupon\", \"FixedRate\"], calendar=[\"CFET\", \"CFET\", \"CFET\"], businessDayConvention=[\"Unadjusted\", \"Unadjusted\", \"Unadjusted\"], settlement=[2025.04.10, 2025.04.10, 2072.04.18], price=[0.02, 0.025, 100.2143], priceType=[\"YTM\", \"YTM\", \"CleanPrice\"], calcRisk=true);\n\nprint result\n\n/* Output:\n(dirtyPrice->99.808586272901294\ncleanPrice->99.601201657516682\nytm->0.02\naccruedInterest->0.207384615384617\nmacaulayDuration->0.095890410958904\nmodifiedDuration->0.095706863549357\nconvexity->0.018319607460911\npvbp->0.000955236674747\n,dirtyPrice->99.232212603180983\ncleanPrice->98.935527671674137\nytm->0.025\naccruedInterest->0.296684931506849\nmacaulayDuration->0.824657534246575\nmodifiedDuration->0.80799946312328\nconvexity->1.305726264815019\npvbp->0.008017957450791\n,dirtyPrice->101.092321978021971\ncleanPrice->100.214299999999994\nytm->0.025000792220527\naccruedInterest->0.878021978021978\nmacaulayDuration->0.240437158469945\nmodifiedDuration->0.239000497930427\nconvexity->0.114242476021984\npvbp->0.002416111528969\n)\n*/ \n```\n\nRelated Functions: [bondAccrInt](https://docs.dolphindb.com/en/Functions/b/bondAccrInt.html), [bondConvexity](https://docs.dolphindb.com/en/Functions/b/bondConvexity.html), [bondDirtyPrice](https://docs.dolphindb.com/en/Functions/b/bondDirtyPrice.html), [bondYield](https://docs.dolphindb.com/en/Functions/b/bondYield.html)\n" }, "bondCashflow": { "url": "https://docs.dolphindb.com/en/Functions/b/bondCashflow.html", "signatures": [ { "full": "bondCashflow(start, maturity, coupon, frequency, dayCountConvention, bondType, [mode='Vector'])", "name": "bondCashflow", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "[mode='Vector']", "name": "mode", "optional": true, "default": "'Vector'" } ] } ], "markdown": "### [bondCashflow](https://docs.dolphindb.com/en/Functions/b/bondCashflow.html)\n\n\n\n#### Syntax\n\nbondCashflow(start, maturity, coupon, frequency, dayCountConvention, bondType, \\[mode='Vector'])\n\n#### Details\n\n`bondCashflow` calculates the cash flow for a bond with a face value of 100. Supports fixed-rate bonds, zero-coupon bonds, and discount bonds.\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity** is a DATE scalar or vector indicating the maturity date.\n\n**coupon** is a numeric scalar or vector indicating the annual coupon rate. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention** is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360\n* \"ActualActualISMA\" (default): actual/actual (ISMA rule)\n* \"Actual360\": actual/360\n* \"Actual365\": actual/365\n* \"Thirty360EU\": European 30/360\n* \"ActualActualISDA\" (default): actual/actual (ISDA rule)\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**mode** is a STRING scalar specifying the output format. The values are:\n\n* \"Vector\" (default): returns only the cash flow amounts.\n* \"Table\": returns a detailed cash flow table.\n\n#### Returns\n\n* If mode = \"Vector\", it returns a DOUBLE vector or an array vector that lists the cash flow amounts for a single bond or multiple bonds.\n\n* If mode = \"Table\", it returns a table or a tuple of tables, each representing the detailed cash flows of a single bond or multiple bonds. Each table contains the following fields:\n\n * paymentDate: DATE, payment date.\n\n * coupon: DOUBLE, interest amount.\n\n * notional: DOUBLE, principal.\n\n * total: DOUBLE, total amount.\n\n#### Examples\n\n```\nfrequency=\"Annual\"\nstart=2022.09.28\nmaturity=2025.09.28\ncoupon=0.078\nbondCashflow(start=start, maturity=maturity, coupon=coupon, frequency=frequency, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\")\n\n// output: [7.8,7.8,107.799999]\n\nbondCashflow(start=start, maturity=maturity, coupon=coupon, frequency=frequency, dayCountConvention=\"Thirty360US\", bondType=\"FixedRate\", mode=\"Table\")\n\n/* output:\npaymentDate coupon notional total \n----------- ------ -------- ----------\n2023.09.28 7.8 0 7.8 \n2024.09.28 7.8 0 7.8 \n2025.09.28 7.8 100 107.799999\n*/\n```\n" }, "bondConvexity": { "url": "https://docs.dolphindb.com/en/Functions/b/bondConvexity.html", "signatures": [ { "full": "bondConvexity(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [benchmark='Excel'])", "name": "bondConvexity", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "issuePrice", "name": "issuePrice" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "settlement", "name": "settlement" }, { "full": "price", "name": "price" }, { "full": "priceType", "name": "priceType" }, { "full": "[benchmark='Excel']", "name": "benchmark", "optional": true, "default": "'Excel'" } ] } ], "markdown": "### [bondConvexity](https://docs.dolphindb.com/en/Functions/b/bondConvexity.html)\n\n\n\n#### Syntax\n\nbondConvexity(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[benchmark='Excel'])\n\n#### Details\n\n`bondConvexity` returns the bond convexity of a bond with a face value of 100. Bond convexity is a measure of the non-linear relationship of bond prices to changes in interest rates, and is defined as the second derivative of the price of the bond with respect to interest rates.\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity** is a DATE scalar or vector indicating the maturity date.\n\n**issuePrice**is a numeric scalar or vector of the same length as *start* indicating the bond’s issue price. For discount bonds, the actual issue price must be specified (typically less than 100); for other bonds, it is usually 100.\n\n**coupon** is a numeric scalar or vector indicating the annual coupon rate. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention** is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360\n* \"ActualActualISMA\" (default): actual/actual (ISMA rule)\n* \"Actual360\": actual/360\n* \"Actual365\": actual/365\n* \"Thirty360EU\": European 30/360\n* \"ActualActualISDA\" (default): actual/actual (ISDA rule)\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**settlement** is a DATE scalar or vector indicating the settlement date.\n\n**price** is a numeric scalar or vector indicating the bond's yield to maturity.\n\n**priceType** is a STRING scalar or vector used to specify the type of the bond price (*price*). Currently, only \"`YTM`\" (Yield to Maturity) is supported.\n\n**benchmark**(optional) is a STRING scalar indicating the reference algorithm. Currently, only \"Excel\" (the algorithm used in Excel) is supported.\n\n#### Returns\n\nA scalar or vector of type DOUBLE.\n\n#### Examples\n\n```\nbondConvexity(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=0.03, priceType=\"YTM\")\n// output: 51.864347713454684\n```\n" }, "bondDirtyPrice": { "url": "https://docs.dolphindb.com/en/Functions/b/bondDirtyPrice.html", "signatures": [ { "full": "bondDirtyPrice(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [benchmark='Excel'])", "name": "bondDirtyPrice", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "issuePrice", "name": "issuePrice" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "settlement", "name": "settlement" }, { "full": "price", "name": "price" }, { "full": "priceType", "name": "priceType" }, { "full": "[benchmark='Excel']", "name": "benchmark", "optional": true, "default": "'Excel'" } ] } ], "markdown": "### [bondDirtyPrice](https://docs.dolphindb.com/en/Functions/b/bondDirtyPrice.html)\n\n\n\n#### Syntax\n\nbondDirtyPrice(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[benchmark='Excel'])\n\n#### Details\n\n`bondDirtyPrice` returns the dirty price of a bond with a face value of 100.\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity** is a DATE scalar or vector indicating the maturity date.\n\n**issuePrice**is a numeric scalar or vector of the same length as *start* indicating the bond’s issue price. For discount bonds, the actual issue price must be specified (typically less than 100); for other bonds, it is usually 100.\n\n**coupon** is a numeric scalar or vector indicating the annual coupon rate. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention** is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360\n* \"ActualActualISMA\" (default): actual/actual (ISMA rule)\n* \"Actual360\": actual/360\n* \"Actual365\": actual/365\n* \"Thirty360EU\": European 30/360\n* \"ActualActualISDA\" (default): actual/actual (ISDA rule)\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**settlement** is a DATE scalar or vector indicating the settlement date.\n\n**price**is a numeric scalar or vector whose meaning depends on the value of *priceType*:\n\n* When *priceType* is \"YTM\", *price* indicates the bond's yield to maturity.\n* When *priceType* is \"CleanPrice\", *price* indicates the bond's clean price.\n\n**priceType** is a STRING scalar or vector used to specify the type of the bond price (*price*). It can be:\n\n* \"YTM\": Yield to Maturity.\n* \"CleanPrice\": Clean price.\n\n**benchmark**(optional) is a STRING scalar indicating the reference algorithm. Currently, only \"Excel\" (the algorithm used in Excel) is supported.\n\n#### Returns\n\nA scalar/vector of type DOUBLE.\n\n#### Examples\n\n```\nbondDirtyPrice(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=100.2143, priceType=\"CleanPrice\")\n// output: 101.447176\n```\n" }, "bondFuturesPricer": { "url": "https://docs.dolphindb.com/en/Functions/b/bondFuturesPricer.html", "signatures": [ { "full": "bondFuturesPricer(instrument, pricingDate, discountCurve)", "name": "bondFuturesPricer", "parameters": [ { "full": "instrument", "name": "instrument" }, { "full": "pricingDate", "name": "pricingDate" }, { "full": "discountCurve", "name": "discountCurve" } ] } ], "markdown": "### [bondFuturesPricer](https://docs.dolphindb.com/en/Functions/b/bondFuturesPricer.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\nbondFuturesPricer(instrument, pricingDate, discountCurve)\n\n#### Details\n\nCalculates the Net Present Value (NPV) of the bond futures.\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**instrument** is an INSTRUMENT scalar/vector of BondFutures type indicating the bond futures to be priced.\n\n**pricingDate** is a DATE scalar/vector specifying the pricing date(s).\n\n**discountCurve** is a MKTDATA scalar/vector of type IrYieldCurve representing the discount curve(s).\n\n#### Returns\n\nA DOUBLE scalar/vector.\n\n#### Examples\n\n```\nbond = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"220010.IB\",\n \"start\": \"2022.05.15\",\n \"maturity\": \"2032.05.15\",\n \"issuePrice\": 100.0,\n \"coupon\": 0.0276,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nbondFutures = { \n \"productType\": \"Futures\",\n \"futuresType\": \"BondFutures\",\n \"instrumentId\": \"T2509\",\n \"nominal\": 100.0,\n \"maturity\": \"2025.09.12\",\n \"settlement\": \"2025.09.16\",\n \"underlying\": bond,\n \"nominalCouponRate\": 0.03\n}\n\ninstrument = parseInstrument(bondFutures)\npricingDate = 2025.06.10\ncurve = {\n \"mktDataType\": \"Curve\",\n \"curveType\": \"IrYieldCurve\",\n \"referenceDate\": pricingDate,\n \"currency\": \"CNY\",\n \"dayCountConvention\": \"ActualActualISDA\",\n \"compounding\": \"Compounded\",\n \"interpMethod\": \"Linear\",\n \"extrapMethod\": \"Flat\",\n \"frequency\": \"Semiannual\",\n \"dates\":[2025.09.05, 2025.12.05, 2026.03.05, 2027.03.05, 2028.03.05, 2030.03.05, 2035.03.05, 2040.03.05, 2045.03.05, 2055.03.05, 2075.03.05],\n \"values\":[1.5347, 1.4958, 1.4447, 1.3955, 1.5029, 1.5561, 1.7156, 1.8652, 2.0329, 1.8955, 2.1059] / 100.0\n}\ndiscountCurve = parseMktData(curve)\n\nbondFuturesPricer(instrument, pricingDate, discountCurve)\nbondFuturesPricer([instrument, instrument], pricingDate, discountCurve)\nbondFuturesPricer(instrument, [pricingDate, pricingDate, pricingDate], discountCurve)\nbondFuturesPricer(instrument, [pricingDate, pricingDate, pricingDate], [discountCurve, discountCurve, discountCurve])\nbondFuturesPricer(instrument, pricingDate, [discountCurve, discountCurve, discountCurve])\n```\n" }, "bondPricer": { "url": "https://docs.dolphindb.com/en/Functions/b/bondPricer.html", "signatures": [ { "full": "bondPricer(instrument, pricingDate, discountCurve, [spreadCurve], [setting])", "name": "bondPricer", "parameters": [ { "full": "instrument", "name": "instrument" }, { "full": "pricingDate", "name": "pricingDate" }, { "full": "discountCurve", "name": "discountCurve" }, { "full": "[spreadCurve]", "name": "spreadCurve", "optional": true }, { "full": "[setting]", "name": "setting", "optional": true } ] } ], "markdown": "### [bondPricer](https://docs.dolphindb.com/en/Functions/b/bondPricer.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\nbondPricer(instrument, pricingDate, discountCurve, \\[spreadCurve], \\[setting])\n\n#### Details\n\nPrices the bond instrument(s), supporting output of multiple risk measures, including (NPV (Net Present Value), Delta (first-order sensitivity), Gamma (second-order sensitivity), and Key Rate Duration (sensitivity to interest rate shifts at specified key maturities).\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**instrument** is an INSTRUMENT scalar/vector object representing the bond(s) to be priced. The required key fields vary depending on the type of bond product; see [Bond Product Field Specifications](https://docs.dolphindb.com/en/Functions/b/bondPricer.html#topic_n1c_qwq_ngc) for details.\n\n**pricingDate** is a DATE scalar/vector specifying the pricing date(s).\n\n**discountCurve** is a MKTDATA scalar/vector of type IrYieldCurve representing the discount curve(s). See [Curve Field Specifications](https://docs.dolphindb.com/en/Functions/b/bondPricer.html#topic_ozj_qwq_ngc) for details.\n\n**spreadCurve** (optional) is a MKTDATA scalar/vector of type IrYieldCurve representing the credit spread curve(s). If not specified, defaults to a flat curve with 0% spread. See [Curve Field Specifications](https://docs.dolphindb.com/en/Functions/b/bondPricer.html#topic_ozj_qwq_ngc) for details.\n\n**setting** (optional)is a Dictionary\\ with the following key-value pairs：\n\n| Key | Value Type | Description |\n| ---------------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |\n| \"calcDiscountCurveDelta\" | BOOL | Whether to compute the bond’s first-order sensitivity (delta) to the discount curve. |\n| \"calcDiscountCurveGamma\" | BOOL | Whether to compute the bond’s second-order sensitivity (gamma) to the discount curve. |\n| \"calcDiscountCurveKeyRateDuration\" | BOOL | Whether to compute the bond’s key rate durations. |\n| \"discountCurveShift\" | DOUBLE scalar | The parallel shift applied to the discount curve. For example, a bp(0.0001). |\n| \"discountCurveKeyTerms\" | DOUBLE scalar/vector | The specific maturity point(s) to calculate the key rate duration. For example, \\[1.0, 3.0, 5.0]. |\n| \"discountCurveKeyShifts\" | DOUBLE scalar/vector | The shift amounts corresponding to each maturity point. It has the same length with discountCurveKeyTerms. For example, \\[0.0001, 0.0002, 0.0015]. |\n\n#### Returns\n\nFor scalar input:\n\n* If *setting*is not specified, returns the NPV (a DOUBLE scalar).\n* If *setting*is specified, returns a Dictionary\\ with the following key-value pairs:\n * \"npv\": A DOUBLE scalar\n * \"discountCurveDelta\": A DOUBLE scalar\n * \"discountCurveGamma\": A DOUBLE scalar\n * \"discountCurveKeyRateDuration\": A DOUBLE vector\n\nFor vector input, it returns a DOUBLE vector (if *setting* is not specified) or a tuple of dictionaries (if *setting* is specified).\n\n#### Examples\n\n```\nbond = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"version\": 0, \n \"instrumentId\": \"240025.IB\",\n \"start\": 2024.12.25,\n \"maturity\": 2031.12.25,\n \"issuePrice\": 100.0,\n \"coupon\": 0.0149,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\n\npricingDate = 2025.08.18\n\ncurve = {\n \"mktDataType\": \"Curve\",\n \"curveType\": \"IrYieldCurve\",\n \"referenceDate\": pricingDate,\n \"currency\": \"CNY\",\n \"curveName\": \"CNY_TREASURY_BOND\",\n \"dayCountConvention\": \"ActualActualISDA\",\n \"compounding\": \"Compounded\",\n \"interpMethod\": \"Linear\",\n \"extrapMethod\": \"Flat\",\n \"frequency\": \"Annual\",\n \"dates\":[2025.09.18, 2025.11.18, 2026.02.18, 2026.08.18, 2027.08.18, 2028.08.18, 2030.08.18,\n 2032.08.18, 2035.08.18, 2040.08.18, 2045.08.18, 2055.08.18,2065.08.18, 2075.08.18],\n \"values\":[1.3000, 1.3700, 1.3898, 1.3865, 1.4299, 1.4471, 1.6401,\n 1.7654, 1.7966, 1.9930, 2.1834, 2.1397, 2.1987, 2.2225] / 100.0\n}\n\ninstrument = parseInstrument(bond)\ndiscountCurve = parseMktData(curve)\n\nsetting = dict(STRING, ANY)\nsetting[\"calcDiscountCurveDelta\"] = true\nsetting[\"calcDiscountCurveGamma\"] = true\nsetting[\"calcDiscountCurveKeyRateDuration\"] = true\nsetting[\"discountCurveShift\"] = 0.0001\nsetting[\"discountCurveKeyTerms\"] = [1.0, 3.0, 5.0]\nsetting[\"discountCurveKeyShifts\"] = [0.0002, 0.0003, 0.0001]\n\nbondPricer(instrument, pricingDate, discountCurve, setting=setting)\n\nbondPricer([instrument, instrument], pricingDate, discountCurve, setting=setting)\nbondPricer(instrument, pricingDate, [discountCurve, discountCurve], setting=setting)\nbondPricer(instrument, [pricingDate], discountCurve, setting=setting)\nbondPricer(instrument, [pricingDate, pricingDate], discountCurve, setting=setting)\n```\n\n**Related functions:** [parseInstrument](https://docs.dolphindb.com/en/Functions/p/parseInstrument.html), [parseMktData](https://docs.dolphindb.com/en/Functions/p/parseMktData.html)\n\n#### Bond Product Field Specifications\n\n**Discount Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"DiscountBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\nissuePrice\n\n\n\nDOUBLE\n\n\n\nIssue price\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
**Zero Coupon Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"ZeroCouponBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ncoupon\n\n\n\nDOUBLE\n\n\n\nCoupon rate, e.g., 0.03 means 3%\n\n\n\n√\n\n
\n\nfrequency\n\n\n\nSTRING\n\n\n\nFrequency of interest payment\n\n\n\n×\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
**Fixed Rate Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"FixedRateBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ncoupon\n\n\n\nDOUBLE\n\n\n\nCoupon rate, e.g., 0.03 means 3%\n\n\n\n√\n\n
\n\nfrequency\n\n\n\nSTRING\n\n\n\nFrequency of interest payment\n\n\n\n√\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
## Curve Field Specifications\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nmktDataType\n\n\n\nSTRING\n\n\n\nMust be \"Curve\"\n\n\n\n√\n\n
\n\nreferenceDate\n\n\n\nDATE\n\n\n\nReference Date\n\n\n\n√\n\n
\n\ncurveType\n\n\n\nSTRING\n\n\n\nMust be \"IrYieldCurve\"\n\n\n\n√\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention to use. It can be:\n\n* \"Actual360\": actual/360\n\n* \"Actual365\": actual/365\n\n* \"ActualActualISMA\": actual/actual according to ISMA (International Securities Market Association) convention\n\n* \"ActualActualISDA\": actual/actual according to ISDA (International Swaps and Derivatives Association) convention.\n\n\n\n√\n\n
\n\ninterpMethod\n\n\n\nSTRING\n\n\n\nInterpolation method. It can be:\n\n* \"Linear\": linear interpolation\n\n* \"CubicSpline\": cubic spline interpolation\n\n* \"CubicHermiteSpline\": cubic Hermite interpolation\n\n\n\n√\n\n
\n\nextrapMethod\n\n\n\nSTRING\n\n\n\nExtrapolation method. It can be\n\n* Flat: flat extrapolation\n\n* Linear: linear extrapolation\n\n\n\n√\n\n
\n\ndates\n\n\n\nDATE vector\n\n\n\nDate of each data point\n\n\n\n√\n\n
\n\nvalues\n\n\n\nDOUBLE vector\n\n\n\nValue of each data point, corresponding to the elements in dates.\n\n\n\n√\n\n
\n\ncurveName\n\n\n\nSTRING\n\n\n\nCurve name\n\n\n\n×\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency. It can be CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\"\n\n\n\n√\n\n
\n\ncompounding\n\n\n\nSTRING\n\n\n\nThe compounding interest. It can be:\n\n* \"Compounded\": discrete compounding\n\n* \"Simple\": simple interest (no compounding).\n\n* \"Continuous\": continuous compounding.\n\n\n\n√\n\n
\n\nsettlement\n\n\n\nDATE\n\n\n\nSettlement date. If specified, all subsequent tenor intervals are computed starting from \"settlement\" rather than from \"referenceDate\".\n\n\n\n×\n\n
\n\nfrequency\n\n\n\nINTEGRAL/STRING\n\n\n\nThe interest payment frequency. Supported values:\n\n* -1 or \"NoFrequency\": No payment frequency\n\n* 0 or \"Once\": Single lump-sum payment of principal and interest at maturity.\n\n* 1 or \"Annual\": Annually\n\n* 2 or \"Semiannual\": Semiannually\n\n* 3 or \"EveryFourthMonth\": Every four months\n\n* 4 or \"Quarterly\": Quarterly\n\n* 6 or \"BiMonthly\": Every two months\n\n* 12 or \"Monthly\": Monthly\n\n* 13 or \"EveryFourthWeek\": Every four weeks\n\n* 26 or \"BiWeekly\": Every two weeks\n\n* 52 or \"Weekly\": Weekly\n\n* 365 or \"Daily\": Daily\n\n* 999 or \"Other\": Other frequencies\n\n\n\n×\n\n
\n\ncurveModel\n\n\n\nSTRING\n\n\n\nCurve construction model; It can be \"Bootstrap\" (default), \"NS\", \"NSS\".\n\nWhen the value is \"NSS\" or \"NS\", the fields interpMethod, extrapMethod, dates, and values are not required.\n\n\n\n×\n\n
\n\ncurveParams\n\n\n\nDICT\n\n\n\nModel parameters. It is required when *curveModel*is \"NSS\" or \"NS\":\n\n* If curveModel = \"NS\": must include keys 'beta0', 'beta1', 'beta2', 'lambda'.\n\n* If curveModel = \"NSS\": must include keys 'beta0', ‘beta1', 'beta2', 'beta3', 'lambda0', 'lambda1'.\n\n\n\n×\n\n
\n" }, "bondYield": { "url": "https://docs.dolphindb.com/en/Functions/b/bondYield.html", "signatures": [ { "full": "bondYield(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, [method='newton'], [maxIter=100], [benchmark='Excel'])", "name": "bondYield", "parameters": [ { "full": "start", "name": "start" }, { "full": "maturity", "name": "maturity" }, { "full": "issuePrice", "name": "issuePrice" }, { "full": "coupon", "name": "coupon" }, { "full": "frequency", "name": "frequency" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "bondType", "name": "bondType" }, { "full": "settlement", "name": "settlement" }, { "full": "price", "name": "price" }, { "full": "priceType", "name": "priceType" }, { "full": "[method='newton']", "name": "method", "optional": true, "default": "'newton'" }, { "full": "[maxIter=100]", "name": "maxIter", "optional": true, "default": "100" }, { "full": "[benchmark='Excel']", "name": "benchmark", "optional": true, "default": "'Excel'" } ] } ], "markdown": "### [bondYield](https://docs.dolphindb.com/en/Functions/b/bondYield.html)\n\n\n\n#### Syntax\n\nbondYield(start, maturity, issuePrice, coupon, frequency, dayCountConvention, bondType, settlement, price, priceType, \\[method='newton'], \\[maxIter=100], \\[benchmark='Excel'])\n\n#### Details\n\nCalculate the bond yield for each 100 face value of a bond based on its clean price or dirty price.\n\nNote:\n\n* If there is one coupon period or less until redemption, YIELD is calculated as follows:\n\n ![](https://docs.dolphindb.com/en/images/bondYield.png)\n\n where:\n\n * * A = number of days from the beginning of the coupon period to the settlement date (accrued days).\n\n* DSR = number of days from the settlement date to the redemption date.\n\n* E = number of days in the coupon period.\n\n* If there is more than one coupon period until redemption, bond yield is calculated through a hundred iterations. The resolution uses the Newton method. The yield is changed until the estimated price given the yield is close to price.\n\n* An annual coupon rate is used by default.\n\n#### Parameters\n\n**Note:** Scalar inputs will be automatically expanded to match the length of other vector inputs. All vector inputs must be of equal length.\n\n**start**is a scalar or vector of DATE type, indicating the bond’s value date.\n\n**maturity** is a DATE scalar or vector indicating the maturity date.\n\n**issuePrice**is a numeric scalar or vector of the same length as *start* indicating the bond’s issue price. For discount bonds, the actual issue price must be specified (typically less than 100); for other bonds, it is usually 100.\n\n**coupon** is a numeric scalar or vector indicating the annual coupon rate. For example, 0.03 indicates a 3% annual coupon.\n\n**frequency** is an INT scalar/vector indicating the number of payments, or a STRING scalar/vector indicating payment frequency. It can be:\n\n* 0/\"Once\": Bullet payment at maturity.\n* 1/\"Annual\": Annual payments.\n* 2/\"Semiannual\": Semi-annual payments.\n* 4/\"Quarterly\": Quarterly payments.\n* 12/\"Monthly\": Monthly payments.\n\n**dayCountConvention** is a STRING scalar or vector indicating the day count convention to use. It can be:\n\n* \"Thirty360US\": US (NASD) 30/360\n* \"ActualActualISMA\" (default): actual/actual (ISMA rule)\n* \"Actual360\": actual/360\n* \"Actual365\": actual/365\n* \"Thirty360EU\": European 30/360\n* \"ActualActualISDA\" (default): actual/actual (ISDA rule)\n\n**bondType** is a STRING scalar or vector indicating the bond type. It can be:\n\n* \"FixedRate\": Fixed-rate bond, where interest is paid periodically based on the coupon rate.\n* \"Discount\": Discount bond, where no interest is paid, and the bond is issued at a discount. FV at maturity = face value.\n* \"ZeroCoupon\": Zero-coupon bond, where interest and face value are paid at maturity. FV at maturity = face value + interest.\n\n**settlement** is a DATE scalar or vector indicating the settlement date.\n\n**price**is a numeric scalar or vector whose meaning depends on the value of *priceType*:\n\n* When *priceType* is \"CleanPrice\", *price* indicates the bond's clean price.\n* When *priceType* is \"DirtyPrice\", *price* indicates the bond's dirty price.\n\n**priceType** is a STRING scalar or vector used to specify the type of the bond price (*price*). It can be:\n\n* \"CleanPrice\": Clean price.\n* \"DirtyPrice\": Dirty price.\n\n**method** (optional) is a STRING scalar or vector indicating the optimization algorithm used to solve the bond yield. It can be:\n\n* \"newton\" (default): Newton algorithm.\n* \"brent\": Brent algorithm.\n* \"nm\": Nelder-Mead simplex algorithm.\n* \"bfgs\": BFGS algorithm.\n* \"lbfgs\": LBFGS algorithm.\n\n**maxIter** (optional) is a positive integer or a vector of positive integers indicating the maximum number of iterations. The default value is 100.\n\n**benchmark**(optional) is a STRING scalar indicating the reference algorithm. Currently, only \"Excel\" (the algorithm used in Excel) is supported.\n\n#### Returns\n\nA DOUBLE scalar or vector.\n\n#### Examples\n\n```\nbondYield(start=2023.01.01, maturity=2030.12.31, issuePrice=100, coupon=0.05, frequency=1, dayCountConvention=\"ActualActualISMA\", bondType=\"FixedRate\", settlement=2023.04.01, price=100.2143, priceType=\"CleanPrice\", method = ['newton', 'nm', 'brentq', 'bfgs','lbfgs'])\n\n// output: [0.049630,0.049628,0.049630,0.049630,0.049635]\n```\n" }, "bondYieldCurveBuilder": { "url": "https://docs.dolphindb.com/en/Functions/b/bondYieldCurveBuilder.html", "signatures": [ { "full": "bondYieldCurveBuilder(referenceDate, currency, bonds, terms, quotes, dayCountConvention, [compounding='Compounded'], [frequency='Annual'], [curveName], [method='Bootstrap'], [interpMethod='Linear'], [extrapMethod='Flat'])", "name": "bondYieldCurveBuilder", "parameters": [ { "full": "referenceDate", "name": "referenceDate" }, { "full": "currency", "name": "currency" }, { "full": "bonds", "name": "bonds" }, { "full": "terms", "name": "terms" }, { "full": "quotes", "name": "quotes" }, { "full": "dayCountConvention", "name": "dayCountConvention" }, { "full": "[compounding='Compounded']", "name": "compounding", "optional": true, "default": "'Compounded'" }, { "full": "[frequency='Annual']", "name": "frequency", "optional": true, "default": "'Annual'" }, { "full": "[curveName]", "name": "curveName", "optional": true }, { "full": "[method='Bootstrap']", "name": "method", "optional": true, "default": "'Bootstrap'" }, { "full": "[interpMethod='Linear']", "name": "interpMethod", "optional": true, "default": "'Linear'" }, { "full": "[extrapMethod='Flat']", "name": "extrapMethod", "optional": true, "default": "'Flat'" } ] } ], "markdown": "### [bondYieldCurveBuilder](https://docs.dolphindb.com/en/Functions/b/bondYieldCurveBuilder.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\nbondYieldCurveBuilder(referenceDate, currency, bonds, terms, quotes, dayCountConvention, \\[compounding='Compounded'], \\[frequency='Annual'], \\[curveName], \\[method='Bootstrap'], \\[interpMethod='Linear'], \\[extrapMethod='Flat'])\n\n#### Details\n\nBuilds a bond yield curve to be used as a discount curve (i.e., a spot yield curve) in pricing applications.\n\n#### Parameters\n\n**referenceDate** A DATE scalar, representing the reference date of the yield curve.\n\n**currency** A STRING scalar specifying the currency code of the curve. Supported values: \"CNY\", \"USD\", \"EUR\", \"GBP\", \"JPY\", \"HKD\".\n\n**bonds** An INSTRUMENT vector, specifying the sample bonds used for curve construction with bond metadata. See [Bond Product Field Specifications](https://docs.dolphindb.com/en/Functions/b/bondYieldCurveBuilder.html#topic_vw4_kyq_ngc) for details.\n\n**terms** A DURATION vector of the same length as *bonds*, indicating the remaining term to maturity of each bond.\n\n**quotes** A numeric vector of the same length as *bonds*, indicating the yield to maturity (YTM) of each bond on the *referenceDate*.\n\n**dayCountConvention**A STRING scalar indicating the day count convention to use. It can be:\n\n* \"Actual360\": actual/360\n\n* \"Actual365\": actual/365\n\n* \"ActualActualISDA\" —actual/actual according to ISDA (International Swaps and Derivatives Association) convention\n\n* \"ActualActualISMA\" — actual/actual according to ISMA (International Securities Market Association) convention\n\n**compounding** (optional) A STRING scalar defining the compounding method. Options:\n\n* \"Compounded\" (default): Discrete compounding\n\n* \"Simple\": Simple interest\n\n* \"Continuous\": Continuous compounding\n\n**frequency** (optional) A STRING scalar specifying the interest payment frequency. It does not affect curve construction and is only recorded in the returned curve. Supported values:\n\n* \"Annual\" (default): Annually\n\n* \"NoFrequency\": No payment frequency\n\n* \"Once\": Single payment at maturity (for discount bonds and zero coupon bonds only)\n\n* \"Semiannual\": Semiannually\n\n* \"EveryFourthMonth\": Every four months\n\n* \"Quarterly\": Quarterly\n\n* \"BiMonthly\": Every two months\n\n* \"Monthly\": Monthly\n\n* \"EveryFourthWeek\": Every four weeks\n\n* \"BiWeekly\": Every two weeks\n\n* \"Weekly\": Weekly\n\n* \"Daily\": Daily\n\n* \"Other\": Other frequencies\n\n**curveName** (optional) A STRING scalar indicating the yield curve name. The default value is NULL.\n\n**method** (optional) A STRING scalar specifying the curve construction method. Options:\n\n* \"Bootstrap\" (default): Bootstrap method\n\n* \"NS\": Nelson-Siegel model\n\n* \"NSS\": Nelson-Siegel-Svensson model\n\n**interpMethod** (optional) A STRING scalar specifying the interpolation method. Options:\n\n* \"Linear\" (default): Linear interpolation\n\n* \"CubicSpline\": Cubic spline\n\n* \"CubicHermiteSpline\": Cubic Hermite spline\n\n**extrapMethod** (optional) A STRING scalar for the extrapolation method. Options:\n\n* \"Flat\" (default): Flat extrapolation\n\n* \"Linear\": Linear extrapolation\n\n#### Returns\n\nA MKTDATA object.\n\n#### Examples\n\nBuild a yield curve based on the Chinese government bond market data as of August 18, 2025.\n\n```\nbond1 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"DiscountBond\",\n \"instrumentId\": \"259916.IB\",\n \"start\": 2025.03.13,\n \"maturity\": 2025.09.11,\n \"issuePrice\": 99.2070,\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond2 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"240021.IB\",\n \"start\": 2024.10.25,\n \"maturity\": 2025.10.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0133,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond3 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250001.IB\",\n \"start\": 2025.01.15,\n \"maturity\": 2026.01.15,\n \"issuePrice\": 100,\n \"coupon\": 0.0116,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond4 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250013.IB\",\n \"start\": 2025.07.25,\n \"maturity\": 2026.07.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0133,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond5 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250012.IB\",\n \"start\": 2025.06.15,\n \"maturity\": 2027.06.15,\n \"issuePrice\": 100,\n \"coupon\": 0.0138,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond6 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250010.IB\",\n \"start\": 2025.05.25,\n \"maturity\": 2028.05.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0146,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond7 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250014.IB\",\n \"start\": 2025.07.25,\n \"maturity\": 2030.07.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0155,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond8 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"2500802.IB\",\n \"start\": 2025.05.25,\n \"maturity\": 2032.05.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0157,\n \"frequency\": \"Annual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond9 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"250011.IB\",\n \"start\": 2025.05.25,\n \"maturity\": 2035.05.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0167,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond10 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"2400102.IB\",\n \"start\": 2024.08.29,\n \"maturity\": 2039.08.29,\n \"issuePrice\": 100,\n \"coupon\": 0.0225,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond11 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"2500004.IB\",\n \"start\": 2025.07.15,\n \"maturity\": 2045.07.15,\n \"issuePrice\": 100,\n \"coupon\": 0.0192,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond12 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"2500005.IB\",\n \"start\": 2025.07.15,\n \"maturity\": 2055.07.15,\n \"issuePrice\": 100,\n \"coupon\": 0.019,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond13 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"200007.IB\",\n \"start\": 2020.05.25,\n \"maturity\": 2070.05.25,\n \"issuePrice\": 100,\n \"coupon\": 0.0373,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\nbond14 = {\n \"productType\": \"Cash\",\n \"assetType\": \"Bond\",\n \"bondType\": \"FixedRateBond\",\n \"instrumentId\": \"2400003.IB\",\n \"start\": 2024.06.15,\n \"maturity\": 2074.06.15,\n \"issuePrice\": 100,\n \"coupon\": 0.0253,\n \"frequency\": \"Semiannual\",\n \"dayCountConvention\": \"ActualActualISDA\"\n}\n\nreferenceDate = 2025.08.18\nbondsTmp = [bond1, bond2, bond3, bond4, bond5, bond6, bond7, bond8, bond9,\n bond10, bond11, bond12, bond13, bond14]\nbonds = parseInstrument(bondsTmp)\n\n```\n\nThis example uses the standard tenors from the China Foreign Exchange Trade System (CFETS, [CFETS Closing Yield Curves- Historical Data - CFETS](https://www.chinamoney.com.cn/english/bmkycvcyccyccychdt/index.html?bondType=CYCC000\\&reference=1)), with sample bonds’ remaining terms and quotes being simulated.\n\n```\nterms = [1M, 3M, 6M, 1y, 2y, 3y, 5y, 7y, 10y, 15y, 20y, 30y, 40y, 50y]\nquotes=[1.3000, 1.3700, 1.3898, 1.3865, 1.4296, 1.4466, 1.6348, \n 1.7557, 1.7875, 1.9660, 2.1300, 2.1100, 2.1556, 2.1750]/100\n \n// method = \"BoostStarp\"\nbootstrapCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='Bootstrap')\nbootstrapCurveDict = extractMktData(bootstrapCurve)\nprint(bootstrapCurveDict)\n\n// method = \"NS\"\nnsCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='NS')\nnsCurveDict = extractMktData(nsCurve)\nprint(nsCurveDict)\n\n// method = \"NSS\"\nnssCurve = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms, quotes, \"ActualActualISDA\", method='NSS')\nnssCurveDict=extractMktData(nssCurve)\nprint(nssCurveDict)\n\n```\n\nIn practice, the remaining term should be calculated as the difference between the bond’s maturity date and the curve reference date, and the actual YTM quotes should be used to construct the curve, in accordance with CFETS bond closing valuation([Bond Valuation Dynamic and Closing - CFETS](https://www.chinamoney.com.cn/english/bmkbvl/) ).\n\n```\nterms2 = array(DURATION)\nfor(bond in bondsTmp){\n term = duration(string(bond[\"maturity\"] - referenceDate)+\"d\")\n terms2.append!(term)\n}\n\nquotes2 = [1.2799, 1.3440, 1.3450, 1.3849, 1.4200, 1.4450, 1.6295, \n 1.7350, 1.7860, 2.0493, 2.1304, 2.1140, 2.1558, 2.1728] / 100\n \n// method = \"BoostStarp\"\nbootstrapCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\", method='Bootstrap')\nbootstrapCurveDict2 = extractMktData(bootstrapCurve2)\nprint(bootstrapCurveDict2)\n\n// method = \"NS\"\nnsCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\", method='NS')\nnsCurveDict2 = extractMktData(nsCurve2)\nprint(nsCurveDict2)\n\n// method = \"NSS\"\nnssCurve2 = bondYieldCurveBuilder(referenceDate, `CNY, bonds, terms2, quotes2, \"ActualActualISDA\",method='NSS')\nnssCurveDict2 =extractMktData(nssCurve2)\nprint(nssCurveDict2)\n```\n\n**Related functions:** [extractMktData](https://docs.dolphindb.com/en/Functions/e/extractMktData.html), [parseInstrument](https://docs.dolphindb.com/en/Functions/p/parseInstrument.html)\n\n#### Bond Product Field Specifications\n\n**Discount Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"DiscountBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\nissuePrice\n\n\n\nDOUBLE\n\n\n\nIssue price\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
**Zero Coupon Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"ZeroCouponBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ncoupon\n\n\n\nDOUBLE\n\n\n\nCoupon rate, e.g., 0.03 means 3%\n\n\n\n√\n\n
\n\nfrequency\n\n\n\nSTRING\n\n\n\nFrequency of interest payment\n\n\n\n×\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
**Fixed Rate Bond**\n\n\n
\n\nField Name\n\n\n\nData Type\n\n\n\nDescription\n\n\n\nRequired\n\n
\n\nproductType\n\n\n\nSTRING\n\n\n\nMust be \"Cash\"\n\n\n\n√\n\n
\n\nassetType\n\n\n\nSTRING\n\n\n\nMust be \"Bond\"\n\n\n\n√\n\n
\n\nbondType\n\n\n\nSTRING\n\n\n\nMust be \"FixedRateBond\"\n\n\n\n√\n\n
\n\nnominal\n\n\n\nDOUBLE\n\n\n\nNominal amount, defalut 100\n\n\n\n×\n\n
\n\ninstrumentId\n\n\n\nSTRING\n\n\n\nBond code, e.g., \"259926.IB\"\n\n\n\n×\n\n
\n\nstart\n\n\n\nDATE\n\n\n\nValue date\n\n\n\n√\n\n
\n\nmaturity\n\n\n\nDATE\n\n\n\nMaturity date\n\n\n\n√\n\n
\n\ncoupon\n\n\n\nDOUBLE\n\n\n\nCoupon rate, e.g., 0.03 means 3%\n\n\n\n√\n\n
\n\nfrequency\n\n\n\nSTRING\n\n\n\nFrequency of interest payment\n\n\n\n√\n\n
\n\ndayCountConvention\n\n\n\nSTRING\n\n\n\nThe day count convention. It can be: \"ActualActualISDA\", \"ActualActualISMA\",\" Actual365\", \"Actual360\"\n\n\n\n√\n\n
\n\ncurrency\n\n\n\nSTRING\n\n\n\nCurrency, defaults to \"CNY\"\n\n\n\n×\n\n
\n\ncashFlow\n\n\n\nTABLE\n\n\n\nCash flow table\n\n\n\n×\n\n
\n\ndiscountCurve\n\n\n\nSTRING\n\n\n\nThe discount curve, e.g., \"CNY\\_TRASURY\\_BOND\"\n\n\n\n×\n\n
\n\nspreadCurve\n\n\n\nSTRING\n\n\n\nThe credit spread curve\n\n\n\n×\n\n
\n\nsubType\n\n\n\nSTRING\n\n\n\nSubtypes. China's bonds include:\n\n* \"TREASURY\\_BOND\": Treasury Bonds\n\n* \"CENTRAL\\_BANK\\_BILL\": Central Bank Bills\n\n* \"CDB\\_BOND\": Policy Bank Financial Bonds (China Development Bank)\n\n* \"EIBC\\_BOND\": Policy Bank Financial Bonds (Export-Import Bank of China)\n\n* \"ADBC\\_BOND\": Policy Bank Financial Bonds (Agricultural Development Bank of China)\n\n* \"MTN\": Medium-term Notes\n\n* \"CORP\\_BOND\": Corporate Bonds\n\n* \"UNSECURED\\_CORP\\_BOND\": Unsecured Corporate Bonds\n\n* \"SHORT\\_FIN\\_BOND\": Short-term Financing Bills\n\n* \"NCD\": Negotiable Certificates of Deposit\n\n* \"LOC\\_GOV\\_BOND\": Local Government Bonds\n\n* \"COMM\\_BANK\\_FIN\\_BOND\": Commercial Bank Financial Bonds\n\n* \"BANK\\_SUB\\_CAP\\_BOND\": Bank Subordinated Capital Bonds\n\n* \"ABS\": Asset-backed Securities\n\n* \"PPN\": Privately Offered Bonds\n\n\n\n×\n\n
\n\ncreditRating\n\n\n\nSTRING\n\n\n\nCredit rating. It can be: \"B\", \"BB\", \"BBB\", \"BBB+\", \"A-\", \"A\", \"A+\", \"AA-\", \"AA\", \"AA+\", \"AAA-\", \"AAA\", \"AAA+\"\n\n\n\n×\n\n
\n" }, "bool": { "url": "https://docs.dolphindb.com/en/Functions/b/bool.html", "signatures": [ { "full": "bool(X)", "name": "bool", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [bool](https://docs.dolphindb.com/en/Functions/b/bool.html)\n\n\n\n#### Syntax\n\nbool(X)\n\n#### Details\n\nConvert the input to a Boolean value.\n\n#### Parameters\n\n**X** can be of any data type.\n\n#### Returns\n\nBOOL type with the same data form as *X*.\n\n#### Examples\n\n```\nx=bool()\nx;\n// output: 00b\n\ntypestr x\n// output: BOOL\n\nbool(`true`false)\n// output: [1,0]\n\nbool(100.2)\n// output: 1\n\nbool(0)\n// output: 0\n```\n" }, "boxcox": { "url": "https://docs.dolphindb.com/en/Functions/b/boxcox.html", "signatures": [ { "full": "boxcox(X, [lmbda])", "name": "boxcox", "parameters": [ { "full": "X", "name": "X" }, { "full": "[lmbda]", "name": "lmbda", "optional": true } ] } ], "markdown": "### [boxcox](https://docs.dolphindb.com/en/Functions/b/boxcox.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nboxcox(X, \\[lmbda])\n\n#### Details\n\nThis function transforms *X* by using the Box-Cox transformation method.\n\nThe Box-Cox transform is given by:\n\n![](https://docs.dolphindb.com/en/Functions/images/boxcox.png)\n\nDifference from Python’s `scipy.stats.boxcox`: Both functions can perform a Box-Cox transformation and estimate the optimal lambda when *lmbda* is not specified. In DolphinDB, *lmbda* can be a scalar or vector, and a vector *lmbda* applies the transformation element by element. SciPy also supports the *alpha* confidence interval and *optimizer* arguments.\n\n#### Parameters\n\n**X** is a numeric vector representing the input to be transformed. If the *lmbda* parameter is not specified, *X*cannot contain null or non-positivevalues, and all elements cannot be identical.\n\n**lmbda**(optional) is a numeric scalar or vector representing the lambda parameter. If it is a vector, *X* and *lmbda* must be of equal length.\n\n#### Returns\n\n* If the *lmbda* parameter is specified, the function returns a vector of DOUBLE type.\n * if *lmbda* is a scalar, the result is the Box-Cox transformation of *X* using *lmbda*.\n * if *lmbda* is a vector, the result is a vector where each element corresponds to `boxcox(Xi, lmbdai)`.\n* If the *lmbda* parameter is not specified, the function returns a 2-element tuple:\n * The first element is a vector of DOUBLE type, representing the Box-Cox transformation of *X*.\n * The second element is a scalar of DOUBLE type, representing the optimal lambda parameter.\n\n#### Examples\n\n```\ndata = [1.5, 2.3, 3.1, 4.8, 5.5, 6.7, 8.2, 9.0, 10.1, 12.4]\nlmb = 2\nboxcox(data)\n\n// output: ([0.4541,1.0562,1.5689,2.4892,2.82394,3.3559,3.9636,4.267,4.6653,5.4393],0.5495)\n\nboxcox(data, lmb)\n// output: [0.625,2.145,4.305,11.02,14.625,21.945,33.12,40,50.505,76.38]\n```\n" }, "brentq": { "url": "https://docs.dolphindb.com/en/Functions/b/brentq.html", "signatures": [ { "full": "brentq(f, a, b, [xtol], [rtol], [maxIter], [funcDataParam])", "name": "brentq", "parameters": [ { "full": "f", "name": "f" }, { "full": "a", "name": "a" }, { "full": "b", "name": "b" }, { "full": "[xtol]", "name": "xtol", "optional": true }, { "full": "[rtol]", "name": "rtol", "optional": true }, { "full": "[maxIter]", "name": "maxIter", "optional": true }, { "full": "[funcDataParam]", "name": "funcDataParam", "optional": true } ] } ], "markdown": "### [brentq](https://docs.dolphindb.com/en/Functions/b/brentq.html)\n\n\n\n#### Syntax\n\nbrentq(f, a, b, \\[xtol], \\[rtol], \\[maxIter], \\[funcDataParam])\n\n#### Details\n\nFind a root x0 of a function*f*in a bracketing interval \\[a, b] using Brent's method.\n\nDifference from Python’s `scipy.optimize.brentq`: Both functions use Brent’s method to find a root in an interval where the function changes sign. DolphinDB returns a result of length 2 containing a status string and the root, and passes additional arguments through the *funcDataParam* vector. SciPy returns the root by default, returns the root and a `RootResults` object when *full\\_output*=True, and passes additional arguments through the *args* tuple.\n\n#### Parameters\n\n**f** is a function which returns a number. The function *f*must be continuous in \\[a,b], and *f(a)* and *f(b)* must have opposite signs.\n\n**a** is a numeric scalar that specifies the left boundary of the bracketing interval \\[a,b].\n\n**b** is a numeric scalar that specifies the right boundary of the bracketing interval \\[a,b].\n\n**xtol** / **rtol** (optional) are numeric scalars that specify the precision of the computed root. The computed root x0 satisfies `|x-x0| <= (xtol + rtol* |x0|)`, where x is the exact root. The default value of *xtol*is 2e-12, and the default value of *rtol*is 4 times the machine epsilon in double precision.\n\n**maxIter** (optional) is an integer indicating the maximum iterations. The default value is 100.\n\n**funcDataParam** (optional) is a vector containing extra arguments for the function *f*.\n\n#### Returns\n\nReturns a vector res of length 2.\n\n* res\\[0] is a STRING scalar indicating the convergence information, which can be:\n\n * CONVERGED: converged.\n\n * SIGNERR: sign error.\n\n * CONVERR: convergence error.\n\n* res\\[1] is a number representing the root of *f* between *a* and *b*.\n\n#### Examples\n\nFind the root of f(x) = x^2 - 1 in \\[-2,0] and \\[0,2].\n\n```\ndef f(x) {\n return (pow(x, 2) - 1)\n}\n\nroot1 = brentq(f, -2, 0)\nroot2 = brentq(f, 0, 2)\nprint(\"root1 : \", root1)\nprint(\"root2 : \", root2)\n\n/* output\nroot1 :\n(\"CONVERGED\",-1)\nroot2 :\n(\"CONVERGED\",1)\n*/\n```\n\nFind the root of f(x,b) with extra arguments in the \\[0,2].\n\n```\ndef f(x, b) {\n return (pow(x, 2) - b)\n}\nroot = brentq(f, 0, 2, 2e-12, 1e-9, 100, [2])\nprint(\"root : \", root)\n\n/* output\nroot : \n(\"CONVERGED\",1.414213562373136)\n*/\n```\n" }, "brute": { "url": "https://docs.dolphindb.com/en/Functions/b/brute.html", "signatures": [ { "full": "brute(func, ranges, [ns=20], [finish=fmin])", "name": "brute", "parameters": [ { "full": "func", "name": "func" }, { "full": "ranges", "name": "ranges" }, { "full": "[ns=20]", "name": "ns", "optional": true, "default": "20" }, { "full": "[finish=fmin]", "name": "finish", "optional": true, "default": "fmin" } ] } ], "markdown": "### [brute](https://docs.dolphindb.com/en/Functions/b/brute.html)\n\n\n\n#### Syntax\n\nbrute(func, ranges, \\[ns=20], \\[finish=fmin])\n\n#### Details\n\nMinimize a function over a given range by brute force. Use the \"brute force\" method, i.e., compute the function's value at each point of a multidimensional grid of points, to find the global minimum of the function.\n\n**Note:** The brute force approach is inefficient because the number of grid points increases exponentially. Consequently, even in cases where the grid spacing is coarse, or the problem is only of medium size, it can take a long time to run, and/or run into memory limitations.\n\nDifference from Python’s `scipy.optimize.brute`: Both functions perform grid-search minimization and can run a subsequent optimizer. DolphinDB’s *ranges* uses `(low, high)` or `(low, high, num)` tuples and returns a dictionary containing `xopt` and `fopt`. SciPy supports slice-based grids, *args*, *full\\_output*, *workers*, and can return the grid and function value arrays.\n\n#### Parameters\n\n**func** is the name of the function to be minimized. Note that its return value must be a numeric scalar.\n\n**ranges** is a tuple of tuples. Each tuple element can take the following forms:\n\n* (low, high): Specifies the minimum and maximum values for a parameter.\n\n* (low, high, num): Also includes the number of grid points between *low* and *high*.\n\n**ns**(optional) is a positive number indicating the number of grid points along the axes. If *ranges* is specified as *(low, high, num)*, *num* determines the number of points. Otherwise, *ns* is used, defaulting to 20 if not provided.\n\n**finish** (optional) is an optimization function that is called with the result of brute force minimization as initial guess. *finish* should be a function that returns a dictionary that contains keys 'xopt' and 'fopt' and their values should be numeric. The default value is the `fmin` function. If set to NULL, no \"polishing\" function is applied and the result of `brute` is returned directly.\n\n#### Returns\n\nIt returns a dictionary with the following members:\n\n* xopt: Parameter that minimizes function.\n\n* fopt: Value of function at minimum: `fopt = f(xopt)`.\n\n#### Examples\n\nCalculate the minimum of function `f` within *ranges*.\n\n```\ndef f(z) {\n\ta = 2\n\tb = 3\n\tc = 7\n\td = 8\n\tee = 9\n\tf = 10\n\tg = 44\n\th = -1\n\ti = 2\n\tj = 26\n\tk = 1\n\tl = -2\n\tscale = 0.5\n\tx = z[0]\n\ty = z[1]\n\tf1 = a * square(x) + b * x * y + c * square(y) + d * x + ee* y + f\n\tf2 = -g * exp(-(square(x-h)+square(y-i)) / scale)\n\tf3 = -j * exp(-(square(x-k)+square(y-l)) / scale)\n\treturn f1+f2+f3\n}\nranges=((-4, 3.75),(-4, 3.75))\nbrute(f, ranges, 32)\n\n/* Ouput:\n\nfopt->-3.408581876799\nxopt->[-1.056651921797,1.808348429512]\n\n*/\n```\n" }, "bucket": { "url": "https://docs.dolphindb.com/en/Functions/b/bucket.html", "signatures": [ { "full": "bucket(vector, dataRange, bucketNum, [includeOutbound=false])", "name": "bucket", "parameters": [ { "full": "vector", "name": "vector" }, { "full": "dataRange", "name": "dataRange" }, { "full": "bucketNum", "name": "bucketNum" }, { "full": "[includeOutbound=false]", "name": "includeOutbound", "optional": true, "default": "false" } ] } ], "markdown": "### [bucket](https://docs.dolphindb.com/en/Functions/b/bucket.html)\n\n\n\n#### Syntax\n\nbucket(vector, dataRange, bucketNum, \\[includeOutbound=false])\n\n#### Details\n\nReturn a vector with the same length as the input *vector*. Each element of the result indicates which bucket each of the elements of the input vector belongs to, based on the bucket classification rules given by *dataRange* and *bucketNum*.\n\nFor example, if *dataRange* is 0:10, *bucketNum* is 2, and *includeOutbound* is unspecified, we have two buckets: \\[0, 5) and \\[5,10). Any value <0 or >=10 will be coded as a null integer. If *includeOutbound* is set to be true, the example above will generate 4 buckets: <0, \\[0, 5), \\[5,10), >=10.\n\n#### Parameters\n\n**vector** is a numeric or temporal vector.\n\n**dataRange** is a pair indicating the data range, which includes the lower bound and excludes the upper bound.\n\n**bucketNum** is the number of buckets. When *dataRange* is specified as an INT PAIR, its range must be a multiple of *bucketNum*.\n\n**includeOutbound** (optional) is a Boolean value indicating whether to include the bucket below the lower bound of the data range and the bucket beyond the upper bound of the data range. The default value is false.\n\n#### Returns\n\nAn INT vector with the same length as *vector*.\n\n#### Examples\n\n```\nbucket(9 23 54 36 46 12, 12:54, 2);\n// output: [,0,,1,1,0]\n\nbucket(9 23 54 36 46 12, 12:54, 2, 1);\n// output: [0,1,3,2,2,1]\n```\n" }, "bucketCount": { "url": "https://docs.dolphindb.com/en/Functions/b/bucketCount.html", "signatures": [ { "full": "bucketCount(vector, dataRange, bucketNum, [includeOutbound=false])", "name": "bucketCount", "parameters": [ { "full": "vector", "name": "vector" }, { "full": "dataRange", "name": "dataRange" }, { "full": "bucketNum", "name": "bucketNum" }, { "full": "[includeOutbound=false]", "name": "includeOutbound", "optional": true, "default": "false" } ] } ], "markdown": "### [bucketCount](https://docs.dolphindb.com/en/Functions/b/bucketCount.html)\n\n\n\n#### Syntax\n\nbucketCount(vector, dataRange, bucketNum, \\[includeOutbound=false])\n\n#### Details\n\nAccept the same set of parameters as the function [bucket](https://docs.dolphindb.com/en/Functions/b/bucket.html) and return the count for each bucket.\n\n#### Parameters\n\n**vector** is a numeric or temporal vector.\n\n**dataRange** is a pair indicating the data range, which includes the lower bound and excludes the upper bound.\n\n**bucketNum** is the number of buckets. When *dataRange* is specified as an INT PAIR, its range must be a multiple of *bucketNum*.\n\n**includeOutbound** (optional) is a Boolean value indicating whether to include the bucket below the lower bound of the data range and the bucket beyond the upper bound of the data range. The default value is false.\n\n#### Returns\n\nAn INT vector.\n\n#### Examples\n\n```\nbucketCount(9 23 54 36 46 12, 12:54, 2);\n// output: [2,2]\n\nbucketCount(9 23 54 36 46 12, 12:54, 2, 1);\n// output: [1,2,2,1]\n```\n" }, "businessDay": { "url": "https://docs.dolphindb.com/en/Functions/b/businessDay.html", "signatures": [ { "full": "businessDay(X, [offset], [n=1])", "name": "businessDay", "parameters": [ { "full": "X", "name": "X" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessDay](https://docs.dolphindb.com/en/Functions/b/businessDay.html)\n\n\n\n#### Syntax\n\nbusinessDay(X, \\[offset], \\[n=1])\n\n#### Details\n\nIf *X* is a business day (Monday to Friday), return date(X). Otherwise, return the most recent business day.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates dates based on periods consisting of *n* business days. In this case, *offset* determines how the business-day periods are aligned. Specifically, the system first calculates the business day corresponding to *offset* and uses that day as the reference point. A new period boundary is then generated every *n* business days, and the function returns the business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**offset** (optional) is a scalar of the same data type as *X*. It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessDay(2019.01.06);\n// output: 2019.01.04\n\nbusinessDay(2019.01.04);\n// output: 2019.01.04\n\ndate=2019.01.06 + 1..10\nbusinessDay = businessDay(date)\nbusinessDay2 = businessDay(date,min(date),2)\ntable(date, businessDay, businessDay2);\n```\n\n| date | businessDay | businessDay2 |\n| ---------- | ----------- | ------------ |\n| 2019.01.07 | 2019.01.07 | 2019.01.07 |\n| 2019.01.08 | 2019.01.08 | 2019.01.07 |\n| 2019.01.09 | 2019.01.09 | 2019.01.09 |\n| 2019.01.10 | 2019.01.10 | 2019.01.09 |\n| 2019.01.11 | 2019.01.11 | 2019.01.11 |\n| 2019.01.12 | 2019.01.11 | 2019.01.11 |\n| 2019.01.13 | 2019.01.11 | 2019.01.11 |\n| 2019.01.14 | 2019.01.14 | 2019.01.11 |\n| 2019.01.15 | 2019.01.15 | 2019.01.15 |\n| 2019.01.16 | 2019.01.16 | 2019.01.15 |\n" }, "businessMonthBegin": { "url": "https://docs.dolphindb.com/en/Functions/b/businessMonthBegin.html", "signatures": [ { "full": "businessMonthBegin(X, [offset], [n=1])", "name": "businessMonthBegin", "parameters": [ { "full": "X", "name": "X" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessMonthBegin](https://docs.dolphindb.com/en/Functions/b/businessMonthBegin.html)\n\n\n\n#### Syntax\n\nbusinessMonthBegin(X, \\[offset], \\[n=1])\n\n#### Details\n\nReturn the first business day (Monday to Friday) of the month that *X* belongs to.\n\nBy default, each period corresponds to a calendar month, and the function returns the first business day of the month containing*X*. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days. Public holidays and exchange trading calendars are not taken into account.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates period start dates based on n-month periods. In this case, *offset* determines how the multi-month periods are aligned. Specifically, the system first calculates the first business day of the month containing *offset* and uses that date as the reference point. A new period boundary is then generated every *n* months, and the function returns the first business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**offset** (optional) is a scalar of the same data type as *X*. It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessMonthBegin(2018.09.12);\n// output: 2018.09.03\n\nbusinessMonthBegin(2018.09.12, 2018.07.12, 3);\n// output: 2018.07.02\n\ndate=2016.04.12+(1..10)*30\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n| date | time | sym | qty | price |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.05.12 | 09:30:00 | MSFT | 2200 | 49.6 |\n| 2016.06.11 | 09:30:00 | MSFT | 1900 | 29.46 |\n| 2016.07.11 | 09:30:00 | MSFT | 2100 | 29.52 |\n| 2016.08.10 | 09:30:00 | MSFT | 3200 | 30.02 |\n| 2016.09.09 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.10.09 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.11.08 | 09:30:00 | MSFT | 1300 | 50.76 |\n| 2016.12.08 | 09:30:00 | MSFT | 2500 | 50.32 |\n| 2017.01.07 | 09:30:00 | MSFT | 8800 | 51.29 |\n| 2017.02.06 | 09:30:00 | MSFT | 4500 | 52.38 |\n\n```\nselect avg(price),sum(qty) from t1 group by businessMonthBegin(date,2016.01.01,2);\n```\n\n| businessMonthBegin\\_date | avg\\_price | sum\\_qty |\n| ------------------------ | ---------- | -------- |\n| 2016.05.02 | 39.53 | 4100 |\n| 2016.07.01 | 29.77 | 5300 |\n| 2016.09.01 | 175.1 | 12200 |\n| 2016.11.01 | 50.54 | 3800 |\n| 2017.01.02 | 51.835 | 13300 |\n\nRelated functions: [businessMonthEnd](https://docs.dolphindb.com/en/Functions/b/businessMonthEnd.html), [monthBegin](https://docs.dolphindb.com/en/Functions/m/monthBegin.html), [monthEnd](https://docs.dolphindb.com/en/Functions/m/monthEnd.html), [semiMonthBegin](https://docs.dolphindb.com/en/Functions/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.com/en/Functions/s/semiMonthEnd.html)\n" }, "businessMonthEnd": { "url": "https://docs.dolphindb.com/en/Functions/b/businessMonthEnd.html", "signatures": [ { "full": "businessMonthEnd(X, [offset], [n=1])", "name": "businessMonthEnd", "parameters": [ { "full": "X", "name": "X" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessMonthEnd](https://docs.dolphindb.com/en/Functions/b/businessMonthEnd.html)\n\n\n\n#### Syntax\n\nbusinessMonthEnd(X, \\[offset], \\[n=1])\n\n#### Details\n\nReturn the last business day (Monday to Friday) of the month that *X* belongs to.\n\nBy default, each period corresponds to a calendar month, and the function returns the last business day of the month containing*X*. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days. Public holidays and exchange trading calendars are not taken into account.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates period end dates based on n-month periods. In this case, *offset* determines how the multi-month periods are aligned. Specifically, the system first calculates the last business day of the month containing *offset* and uses that date as the reference point. A new period boundary is then generated every *n* months, and the function returns the last business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**offset** (optional) is a scalar of the same data type as *X*. It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessMonthEnd(2010.10.12);\n// output: 2010.10.29\n\nbusinessMonthEnd(2010.10.12, 2000.03.31, 3);\n// output: 2010.12.31\n\ndate=2016.04.12+(1..10)*30\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\nt1;\n```\n\n| date | time | sym | qty | price |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2016.05.12 | 09:30:00 | MSFT | 2200 | 49.6 |\n| 2016.06.11 | 09:30:00 | MSFT | 1900 | 29.46 |\n| 2016.07.11 | 09:30:00 | MSFT | 2100 | 29.52 |\n| 2016.08.10 | 09:30:00 | MSFT | 3200 | 30.02 |\n| 2016.09.09 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2016.10.09 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2016.11.08 | 09:30:00 | MSFT | 1300 | 50.76 |\n| 2016.12.08 | 09:30:00 | MSFT | 2500 | 50.32 |\n| 2017.01.07 | 09:30:00 | MSFT | 8800 | 51.29 |\n| 2017.02.06 | 09:30:00 | MSFT | 4500 | 52.38 |\n\n```\nselect avg(price),sum(qty) from t1 group by businessMonthEnd(date,2016.01.31,2);\n```\n\n| businessMonthEnd\\_date | avg\\_price | sum\\_qty |\n| ---------------------- | ---------- | -------- |\n| 2016.06.30 | 39.53 | 4100 |\n| 2016.08.31 | 29.77 | 5300 |\n| 2016.10.31 | 175.1 | 12200 |\n| 2016.12.30 | 50.54 | 3800 |\n| 2017.02.28 | 51.835 | 13300 |\n\nRelated functions: [businessMonthBegin](https://docs.dolphindb.com/en/Functions/b/businessMonthBegin.html), [monthBegin](https://docs.dolphindb.com/en/Functions/m/monthBegin.html), [monthEnd](https://docs.dolphindb.com/en/Functions/m/monthEnd.html), [semiMonthBegin](https://docs.dolphindb.com/en/Functions/s/semiMonthBegin.html), [semiMonthEnd](https://docs.dolphindb.com/en/Functions/s/semiMonthEnd.html)\n" }, "businessQuarterBegin": { "url": "https://docs.dolphindb.com/en/Functions/b/businessQuarterBegin.html", "signatures": [ { "full": "businessQuarterBegin(X, [startingMonth=1], [offset], [n=1])", "name": "businessQuarterBegin", "parameters": [ { "full": "X", "name": "X" }, { "full": "[startingMonth=1]", "name": "startingMonth", "optional": true, "default": "1" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessQuarterBegin](https://docs.dolphindb.com/en/Functions/b/businessQuarterBegin.html)\n\n\n\n#### Syntax\n\nbusinessQuarterBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### Details\n\nReturn the first business day (Monday to Friday) of the quarter that *X* belongs to. The first months of the quarters are determined by *startingMonth*. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates dates based on periods consisting of *n* quarters. In this case, *offset* determines how the multi-quarter periods are aligned. Specifically, the system first calculates the first business day of the quarter containing *offset* according to *startingMonth*, and uses that date as the reference point. A new period start boundary is then generated every *n* quarters, and the function returns the first business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**startingMonth** (optional) is an integer between 1 and 12 that specifies the starting month of the first quarter in a year. The default value is 1, which represents calendar quarters, i.e., January–March, April–June, July–September, and October–December.\n\n**offset** (optional) is a scalar of the same data type as *X*. It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessQuarterBegin(2012.06.12);\n// output: 2012.04.02\n\nbusinessQuarterBegin(2012.06.12, 3);\n// output: 2012.06.01\n\nbusinessQuarterBegin(2012.06.12, 8, 2011.08.01, 3);\n// output: 2012.05.01\n\ndate=2011.04.25+(1..10)*90\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date | time | sym | qty | price |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2011.07.24 | 09:30:00 | MSFT | 2200 | 49.6 |\n| 2011.10.22 | 09:30:00 | MSFT | 1900 | 29.46 |\n| 2012.01.20 | 09:30:00 | MSFT | 2100 | 29.52 |\n| 2012.04.19 | 09:30:00 | MSFT | 3200 | 30.02 |\n| 2012.07.18 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2013.01.14 | 09:30:00 | MSFT | 1300 | 50.76 |\n| 2013.04.14 | 09:30:00 | MSFT | 2500 | 50.32 |\n| 2013.07.13 | 09:30:00 | MSFT | 8800 | 51.29 |\n| 2013.10.11 | 09:30:00 | MSFT | 4500 | 52.38 |\n\n```\nselect avg(price),sum(qty) from t1 group by businessQuarterBegin(date, 10, 2010.10.01, 2);\n```\n\n| businessQuarterBegin\\_date | avg\\_price | sum\\_qty |\n| -------------------------- | ---------- | -------- |\n| 2011.04.01 | 49.6 | 2200 |\n| 2011.10.03 | 29.49 | 4000 |\n| 2012.04.02 | 102.495 | 10000 |\n| 2012.10.01 | 112.995 | 6700 |\n| 2013.04.01 | 50.805 | 11300 |\n| 2013.10.01 | 52.38 | 4500 |\n\nRelated functions: [businessQuarterEnd](https://docs.dolphindb.com/en/Functions/b/businessQuarterEnd.html), [quarterBegin](https://docs.dolphindb.com/en/Functions/q/quarterBegin.html), [quarterEnd](https://docs.dolphindb.com/en/Functions/q/quarterEnd.html)\n" }, "businessQuarterEnd": { "url": "https://docs.dolphindb.com/en/Functions/b/businessQuarterEnd.html", "signatures": [ { "full": "businessQuarterEnd(X, [endingMonth=12], [offset], [n=1])", "name": "businessQuarterEnd", "parameters": [ { "full": "X", "name": "X" }, { "full": "[endingMonth=12]", "name": "endingMonth", "optional": true, "default": "12" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessQuarterEnd](https://docs.dolphindb.com/en/Functions/b/businessQuarterEnd.html)\n\n\n\n#### Syntax\n\nbusinessQuarterEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### Details\n\nReturn the last day of the quarter that *X* belongs to. The last months of the quarters are determined by *endingMonth*. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates dates based on periods consisting of *n* quarters. In this case, *offset* determines how the multi-quarter periods are aligned. Specifically, the system first calculates the last business day of the quarter containing *offset* according to *endingMonth*, and uses that date as the reference point. A new period-ending boundary is then generated every *n* quarters, and the function returns the last business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**endingMonth** (optional) is an integer between 1 and 12 specifies the ending month of the last quarter in a year. The default value is 12, which represents calendar quarters, i.e., January–March, April–June, July–September, and October–December.\n\n**offset** (optional) is a scalar of the same data type as *X*, It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```language-python\nbusinessQuarterEnd(2012.04.12);\n// output: 2012.06.30\n\nbusinessQuarterEnd(2012.04.12, 2);\n// output: 2012.05.31\n\nbusinessQuarterEnd(2012.04.12, 8, 2011.08.01, 3);\n// output: 2012.05.31\n\ndate=2011.04.25+(1..10)*90\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date | time | sym | qty | price |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2011.07.24 | 09:30:00 | MSFT | 2200 | 49.6 |\n| 2011.10.22 | 09:30:00 | MSFT | 1900 | 29.46 |\n| 2012.01.20 | 09:30:00 | MSFT | 2100 | 29.52 |\n| 2012.04.19 | 09:30:00 | MSFT | 3200 | 30.02 |\n| 2012.07.18 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2012.10.16 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2013.01.14 | 09:30:00 | MSFT | 1300 | 50.76 |\n| 2013.04.14 | 09:30:00 | MSFT | 2500 | 50.32 |\n| 2013.07.13 | 09:30:00 | MSFT | 8800 | 51.29 |\n| 2013.10.11 | 09:30:00 | MSFT | 4500 | 52.38 |\n\n```language-python\nselect avg(price),sum(qty) from t1 group by businessQuarterEnd(date, , 2010.06.01, 2)\n```\n\n| businessQuarterEnd\\_date | avg\\_price | sum\\_qty |\n| ------------------------ | ---------- | -------- |\n| 2011.12.30 | 39.53 | 4100 |\n| 2012.06.29 | 29.77 | 5300 |\n| 2012.12.31 | 175.1 | 12200 |\n| 2013.06.28 | 50.54 | 3800 |\n| 2013.12.31 | 51.835 | 13300 |\n\nRelated functions: [businessQuarterBegin](https://docs.dolphindb.com/en/Functions/b/businessQuarterBegin.html), [quarterBegin](https://docs.dolphindb.com/en/Functions/q/quarterBegin.html), [quarterEnd](https://docs.dolphindb.com/en/Functions/q/quarterEnd.html)\n" }, "businessYearBegin": { "url": "https://docs.dolphindb.com/en/Functions/b/businessYearBegin.html", "signatures": [ { "full": "businessYearBegin(X, [startingMonth=1], [offset], [n=1])", "name": "businessYearBegin", "parameters": [ { "full": "X", "name": "X" }, { "full": "[startingMonth=1]", "name": "startingMonth", "optional": true, "default": "1" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessYearBegin](https://docs.dolphindb.com/en/Functions/b/businessYearBegin.html)\n\n\n\n#### Syntax\n\nbusinessYearBegin(X, \\[startingMonth=1], \\[offset], \\[n=1])\n\n#### Details\n\nReturn the first business day (Monday to Friday) of the year that *X* belongs to and that starts in the month of *startingMonth*.\n\nBy default, each period corresponds to one year, and the function returns the first business day of the year containing *X*. The starting month of the year is determined by the *startingMonth* parameter. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates period start dates based on n-year periods. In this case, *offset* determines how multi-year periods are aligned. Specifically, the system first calculates the first business day of the year containing *offset* according to *startingMonth*, and uses that date as the reference point. A new period start boundary is then generated every *n* years, and the function returns the first business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**startingMonth** (optional) is an integer between 1 and 12 indicating a month. The default value is 1.\n\n**offset** (optional) is a scalar of the same data type as *X*, It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessYearBegin(2012.06.12);\n// output: 2012.01.02\n\nbusinessYearBegin(2012.06.13 10:10:10.008,5);\n// output: 2012.05.01\n\ndate=2011.10.25 2012.10.25 2013.10.25 2014.10.25 2015.10.25 2016.10.25 2017.10.25 2018.10.25 2019.10.25 2020.10.25\ntime = [09:34:07,09:36:42,09:36:51,09:36:59,09:32:47,09:35:26,09:34:16,09:34:26,09:38:12,09:38:13]\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nselect avg(price),sum(qty) from t1 group by businessYearBegin(date,1,2011.10.01,2)\n```\n\n| businessYearBegin\\_date | avg\\_price | sum\\_qty |\n| ----------------------- | ---------- | -------- |\n| 2011.01.03 | 39.53 | 4100 |\n| 2013.01.01 | 29.77 | 5300 |\n| 2015.01.01 | 175.1 | 12200 |\n| 2017.01.02 | 50.54 | 3800 |\n| 2019.01.01 | 51.835 | 13300 |\n\nRelated functions: [businessYearEnd](https://docs.dolphindb.com/en/Functions/b/businessYearEnd.html), [yearBegin](https://docs.dolphindb.com/en/Functions/y/yearBegin.html), [yearEnd](https://docs.dolphindb.com/en/Functions/y/yearEnd.html)\n" }, "businessYearEnd": { "url": "https://docs.dolphindb.com/en/Functions/b/businessYearEnd.html", "signatures": [ { "full": "businessYearEnd(X, [endingMonth=12], [offset], [n=1])", "name": "businessYearEnd", "parameters": [ { "full": "X", "name": "X" }, { "full": "[endingMonth=12]", "name": "endingMonth", "optional": true, "default": "12" }, { "full": "[offset]", "name": "offset", "optional": true }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" } ] } ], "markdown": "### [businessYearEnd](https://docs.dolphindb.com/en/Functions/b/businessYearEnd.html)\n\n\n\n#### Syntax\n\nbusinessYearEnd(X, \\[endingMonth=12], \\[offset], \\[n=1])\n\n#### Details\n\nReturn the last business day (Monday to Friday) of the year that *X* belongs to and that ends in the month of *endingMonth*.\n\nBy default, each period corresponds to one year, and the function returns the last business day of the year containing *X*. The ending month of the year is determined by the *endingMonth* parameter. Here, business days are determined solely by the day of the week: Monday through Friday are considered business days, while Saturday and Sunday are considered non-business days.\n\nWhen both *offset* and *n* are specified and *n* > 1, the function calculates period end dates based on n-year periods. In this case, *offset* determines how multi-year periods are aligned. Specifically, the system first calculates the last business day of the year containing *offset* according to *endingMonth*, and uses that date as the reference point. A new period end boundary is then generated every *n* years, and the function returns the last business day corresponding to the period to which *X* belongs.\n\nDolphinDB and pandas both provide similar date offset functionality at the conceptual level. For a comparison of calculation rules, see [Functions Related to Date Offset](https://docs.dolphindb.com/en/Programming/DataManipulation/TemporalObjects/TemporalObjectsManipulation.md#).\n\n#### Parameters\n\n**X** is a scalar/vector of data type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**endingMonth** is an integer between 1 and 12 indicating a month. The default value is 12.\n\n**offset** (optional) is a scalar of the same data type as *X*, It must be no greater than the minimum value of *X*. The default value is the minimum value of *X*.\n\n**n** (optional) is a positive integer. The default value is 1.\n\n#### Returns\n\nA scalar/vector of type DATE.\n\n#### Examples\n\n```\nbusinessYearEnd(2012.06.12, 3);\n// output: 2013.03.29\n\nbusinessYearEnd(2012.06.12, 9);\n// output: 2012.09.28\n\nbusinessYearEnd(2012.06.12);\n// output: 2012.12.31\n\nbusinessYearEnd(2012.06.12, 12, 2009.04.03, 2);\n// output: 2013.12.31\n\ndate=2011.04.25+(1..10)*365\ntime = take(09:30:00, 10)\nsym = take(`MSFT,10)\nprice= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29 52.38\nqty = 2200 1900 2100 3200 6800 5400 1300 2500 8800 4500\nt1 = table(date, time, sym, qty, price);\n\nt1;\n```\n\n| date | time | sym | qty | price |\n| ---------- | -------- | ---- | ---- | ------ |\n| 2012.04.24 | 09:30:00 | MSFT | 2200 | 49.6 |\n| 2013.04.24 | 09:30:00 | MSFT | 1900 | 29.46 |\n| 2014.04.24 | 09:30:00 | MSFT | 2100 | 29.52 |\n| 2015.04.24 | 09:30:00 | MSFT | 3200 | 30.02 |\n| 2016.04.23 | 09:30:00 | MSFT | 6800 | 174.97 |\n| 2017.04.23 | 09:30:00 | MSFT | 5400 | 175.23 |\n| 2018.04.23 | 09:30:00 | MSFT | 1300 | 50.76 |\n| 2019.04.23 | 09:30:00 | MSFT | 2500 | 50.32 |\n| 2020.04.22 | 09:30:00 | MSFT | 8800 | 51.29 |\n| 2021.04.22 | 09:30:00 | MSFT | 4500 | 52.38 |\n\n```\nselect avg(price),sum(qty) from t1 group by businessYearEnd(date, 4, 2010.04.01, 2);\n```\n\n| businessYearEnd\\_date | avg\\_price | sum\\_qty |\n| --------------------- | ---------- | -------- |\n| 2012.04.30 | 49.6 | 2200 |\n| 2014.04.30 | 29.49 | 4000 |\n| 2016.04.29 | 102.495 | 10000 |\n| 2018.04.30 | 112.995 | 6700 |\n| 2020.04.30 | 50.805 | 11300 |\n| 2022.04.29 | 52.38 | 4500 |\n\nRelated functions: [businessYearBegin](https://docs.dolphindb.com/en/Functions/b/businessYearBegin.html), [yearBegin](https://docs.dolphindb.com/en/Functions/y/yearBegin.html), [yearEnd](https://docs.dolphindb.com/en/Functions/y/yearEnd.html)\n" }, "bvls": { "url": "https://docs.dolphindb.com/en/Functions/b/bvls.html", "signatures": [ { "full": "bvls(Y, X, bounds, [maxIter], [tolerance=1e-10], [intercept=true], [mode=0])", "name": "bvls", "parameters": [ { "full": "Y", "name": "Y" }, { "full": "X", "name": "X" }, { "full": "bounds", "name": "bounds" }, { "full": "[maxIter]", "name": "maxIter", "optional": true }, { "full": "[tolerance=1e-10]", "name": "tolerance", "optional": true, "default": "1e-10" }, { "full": "[intercept=true]", "name": "intercept", "optional": true, "default": "true" }, { "full": "[mode=0]", "name": "mode", "optional": true, "default": "0" } ] } ], "markdown": "### [bvls](https://docs.dolphindb.com/en/Functions/b/bvls.html)\n\nFirst introduced in version: 2.00.163.00.3\n\n\n\n#### Syntax\n\nbvls(Y, X, bounds, \\[maxIter], \\[tolerance=1e-10], \\[intercept=true], \\[mode=0])\n\n#### Details\n\nPerform Bounded-Variable Least Squares (BVLS) regression.\n\n#### Parameters\n\n**Y** is a numeric vector indicating the dependent variable.\n\n**X** is a numeric vector/matrix/table/tuple indicating the independent variable(s). When *X* is a matrix,\n\n* If the number of rows equals the length of *Y*, each column of *X* is a factor.\n* If the number of rows is not the same as the length of *Y*, and the number of columns equals the length of *Y*, each row of *X* is a factor.\n\nNote: The values in *X* and *Y* will be converted to DOUBLE, and the null values after the conversion will be treated as 0.\n\n**bounds** is a tuple of elements (\\[lb, ub]) specifying the lower and upper bounds. Each element of the tuple can be:\n\n* A scalar: specifies the same boundary for all factors.\n* A vector: specifies boundaries for each factor individually, with the vector length equal to the number of factors.\n\n**maxIter** (optional) is a positive integer indicating the maximum number of iterations before termination, defaults to the number of variables.\n\n**tolerance** (optional) is a DOUBLE value indicating the convergence threshold, defaults to 1e-10. Iteration stops when either:\n\n* The difference in loss function values between consecutive iterations < *tolerance*;\n* The KKT (Karush-Kuhn-Tucker) conditions are satisfied within *tolerance*.\n\n**intercept** (optional) is a Boolean variable indicating whether the regression includes the intercept. If it is true, the system automatically adds a column of 1 to *X* to generate the intercept. The default value is true.\n\n**mode** (optional) is an integer indicating the contents in the output. Currently only 0 (default) is supported, returning a coefficient vector.\n\n#### Returns\n\nA DOUBLE vector indicating the estimated coefficients.\n\n#### Examples\n\n```\nx1 = [1, 3, 5, 7, 11, 16, 23]\nx2 = [2, 8, 11, 34, 56, 54, 100]\ny = [0.1, 4.2, 5.6, 8.8, 22.1, 35.6, 77.2]\nbounds = (0.0, 10.0)\n\nbvls(y, x1, bounds)\n// output: [0,2.717777777777778]\n\nbvls(y, (x1, x2), bounds)\n// output: [0,1.409643685501234,0.315943584131198]\n```\n\nRelated functions: [ols](https://docs.dolphindb.com/en/Functions/o/ols.html)\n" }, "dailyAlignedBar": { "url": "https://docs.dolphindb.com/en/Functions/d/dailyAlignedBar.html", "signatures": [ { "full": "dailyAlignedBar(X, timeOffset, n, [timeEnd], [mergeSessionEnd=false])", "name": "dailyAlignedBar", "parameters": [ { "full": "X", "name": "X" }, { "full": "timeOffset", "name": "timeOffset" }, { "full": "n", "name": "n" }, { "full": "[timeEnd]", "name": "timeEnd", "optional": true }, { "full": "[mergeSessionEnd=false]", "name": "mergeSessionEnd", "optional": true, "default": "false" } ] } ], "markdown": "### [dailyAlignedBar](https://docs.dolphindb.com/en/Functions/d/dailyAlignedBar.html)\n\n\n\n#### Syntax\n\ndailyAlignedBar(X, timeOffset, n, \\[timeEnd], \\[mergeSessionEnd=false])\n\n#### Details\n\nDetermine windows based on the starting time (specified by *timeOffset*), window length (specified by *n*), and possibly ending time (specified by *timeEnd*). For each element of *X*, return the starting time of the window it belongs to. Specifically, return `X-((X-timeOffset)%n)` for each element of *X* and return a vector with the same length as *X*.\n\nGenerally, a window includes the left boundary but not the right boundary. If *mergeSessionEnd*=true and the right boundary of a session is also the right boundary of a window, the right boundary of the session is merged into the previous window.\n\nThe function supports overnight sessions.\n\n#### Parameters\n\n**X** is a temporal vector of type SECOND, TIME, NANOTIME, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n**timeOffset** is a scalar/vector of type SECOND, TIME or NANOTIME with the same accuracy of *X* indicating the left boundary of session(s). If it is a vector, it must be increasing.\n\n**n** is a positive integer or DURATION type data indicating the window length. If *n* is a positive integer, its unit is the minimum accuracy of *timeOffset*. If *n* is a DURATION type data, its unit cannot be y, M, w, d, B.\n\n**timeEnd** (optional) is of the same type and length of *timeOffset* indicating the right boundary of session(s).\n\n**mergeSessionEnd** (optional) is a Boolean value. When the right boundary of a session (as specified in *timeEnd*) is also the right boundary of a window, if *mergeSessionEnd*=true, the right boundary of the session is merged into the previous window.\n\n#### Returns\n\nA vector with the same length as *X*\n\n#### Examples\n\nPlease note that the examples below use randomly generated data for the column of price. The result is different each time you execute it.\n\nExample 1. The Chinese stock market has 2 sessions each day: from 9:30AM to 11:30AM and from 1PM to 3PM. The script below calculates rolling 1-hour average prices for these sessions.\n\n```\nsessionsBegin = 09:30:00 13:00:00\nts = 2019.11.01T09:30:00..2019.11.01T11:30:00 join 2019.11.01T13:00:00..2019.11.01T15:00:00\nt = table(ts, rand(10.0, size(ts)) as price);\n\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60) as k60;\n```\n\n| k60 | price | count |\n| ------------------- | ----------------- | ----- |\n| 2019.11.01T09:30:00 | 5.031685383252463 | 3600 |\n| 2019.11.01T10:30:00 | 5.022667285786399 | 3600 |\n| 2019.11.01T11:30:00 | 4.930270051117987 | 1 |\n| 2019.11.01T13:00:00 | 4.931854071494632 | 3600 |\n| 2019.11.01T14:00:00 | 4.979529541734115 | 3600 |\n| 2019.11.01T15:00:00 | 0.961996954865754 | 1 |\n\nAs a window includes the left boundary but not the right boundary, if the right boundary of a session is also the right boundary of a window as in the example above, the right boundary of the session belongs to a window that has no other records if *timeEnd* and *mergeSessionEnd* are not specified. In most cases we would like to merge the right boundary of a session to the previous window. Please refer to the example below.\n\n```\nsessionsEnd = 11:30:00 15:00:00;\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessionsBegin, n=60*60, timeEnd=sessionsEnd, mergeSessionEnd=true) as k60;\n```\n\n| k60 | price | count |\n| ------------------- | ----------------- | ----- |\n| 2019.11.01T09:30:00 | 5.031685383252463 | 3600 |\n| 2019.11.01T10:30:00 | 5.022641627015316 | 3601 |\n| 2019.11.01T13:00:00 | 4.931854071494632 | 3600 |\n| 2019.11.01T14:00:00 | 4.978413870368697 | 3601 |\n\nExample 2. The futures market has 2 sessions each day: from 1:30PM to 4:30PM and from 10:30PM to 2:30AM the next day. `dailyAlignedBar` is used to calculate 7-minute average prices for these sessions. Please note that we simulate 2 days' data in the example.\n\n```\nsessions = 13:30:00 22:30:00\nts = 2019.11.01T13:30:00..2019.11.01T16:30:00 join 2019.11.01T22:30:00..2019.11.02T02:30:00\nts = ts join (ts+60*60*24)\nt = table(ts, rand(10.0, size(ts)) as price)\nselect avg(price) as price, count(*) as count from t group by dailyAlignedBar(X=ts, timeOffset=sessions, n=7m) as k7;\n```\n\nExample 3. When calculating 1-minute OHLC bars, the data type needs to be converted to LONG if *n* needs to be converted to NANOTIMESTAMP, otherwise an integer overflow will occur.\n\n```\nn = 1000000\nnano=(09:30:00.000000000 + rand(long(6.5*60*60*1000000000), n)).sort!()\nsessionStartNano=09:30:00.000000000\nprice = 100+cumsum(rand(0.02, n)-0.01)\nvolume = rand(1000, n)\nsymbol = rand(`600519`000001`600000`601766, n)\ntradeNano=table(symbol, nano, price, volume).sortBy!(`symbol`nano)\nundef(`nano`price`volume`symbol)\nbarMinutes=7\nitv = barMinutes*60*long(1000000000)\n\nOHLC_nano=select first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume from tradeNano group by symbol, dailyAlignedBar(X=nano, timeOffset=sessionStartNano, n=itv) as barStart\n```\n\nRelated function: [bar](https://docs.dolphindb.com/en/Functions/b/bar.html)\n" }, "database": { "url": "https://docs.dolphindb.com/en/Functions/d/database.html", "signatures": [ { "full": "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'])", "name": "database", "parameters": [ { "full": "directory", "name": "directory" }, { "full": "[partitionType]", "name": "partitionType", "optional": true }, { "full": "[partitionScheme]", "name": "partitionScheme", "optional": true }, { "full": "[locations]", "name": "locations", "optional": true }, { "full": "[engine='OLAP']", "name": "engine", "optional": true, "default": "'OLAP'" }, { "full": "[atomic='TRANS']", "name": "atomic", "optional": true, "default": "'TRANS'" } ] }, { "full": "database(directory, [partitionType], [partitionScheme], [locations], [engine='OLAP'], [atomic='TRANS'], [chunkGranularity='TABLE'])", "name": "database", "parameters": [ { "full": "directory", "name": "directory" }, { "full": "[partitionType]", "name": "partitionType", "optional": true }, { "full": "[partitionScheme]", "name": "partitionScheme", "optional": true }, { "full": "[locations]", "name": "locations", "optional": true }, { "full": "[engine='OLAP']", "name": "engine", "optional": true, "default": "'OLAP'" }, { "full": "[atomic='TRANS']", "name": "atomic", "optional": true, "default": "'TRANS'" }, { "full": "[chunkGranularity='TABLE']", "name": "chunkGranularity", "optional": true, "default": "'TABLE'" } ] } ], "markdown": "### [database](https://docs.dolphindb.com/en/Functions/d/database.html)\n\n\n\n#### Syntax\n\ndatabase(directory, \\[partitionType], \\[partitionScheme], \\[locations], \\[engine='OLAP'], \\[atomic='TRANS'])\n\nStarting from 1.30.16/2.00.4, if the configuration paramter *enableChunkGranularityConfig* = true, use the following syntax:\n\ndatabase(directory, \\[partitionType], \\[partitionScheme], \\[locations], \\[engine='OLAP'], \\[atomic='TRANS'], \\[chunkGranularity='TABLE'])\n\n#### Details\n\nCreate a database handle.\n\nTo create a DFS database, *partitionType* and *partitionScheme* must be specified. To reopen an existing distributed database, only *directory* is required. It is not allowed to overwrite an existing distributed database with a different *partitionType* or *partitionScheme*.\n\n#### Parameters\n\n**directory** is the directory where a database is located. To establish a database in the distributed file system, *directory* should start with \"dfs\\://\". To establish an in-memory database, directory should be unspecfied or an empty string \"\". To establish an IMOLTP database, directory should start with \"oltp\\://\". Make sure the configuration parameter *enableIMOLTP* is set to true before creating an IMOLTP database.\n\n**partitionType** (optional) specifies the partition type, which can be: sequential (SEQ), range (RANGE), hash (HASH), value (VALUE), list (LIST), and composite (COMPO).\n\n**partitionScheme** (optional) describes how the partitions are created. It is usually a vector, with the exception that it is an integer scalar for the sequential domain. The interpretation of the partition scheme depends on the partition type. *partitionScheme* supports the following data types: CHAR, SHORT, INT, DATE, MONTH, TIME, MINUTE, SECOND, DATETIME, and SYMBOL.\n\n| Partition Type | Partition Type Symbol | Partition Scheme |\n| ----------------- | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| sequential domain | SEQ | An integer scalar. It means the number of partitions. |\n| range domain | RANGE | A vector. Any two adjacent elements of the vector define the range for a partition. |\n| hash domain | HASH | A tuple. The first element is the data type of partitioning column. The second element is the number of partitions. |\n| value domain | VALUE | A vector. Each element of the vector defines a partition. |\n| list domain | LIST | A vector. Each element of the vector defines a partition. |\n| composite domain | COMPO | A vector. Each element of the vector is a database handle. The vector can contain two or three elements and the length of the vector indicates the partition levels. |\n\n**locations** (optional) is a tuple indicating the locations of each partition. The number of elements in the tuple should be the same as that of partitions determined by *partitionType* and *partitionScheme*. When saving partitions on multiple nodes, we can specify the location for each partition by using the DFS (Distributed File System) or the *locations* parameter. If the *locations* parameter is not specified, all partitions reside in the current node. We cannot specify partition *locations* for composite partitions.\n\n**engine** (optional) specifies the storage engine. It can be 'OLAP' (default), 'TSDB', 'IMOLTP', 'IOTDB' or 'PKEY'. Note that the TSDB and PKEY engines only support creating distributed databases.\n\n**engine** (optional) specifies the storage engine. It can be 'OLAP' (default), 'TSDB', or 'IOTDB'.\n\n**atomic** (optional) indicates at which level the atomicity is guaranteed for a write transaction, thus determining whether concurrent writes to the same chunk are allowed. It can be 'TRANS' or 'CHUNK' and the default value is 'TRANS'.\n\n* 'TRANS' indicates that the atomicity is guaranteed at the transaction level. If a transaction attempts to write to multiple chunks and one of the chunks is locked by another transaction, a write-write conflict occurs, and all writes of the transaction fail. Therefore, setting *atomic* ='TRANS' means concurrent writes to a chunk are not allowed.\n\n* 'CHUNK' indicates that the atomicity is guaranteed at the chunk level. If a transaction tries to write to multiple chunks and a write-write conflict occurs as a chunk is locked by another transaction, instead of aborting the writes, the transaction will keep writing to the non-locked chunks and keep attempting to write to the chunk in conflict until it is still locked after a few minutes. Therefore, setting *atomic* ='CHUNK' means concurrent writes to a chunk are allowed. As the atomicity at the transaction level is not guaranteed, the write operation may succeed in some chunks but fail in other chunks. Please also note that the write speed may be impacted by the repeated attempts to write to the chunks that are locked.\n\n**chunkGranularity** (optional) is a string indicating the chunk granularity. It determines whether concurrent writes to different tables in the same chunk are allowed. It is only enabled when *enableChunkGranularityConfig* = true is configured. The value can be 'TABLE' or 'DATABASE':\n\n* 'TABLE': the chunk granularity is at the TABLE level. In this case, concurrent writes to different tables in the same partition are allowed.\n\n* 'DATABASE': the chunk granularity is at the DATABASE level. In this case, concurrent writes to different tables in the same partition are not allowed.\n\nThe chunk granularity determines where a DolphinDB transaction locates the lock. For databases created with version 1.30.16/2.00.4 or earlier, the chunk granularity is at the DATABASE level, i.e., each partition of the database is a chunk. Starting from version 1.30.16/2.00.4, the default chunk granularity is at the TABLE level and each table of the partition is a chunk.\n\n#### Examples\n\nExample 1. To establish a non-partitioned database on disk:\n\n```\ndb=database(directory=\"C:/DolphinDB/Data/db1/\");\nt=table(take(1..10,1000) as id, rand(10,1000) as x, rand(10.0,1000) as y);\nsaveTable(db, t, `t1);\n```\n\nExample 2. For distributed database, here's an example for each type of partition:\n\n* **Partition Type: SEQ**\n\n In a sequential domain (SEQ), the partitions are based on the order of rows in the input data file. It can only be used in the local file system, not in the distributed file system.\n\n ```\n n=1000000\n ID=rand(100, n)\n dates=2017.08.07..2017.08.11\n date=rand(dates, n)\n x=rand(10.0, n)\n t=table(ID, date, x);\n saveText(t, \"C:/DolphinDB/Data/t.txt\");\n\n db = database(directory=\"C:/DolphinDB/Data/seqdb\", partitionType=SEQ, partitionScheme=8)\n pt = loadTextEx(db, `pt, ,\"C:/DolphinDB/Data/t.txt\");\n ```\n\n Under the folder *C:/DolphinDB/data/seqdb*, 8 sub folders have been created. Each of them corresponds to a partition of the input data file. If the size of the input data file is larger than the available memory of the computer, we can load the data in partitions.\n\n ![](https://docs.dolphindb.com/en/images/database01.png)\n\n* **Partition Type: RANGE**\n\n In a range domain (RANGE), partitions are determined by any two adjacent elements of the partition scheme vector. The starting value is inclusive and the ending value is exclusive.\n\n ```\n n=1000000\n ID=rand(10, n)\n x=rand(1.0, n)\n t=table(ID, x);\n db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)\n pt = db.createPartitionedTable(t, `pt, `ID);\n pt.append!(t);\n\n pt=loadTable(db,`pt)\n x=select * from pt\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000000 |\n\n In the example above, the database db has two partitions: \\[0,5) and \\[5,10). Table t is saved as a partitioned table pt with the partitioning column of ID in database db.\n\n ![](https://docs.dolphindb.com/en/images/database02.png)\n\n To import a data file into a distributed database of range domain in the local file system:\n\n ```\n n=1000000\n ID=rand(10, n)\n x=rand(1.0, n)\n t=table(ID, x);\n saveText(t, \"C:/DolphinDB/Data/t.txt\");\n\n db=database(directory=\"dfs://rangedb\", partitionType=RANGE, partitionScheme=0 5 10)\n pt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n ```\n\n* **Partition Type: HASH**\n\n In a hash domain (HASH), the data type and numbers of partitions need to be specified.\n\n ```\n n=1000000\n ID=rand(10, n)\n x=rand(1.0, n)\n t=table(ID, x)\n db=database(directory=\"dfs://hashdb\", partitionType=HASH, partitionScheme=[INT, 2])\n\n pt = db.createPartitionedTable(t, `pt, `ID)\n pt.append!(t);\n\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000000 |\n\n In example above, database db has two partitions. Table t is saved as pt(a partitioned table) with the partitioning column ID.\n\n Note: For a database to be imported to a hash domain, if a partitioning column contains null value, the record is discarded.\n\n ```\n ID = NULL 3 6 NULL 9\n x = rand(1.0, 5)\n t1 = table(ID, x)\n pt.append!(t1)\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000003 |\n\n* **Partition Type: VALUE**\n\n In a value domain (VALUE), each element of the partition scheme vector determines a partition.\n\n ```\n n=1000000\n month=take(2000.01M..2016.12M, n);\n x=rand(1.0, n);\n t=table(month, x);\n\n db=database(directory=\"dfs://valuedb\", partitionType=VALUE, partitionScheme=2000.01M..2016.12M)\n pt = db.createPartitionedTable(t, `pt, `month);\n pt.append!(t);\n\n pt=loadTable(db,`pt)\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000000 |\n\n The example above defines a database db with 204 partitions. Each of these partitions is a month between January 2000 and December 2016. With function `createPartitionedTable` and `append!`, table t is saved as a partitioned table pt in the database db with the partitioning column of month.\n\n ![](https://docs.dolphindb.com/en/images/database03.png)\n\n* **Partition Type: LIST**\n\n In a list domain (LIST), each element of the partition scheme vector determines a partition.\n\n ```\n n=1000000\n ticker = rand(`MSFT`GOOG`FB`ORCL`IBM,n);\n x=rand(1.0, n);\n t=table(ticker, x);\n\n db=database(directory=\"dfs://listdb\", partitionType=LIST, partitionScheme=[`IBM`ORCL`MSFT, `GOOG`FB])\n pt = db.createPartitionedTable(t, `pt, `ticker)\n pt.append!(t);\n\n pt=loadTable(db,`pt)\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000000 |\n\n The database above has 2 partitions. The first partition has 3 tickers and the second has 2 tickers.\n\n ![](https://docs.dolphindb.com/en/images/database04.png)\n\n* **Partition Type: COMPO**\n\n In a composite domain (COMPO), we can have 2 or 3 partitioning columns. Each column can be of range, value, or list domain.\n\n ```\n n=1000000\n ID=rand(100, n)\n dates=2017.08.07..2017.08.11\n date=rand(dates, n)\n x=rand(10.0, n)\n t=table(ID, date, x)\n\n dbDate = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\n dbID = database(, partitionType=RANGE, partitionScheme=0 50 100)\n db = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID])\n\n pt = db.createPartitionedTable(t, `pt, `date`ID)\n pt.append!(t)\n\n pt=loadTable(db,`pt)\n select count(x) from pt;\n ```\n\n | count\\_x |\n | -------- |\n | 1000000 |\n\n The value domain has 5 partitions for 5 days:\n\n ![](https://docs.dolphindb.com/en/images/database05.png)\n\n The range domain has 2 partitions:\n\n ![](https://docs.dolphindb.com/en/images/database06.png)\n\n Please note that the although we have 2 levels of folders here for database files, composite domain only has one level of partition. In comparision, there are 2 levels of partition in dual partition.\n\nExample 3. To establish distributed databases in the distributed file system, we can follow the syntax of the examples above. The only difference is that the *directory* parameter in function `database` should start with \"dfs\\://\".\n\nTo execute the following examples, we need to start a DFS cluster on the web interface, and submit the script on a data node.\n\nSave a partitioned table of composite domain in the distributed file system:\n\n```\nn=1000000\nID=rand(100, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\n\ndbDate = database(, partitionType=VALUE, partitionScheme=2017.08.07..2017.08.11)\ndbID=database(, partitionType=RANGE, partitionScheme=0 50 100);\ndb = database(directory=\"dfs://compoDB\", partitionType=COMPO, partitionScheme=[dbDate, dbID]);\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\nThe data are stored at a location specified by the configuration parameter volumes.\n\n![](https://docs.dolphindb.com/en/images/database07.png)\n\nPlease note that DFS\\_NODE1 only has 4 date folders; under DFS\\_NODE1, the folder of 20170807 only has 1 ID folder. This is because here we have 4 data nodes and 2*5=10 partitions based on date and ID. By default each partition has 3 copies in the distributed file system. Therefore, we have 5*2\\*3=30 partitions in total saved on 4 data nodes. Not all data nodes have all the 10 partitions.\n\nImport a data file into a distributed database of range domain in the distributed file system:\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb=database(\"dfs://rangedb\", RANGE, 0 5 10)\npt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n```\n\nExample 4. Use the parameter *locations*\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x);\n\ndb=database(directory=\"dfs://rangedb5\", partitionType=RANGE, partitionScheme=0 5 10, locations=[`node1`node2, `node3])\npt = db.createPartitionedTable(t, `pt, `ID);\npt.append!(t);\n```\n\nThe example above defines a list domain that has 2 partitions. The first partition resides on 2 sites: node1 and node2, and the second partition resides on site node3. All referred sites must be defined in the sites attribute of *dolphindb.cfg* on all machines where these nodes are located:\n\n```\nsites=111.222.3.4:8080:node1, 111.222.3.5:8080:node2, 111.222.3.6:8080:node3\n```\n\nSites are separated by comma. Each site specification contains 3 parts: host name, port number, and alias. A partition can reside on multiple sites that back up each other. In this example, each node is located on a different machine.\n\nWe can also use the actual host name and the port number to represent a site. The function call can be changed to\n\n```\ndb=database(\"C:/DolphinDB/Data/rangedb6\", RANGE, 0 5 10, [[\"111.222.3.4:8080\", \"111.222.3.5:8080\"], \"111.222.3.6:8080\"])\n```\n\nExample 5. Use the parameter *atomic*:\n\n```\nif(existsDatabase(\"dfs://test\"))\ndropDB(\"dfs://test\")\ndb = database(directory=\"dfs://test\", partitionType=VALUE, partitionScheme=1..20, atomic='CHUNK')\ndummy = table(take(1..20, 100000) as id, rand(1.0, 100000) as value)\npt = db.createPartitionedTable(dummy, \"pt\", `id)\n\ndummy1 = table(take(1..15, 1000000) as id, rand(1.0, 1000000) as value)\ndummy2 = table(take(11..20, 1000000) as id, rand(1.0, 1000000) as value)\nsubmitJob(\"write1\", \"writer1\", append!{pt, dummy1})\nsubmitJob(\"write2\", \"writer2\", append!{pt, dummy2})\nsubmitJob(\"write3\", \"writer3\", append!{pt, dummy1})\nsubmitJob(\"write4\", \"writer4\", append!{pt, dummy2})\nselect count(*) from pt\n// output: 4,000,000\n```\n" }, "date": { "url": "https://docs.dolphindb.com/en/Functions/d/date.html", "signatures": [ { "full": "date(X)", "name": "date", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [date](https://docs.dolphindb.com/en/Functions/d/date.html)\n\n\n\n#### Syntax\n\ndate(X)\n\n#### Details\n\nConvert *X* into DATE type.\n\n#### Parameters\n\n**X** is an integer or temporal scalar/vector.\n\n#### Returns\n\nDATE type with the same data form as *X*.\n\n#### Examples\n\n```\ndate 2012.12.03 01:22:01;\n// output: 2012.12.03\n\ndate(2016.03M);\n// output: 2016.03.01\n\ndate(1);\n// output: 1970.01.02\n```\n\nRelated functions: [second](https://docs.dolphindb.com/en/Functions/s/second.html), [minute](https://docs.dolphindb.com/en/Functions/m/minute.html), [month](https://docs.dolphindb.com/en/Functions/m/month.html), [hour](https://docs.dolphindb.com/en/Functions/h/hour.html), [year](https://docs.dolphindb.com/en/Functions/y/year.html)\n" }, "datehour": { "url": "https://docs.dolphindb.com/en/Functions/d/datehour.html", "signatures": [ { "full": "datehour(X)", "name": "datehour", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [datehour](https://docs.dolphindb.com/en/Functions/d/datehour.html)\n\n\n\n#### Syntax\n\ndatehour(X)\n\n#### Details\n\nConvert *X* into DATEHOUR data type.\n\nSince version 2.00.12, converting MONTH into DATEHOUR is allowed.\n\n#### Parameters\n\n**X** is a temporal scalar/vector that contains information about dates.\n\n#### Returns\n\nDATEHOUR type with the same data form as *X*.\n\n#### Examples\n\n```\ndatehour(2012.06.13 13:30:10);\n// output: 2012.06.13T13\n\ndatehour([2012.06.15 15:32:10.158,2012.06.15 17:30:10.008]);\n// output: [2012.06.15T15,2012.06.15T17]\n\ndatehour(2012.01M)\n// output: 2012.01.01T00\n```\n" }, "datetime": { "url": "https://docs.dolphindb.com/en/Functions/d/datetime.html", "signatures": [ { "full": "datetime(X)", "name": "datetime", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [datetime](https://docs.dolphindb.com/en/Functions/d/datetime.html)\n\n\n\n#### Syntax\n\ndatetime(X)\n\n#### Details\n\nConvert *X* into DATETIME type. Since version 2.00.12, converting MONTH into DATETIME is allowed.\n\n**Note:** The range for data of DATETIME type is \\[1901.12.13T20:45:53, 2038.01.19T03:14:07].\n\n#### Parameters\n\n**X** is a temporal scalar/vector, or an integer.\n\n#### Returns\n\nDATETIME type with the same data form as *X*.\n\n#### Examples\n\n```\ndatetime(2009.11.10);\n// output: 2009.11.10T00:00:00\n\ntypestr datetime(2009.11.10);\n// output: DATETIME\n\ndatetime(now());\n// output: 2016.03.02T20:51:10\n\ndatetime(2012.01M)\n// output: 2012.01.01T00:00:00\n```\n\nRelated functions: [date](https://docs.dolphindb.com/en/Functions/d/date.html), [second](https://docs.dolphindb.com/en/Functions/s/second.html), [minute](https://docs.dolphindb.com/en/Functions/m/minute.html), [month](https://docs.dolphindb.com/en/Functions/m/month.html), [hour](https://docs.dolphindb.com/en/Functions/h/hour.html), [year](https://docs.dolphindb.com/en/Functions/y/year.html)\n" }, "datetimeParse": { "url": "https://docs.dolphindb.com/en/Functions/d/datetimeParse.html", "signatures": [ { "full": "temporalParse(X, format)", "name": "temporalParse", "parameters": [ { "full": "X", "name": "X" }, { "full": "format", "name": "format" } ] } ], "markdown": "### [datetimeParse](https://docs.dolphindb.com/en/Functions/d/datetimeParse.html)\n\nAlias for [temporalParse](https://docs.dolphindb.com/en/Functions/t/temporalParse.html)\n\n\nDocumentation for the `temporalParse` function:\n### [temporalParse](https://docs.dolphindb.com/en/Functions/t/temporalParse.html)\n\n\n\n#### Syntax\n\ntemporalParse(X, format)\n\nAlias: datetimeParse\n\n#### Details\n\nConvert a string with specified format to a DolphinDB temporal data type. Return NULL if it cannot decide on the data type.\n\nDolphinDB has the following temporal formats:\n\n| Format | Meaning | Range of value |\n| --------- | ---------------- | ------------------------------------------- |\n| yyyy | year (4 digits) | 1000-9999 |\n| yy | year (2 digits) | 00-99. (00-39: 2000-2039; 40-99: 1940-1999) |\n| MM | month in year | 1-12 |\n| MMM | month in year | JAN, FEB, ... DEC (case insensitive) |\n| dd | day in month | 1-31 |\n| HH | hour in day | 0-23 |\n| hh | hour in AM/PM | 0-11 |\n| mm | minute in hour | 0-59 |\n| ss | second in minute | 0-59 |\n| aa | AM/PM marker | AM, PM. (case-insensitive) |\n| SSS | millisecond | 0-999 |\n| nnnnnn | microsecond | 0-999999 |\n| nnnnnnnnn | nanosecond | 0-999999999 |\n\nThe parameter format of the *temporalParse* function has 2 types of representation:\n\n* **With deliminator(s)**\n\nAny symbol or character is treated as a deliminator except the characters that are used to express a temporal format: y, M, d, H, h, m, s, a, S, and n. A deliminator in the parameter *format* should be identical as the deliminator in the input string.\n\n```\ntemporalParse(\"14-02-2018\",\"dd-MM-yyyy\");\n// output: 2018.02.14\n\ntemporalParse(\"14-02-2018\",\"dd/MM/yyyy\");\n// output: 00d\n\ntemporalParse(\"14//02//2018\",\"dd//MM//yyyy\");\n// output: 2018.02.14\n\ntemporalParse(\"14//02//2018\",\"dd/MM/yyyy\");\n// output: 00d\n\ntemporalParse(\"14//02//2018\",\"dd..MM..yyyy\");\n// output: 00d\n```\n\nWe can simplify the formats by using a single letter between deliminators for the parameter *format*. For example, we can use the format \"y/M/d\" instead of \"yyyy/MM/dd\" for \"2018/01/16\". As \"y\" may mean both \"yyyy\" and \"yy\", for this case the system decides on the format based on the number of digits between deliminators.\n\n```\ntemporalParse(\"14-02-18\",\"d-M-y\");\n// output: 2018.02.14\n\ntemporalParse(\"2018/2/6 02:33:01 PM\",\"y/M/d h:m:s a\");\n// output: 2018.02.06T14:33:01\n```\n\n\"MMM\",\"SSS\", \"nnnnnn\" and \"nnnnnnnnn\", however, cannot be simplified to a single letter.\n\n```\ntemporalParse(\"02-FEB-2018\",\"d-MMM-y\");\n// output: 2018.02.02\n\ntemporalParse(\"02-FEB-2018\",\"d-M-y\");\n// output: 00d\n\ntemporalParse(\"13:30:10.001\",\"H:m:s.SSS\");\n// output: 13:30:10.001\n\ntemporalParse(\"13:30:10.001\",\"H:m:s.S\");\n// output: Invalid temporal format: 'H:m:s.S'. Millisecond (S) must have three digits.\n\ntemporalParse(\"13:30:10.008001\",\"H:m:s.nnnnnn\");\n// output: 13:30:10.008001000\n\ntemporalParse(\"13:30:10.008001\",\"H:m:s.n\");\n// output: Invalid temporal format: 'H:m:s.n'. Nanosecond (n) must have six or nine digits.\n```\n\nThe `temporalParse` function is very flexible in interpreting the numbers between deliminators in the input string.\n\n```\ntemporalParse(\"2-4-18\",\"d-M-yy\");\n// output: 2018.04.02\n\ntemporalParse(\"2-19-6\",\"H-m-s\");\n// output: 02:19:06\n\ntemporalParse(\"002-019-006\",\"H-m-s\");\n// output: 02:19:06\n```\n\nFor millisecond, microsecond and nanosecond, however, the corresponding number of digits in the input string must be 3, 6 and 9 respectively.\n\n```\ntemporalParse(\"2018/2/6 13:30:10.001\",\"y/M/d H:m:s.SSS\");\n// output: 2018.02.06T13:30:10.001\n\ntemporalParse(\"2018/2/6 13:30:10.01\",\"y/M/d H:m:s.SSS\");\n// output: 00T\n\ntemporalParse(\"2018/2/6 13:30:10.000001\",\"y/M/d H:m:s.nnnnnn\");\n// output: 2018.02.06T13:30:10.000001000\n\ntemporalParse(\"2018/2/6 13:30:10.0000010\",\"y/M/d H:m:s.nnnnnn\");\n// output: 00N\n```\n\nIf a character that is used to express a temporal format (y, M, d, H, h, m, s, a, S, n) appears in the input string as a deliminator, we need to use \"\" before the character in parameter *format*.\n\n```\ntemporalParse(\"2013a02\", \"y\\\\aM\");\n// output: 2013.02M\n\ntemporalParse(\"2013an02\", \"y\\\\a\\\\nM\");\n// output: 2013.02M\n```\n\n* **Without deliminators**\n\nFor this reprensentation, the parameter *format* must be composed of the formats in the temporal formats table. We cannot use a single letter to represent a format in the temporal format table.\n\n```\ntemporalParse(\"20180214\",\"yyyyMMdd\");\n// output: 2018.02.14\n\ntemporalParse(\"122506\",\"MMddyy\");\n// output: 2006.12.25\n\ntemporalParse(\"155950\",\"HHmmss\");\n// output: 15:59:50\n\ntemporalParse(\"035901PM\",\"hhmmssaa\");\n// output: 15:59:01\n\ntemporalParse(\"02062018155956001000001\",\"MMddyyyyHHmmssnnnnnnnnn\");\n// output: 2018.02.06T15:59:56.001000001\n```\n\n#### Parameters\n\n**X** is a string scalar/vector to be converted to temporal data types.\n\n**format** is a string indicating a temporal format.\n\n#### Returns\n\nA temporal scalar or vector.\n" }, "dayOfMonth": { "url": "https://docs.dolphindb.com/en/Functions/d/dayOfMonth.html", "signatures": [ { "full": "dayOfMonth(X)", "name": "dayOfMonth", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [dayOfMonth](https://docs.dolphindb.com/en/Functions/d/dayOfMonth.html)\n\n\n\n#### Syntax\n\ndayOfMonth(X)\n\n#### Details\n\nReturn the day of the month for each element in X.\n\n#### Parameters\n\n**X** is a scalar/vector of type DATE, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n#### Returns\n\nAn integer.\n\n#### Examples\n\n```\ndayOfMonth(2011.01.01);\n// output: 1\n\ndayOfMonth([2012.06.12T12:30:00,2012.07.28T12:35:00]);\n// outpu: [12,28]\n```\n\nRelated functions: [dayOfYear](https://docs.dolphindb.com/en/Functions/d/dayOfYear.html), [quarterOfYear](https://docs.dolphindb.com/en/Functions/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.com/en/Functions/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.com/en/Functions/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.com/en/Functions/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.com/en/Functions/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.com/en/Functions/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.com/en/Functions/m/millisecond.html), [microsecond](https://docs.dolphindb.com/en/Functions/m/microsecond.html), [nanosecond](https://docs.dolphindb.com/en/Functions/n/nanosecond.html)\n" }, "dayOfWeek": { "url": "https://docs.dolphindb.com/en/Functions/d/dayOfWeek.html", "signatures": [ { "full": "dayOfWeek(X)", "name": "dayOfWeek", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [dayOfWeek](https://docs.dolphindb.com/en/Functions/d/dayOfWeek.html)\n\n\n\n#### Syntax\n\ndayOfWeek(X)\n\n#### Details\n\nReturn which day of the week is *X*.\n\n#### Parameters\n\n**X** is a scalar/vector of type DATE, DATETIME, DATEHOUR, TIMESTAMP or NANOTIMESTAMP.\n\n#### Returns\n\nAn integer from 0 to 6, where 0 means Monday, .., 6 means Sunday.\n\n#### Examples\n\n```\ndayOfWeek(2012.12.05);\n// output: 2\n\ndayOfWeek 2013.05.23T12:00:00;\n// output: 3\n\ndayOfWeek(2014.01.11T23:04:28.113);\n// output: 5\n\ndayOfWeek(2012.12.05 2012.12.06 2013.01.05);\n// output: [2,3,4]\n```\n" }, "dayOfYear": { "url": "https://docs.dolphindb.com/en/Functions/d/dayOfYear.html", "signatures": [ { "full": "dayOfYear(X)", "name": "dayOfYear", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [dayOfYear](https://docs.dolphindb.com/en/Functions/d/dayOfYear.html)\n\n\n\n#### Syntax\n\ndayOfYear(X)\n\n#### Details\n\nReturn the day of the year for each element in *X*.\n\n#### Parameters\n\n**X** is a scalar/vector of type DATE, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n#### Returns\n\nAn integer.\n\n#### Examples\n\n```\ndayOfYear(2011.01.01);\n// output: 1\n\ndayOfYear([2011.12.31,2012.12.31]);\n// output: [365,366]\n\ndayOfYear([2012.06.12T12:30:00,2012.07.12T12:35:00]);\n// output: [164,194]\n```\n\nRelated functions: [dayOfMonth](https://docs.dolphindb.com/en/Functions/d/dayOfMonth.html), [quarterOfYear](https://docs.dolphindb.com/en/Functions/q/quarterOfYear.html), [monthOfYear](https://docs.dolphindb.com/en/Functions/m/monthOfYear.html), [weekOfYear](https://docs.dolphindb.com/en/Functions/w/weekOfYear.html), [hourOfDay](https://docs.dolphindb.com/en/Functions/h/hourOfDay.html), [minuteOfHour](https://docs.dolphindb.com/en/Functions/m/minuteOfHour.html), [secondOfMinute](https://docs.dolphindb.com/en/Functions/s/secondOfMinute.html), [millisecond](https://docs.dolphindb.com/en/Functions/m/millisecond.html), [microsecond](https://docs.dolphindb.com/en/Functions/m/microsecond.html), [nanosecond](https://docs.dolphindb.com/en/Functions/n/nanosecond.html)\n" }, "daysInMonth": { "url": "https://docs.dolphindb.com/en/Functions/d/daysInMonth.html", "signatures": [ { "full": "daysInMonth(X)", "name": "daysInMonth", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [daysInMonth](https://docs.dolphindb.com/en/Functions/d/daysInMonth.html)\n\n\n\n#### Syntax\n\ndaysInMonth(X)\n\n#### Details\n\nReturn the number of days in the month for each element in *X*.\n\n#### Parameters\n\n**X** is a scalar/vector of type DATE, DATEHOUR, DATETIME, TIMESTAMP or NANOTIMESTAMP.\n\n#### Returns\n\nAn integer.\n\n#### Examples\n\n```\ndaysInMonth(2012.06.12T12:30:00);\n// output: 30\n\ndaysInMonth([2012.02.01,2013.12.05]);\n// output: [29,31]\n```\n" }, "decimal128": { "url": "https://docs.dolphindb.com/en/Functions/d/decimal128.html", "signatures": [ { "full": "decimal128(X, scale)", "name": "decimal128", "parameters": [ { "full": "X", "name": "X" }, { "full": "scale", "name": "scale" } ] } ], "markdown": "### [decimal128](https://docs.dolphindb.com/en/Functions/d/decimal128.html)\n\n\n\n#### Syntax\n\ndecimal128(X, scale)\n\n#### Details\n\nConvert the input values into DECIMAL128.\n\n#### Parameters\n\n**X** is a scalar/vector of Integral, Floating, or STRING type.\n\n**scale** is an integer in \\[0,38] that determines the number of digits to the right of the decimal point.\n\n#### Returns\n\nA scalar or vector of type DECIMAL128.\n\n#### Examples\n\n```\na=decimal128(142, 2)\na\n// output: 142.00\n\nb=decimal128(1\\7, 6)\nb\n// output: 0.142857\n\na+b\n// output: 142.142857\n\na*b\n// output: 20.28569400\n\ndecimal128(\"3.1415926535\", 4)\n// output: 3.1416\n\n// All elements of a DECIMAL vector must be of the same type and scale\nd1=[1.23$DECIMAL128(4), 3$DECIMAL128(4), 3.14$DECIMAL128(4)];\n// output: [1.2300,3.0000,3.1400]\ntypestr(d1)\n// output: FAST DECIMAL128 VECTOR\n\n// If the elements are of different scales, a tuple is created\nd2=[1.23$DECIMAL128(4), 3$DECIMAL128(4), 3.14$DECIMAL128(3)];\n// output: (1.2300,3.0000,3.140)\ntypestr(d2)\n// output: ANY VECTOR\n```\n" }, "decimal32": { "url": "https://docs.dolphindb.com/en/Functions/d/decimal32.html", "signatures": [ { "full": "decimal32(X, scale)", "name": "decimal32", "parameters": [ { "full": "X", "name": "X" }, { "full": "scale", "name": "scale" } ] } ], "markdown": "### [decimal32](https://docs.dolphindb.com/en/Functions/d/decimal32.html)\n\n\n\n#### Syntax\n\ndecimal32(X, scale)\n\n#### Details\n\nConvert the input values into DECIMAL32 type.\n\n#### Parameters\n\n**X** is a scalar/vector of Integral, Floating, or STRING type.\n\n**scale** is an integer in \\[0,9] that determines the number of digits to the right of the decimal point.\n\n#### Returns\n\nA scalar or vector of type DECIMAL32.\n\n#### Examples\n\n```\na=decimal32(142, 2)\na\n// output: 142.00\n\nb=decimal32(1\\7, 6)\nb\n// output: 0.142857\n\na+b\n// output: 142.142857\n\na*b\n// output: 20.28569400\n\ndecimal32(\"3.1415926535\", 4)\n// output: 3.1415\n\n// the elements of a DECIMAL vector must be of the same decimal type and scale\nd1=[1.23$DECIMAL32(4), 3$DECIMAL32(4), 3.14$DECIMAL32(4)];\n// output: [1.2300,3.0000,3.1400]\ntypestr(d1)\n// output: FAST DECIMAL32 VECTOR\n\nd2=[1.23$DECIMAL32(4), 3$DECIMAL32(4), 3.14$DECIMAL32(3)];\n// output: (1.2300,3.0000,3.140)\ntypestr(d2)\n// output: ANY VECTOR\n```\n\n**Note:** When converting data of STRING/SYMBOL type into DECIMAL, there has been a modification in the way the decimal part exceeding the scale is handled since version 2.00.10.\n\n* Before version 2.00.10, the decimal part is truncated;\n\n* Starting from version 2.00.10, the decimal part is rounded.\n\n```\nsymbol([\"1.341\", \"4.5677\"])$DECIMAL32(2)\n//before version 2.00.10, the output is: [1.34,4.56]\n//starting from version 2.00.10, the output turns to: [1.34,4.57]\n```\n" }, "decimal64": { "url": "https://docs.dolphindb.com/en/Functions/d/decimal64.html", "signatures": [ { "full": "decimal64(X, scale)", "name": "decimal64", "parameters": [ { "full": "X", "name": "X" }, { "full": "scale", "name": "scale" } ] } ], "markdown": "### [decimal64](https://docs.dolphindb.com/en/Functions/d/decimal64.html)\n\n\n\n#### Syntax\n\ndecimal64(X, scale)\n\n#### Details\n\nConvert the input values into DECIMAL64.\n\n#### Parameters\n\n**X** is a scalar/vector of Integral, Floating, or STRING type.\n\n**scale** is an integer in \\[0,18] that determines the number of digits to the right of the decimal point.\n\n#### Returns\n\nA scalar or vector of type DECIMAL64.\n\n#### Examples\n\n```\na=decimal64(142, 2)\na\n// output: 142.00\n\nb=decimal64(1\\7, 6)\nb\n// output: 0.142857\n\na+b\n// output: 142.142857\n\na*b\n// output: 20.28569400\n\ndecimal64(\"3.1415926535\", 4)\n// output: 3.1415\n\n// the elements of a DECIMAL vector must be of the same decimal type and scale\nd1=[1.23$DECIMAL64(4), 3$DECIMAL64(4), 3.14$DECIMAL64(4)];\n// output: [1.2300,3.0000,3.1400]\ntypestr(d1)\n// output: FAST DECIMAL64 VECTOR\n\nd2=[1.23$DECIMAL64(4), 3$DECIMAL64(4), 3.14$DECIMAL64(3)];\n// output: (1.2300,3.0000,3.140)\ntypestr(d2)\n// output: ANY VECTOR\n```\n\n**Note:** When converting data of STRING/SYMBOL type into DECIMAL, there has been a modification in the way the decimal part exceeding the scale is handled since version 2.00.10.\n\n* Before version 2.00.10, the decimal part is truncated;\n\n* Starting from version 2.00.10, the decimal part is rounded.\n\n```\nsymbol([\"1.341\", \"4.5677\"])$DECIMAL64(2)\n//before version 2.00.10, the output is: [1.34,4.56]\n//starting from version 2.00.10, the output turns to: [1.34,4.57]\n```\n" }, "decimalFormat": { "url": "https://docs.dolphindb.com/en/Functions/d/decimalFormat.html", "signatures": [ { "full": "decimalFormat(X, format)", "name": "decimalFormat", "parameters": [ { "full": "X", "name": "X" }, { "full": "format", "name": "format" } ] } ], "markdown": "### [decimalFormat](https://docs.dolphindb.com/en/Functions/d/decimalFormat.html)\n\n\n\n#### Syntax\n\ndecimalFormat(X, format)\n\n#### Details\n\nApply a specified *format* to the given object.\n\n| Symbol | Meaning | Notes |\n| ------ | ----------------------------------------------------------------------------- | ------ |\n| 0 | mandatory digit | note 1 |\n| # | optional digit | note 2 |\n| . | decimal point | |\n| % | percent sign | note 3 |\n| E | separates mantissa and exponent in scientific notation. | note 4 |\n| , | grouping separator | note 5 |\n| ; | separates the format for positive numbers and the format for negative numbers | note 6 |\n\n* Note 1: The number of 0s before the decimal point means the minimum number of digits before the decimal point. In comparison, the number of 0s after the decimal point means the number of digits after the decimal point.\n\n ```\n decimalFormat(123,\"0\");\n // output: 123\n\n decimalFormat(123,\"00000\");\n // output: 00123\n\n decimalFormat(123.45,\"0\");\n // output: 123\n\n decimalFormat(123.45,\"0.0\");\n // output: 123.5\n\n decimalFormat(123.45,\"0.000\");\n // output: 123.450\n\n decimalFormat(123.45, \".0\");\n // output: 123.5\n\n decimalFormat(0.45, \".0\");\n // output: .5\n ```\n\n* Note 2: If 0s and #s are used together after the decimal point, 0s must appear before #s.\n\n ```\n decimalFormat(123.45,\"0.#\");\n // output: 123.5\n\n decimalFormat(123.45,\"0.###\");\n // output: 123.45\n\n decimalFormat(123.456,\"0.000###\");\n // output: 123.456\n\n decimalFormat(123.456789110,\"0.000###\");\n // output: 123.456789\n\n decimalFormat(0.345, \".##\");\n // output: .35\n ```\n\n* Note 3: % is always at the end of a format. % and E cannot both appear in a format.\n\n ```\n decimalFormat(0.125,\"0.00%\");\n // output: 12.50%\n\n decimalFormat(0.125, \"#.##%\");\n // output: 12.5%\n\n decimalFormat(0.12567,\"#.##%\");\n // output: 12.57%\n ```\n\n* Note 4: \"E\" is followed by at least one 0 and 0s only.\n\n ```\n decimalFormat(1234567.89,\"0.##E00\");\n // output: 1.23E06\n\n decimalFormat(0.0000000000123456789,\"0.000E0\");\n // output: 1.235E-11\n ```\n\n* Note 5: The grouping separator may only appear at most once in the parameter *format*. The number of digits between the grouping separator and the decimal point (if the decimal point is used) or the end of the format (if the decimal point is not used) determines the number of digits between grouping separators in the result.\n\n ```\n decimalFormat(123456789,\"#,###\");\n // output: 123,456,789\n\n decimalFormat(123456789.166,\"#,###.##\");\n // output: 123,456,789.17\n\n decimalFormat(123456789.166,\"0,000.00\");\n // output: 123,456,789.17\n ```\n\n* Note 6: If we prefer to apply different formats to an object depending on whether it is positive or negative, we can use \";\" to seperate the 2 formats.\n\n ```\n decimalFormat(123.456,\"0.00#E00;(0.00#E00)\");\n // output: 1.235E02\n\n decimalFormat(-123.456,\"0.00#E00;(0.00#E00)\");\n // output: (1.235E02)\n ```\n\n#### Parameters\n\n**X** is a scalar/vector of Integral or Floating type.\n\n**format** is a string indicating the format to apply to *X*.\n\n#### Returns\n\nA scalar or vector of type STRING.\n" }, "decimalMultiply": { "url": "https://docs.dolphindb.com/en/Functions/d/decimalMultiply.html", "signatures": [ { "full": "decimalMultiply(X, Y, scale)", "name": "decimalMultiply", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" }, { "full": "scale", "name": "scale" } ] } ], "markdown": "### [decimalMultiply](https://docs.dolphindb.com/en/Functions/d/decimalMultiply.html)\n\n\n\n#### Syntax\n\ndecimalMultiply(X, Y, scale)\n\n#### Details\n\nThe function multiplies Decimals. Compared with the [mul](https://docs.dolphindb.com/en/Functions/m/mul.html) function or operator [\\*](https://docs.dolphindb.com/en/Programming/Operators/OperatorReferences/mul.html), the function can set the decimal places of the result with *scale*.\n\nNote: In the following situations, the specified scale does not take effect and the function is equivalent to operator `*`.\n\n* Only one argument is of DECIMAL type (with scale S), and the specified *scale* is not equal to S.\n* *X* and *Y* are both of DECIMAL type (with scale S1 and S2, respectively), and the specified *scale* is smaller than `min(S1, S2)` or greater than `(S1+S2)`.\n* One argument is a floating-point number.\n\nFor the first two situations, the function return a DECIMAL type result, and for the third situation it returns a result of DOUBLE type.\n\n#### Parameters\n\n**X** and **Y** can be scalar or vector, and at least one argument is of DECIMAL type.\n\n**scale** is a non-negative integer indicating the decimal places to be retained in the result.\n\n#### Returns\n\nDECIMAL or DOUBLE type.\n\n#### Examples\n\n```\na = decimal32(`1.235, 3);\nb = decimal32(`7.5689, 4);\nc=decimalMultiply(a, b, 5)\n// output: 9.34759\n\ntypestr(c)\n// output: DECIMAL32\n\ndecimalMultiply(a, b, 2) // As scale is smaller than min(3,4), the operation is equivalent to a*b.\n// output: 9.3475915\n\nb=float(`7.5689)\nc=decimalMultiply(a, b, 5) // As b is a floating-point number, the operation is equivalent to a*b and returns a result of DOUBLE type.\n// output: 9.3475916337\ntypestr(c)\n// output: DOUBLE\n```\n\nIf the calculation result of a multiplication operation (`*`) or decimalMultiply overflows, it is automatically converted to type with higher precision. If the conversion fails, an exception will be thrown.\n\n```\nx = decimal32(1\\7, 8)\ny = decimal32(1\\6, 8)\nz = x * y\nz\n// output: 0.0238095223809524\ntypestr z\n// output\nDECIMAL64\n\nz = decimalMultiply(x, y, 8)\nz\n// output: 0.02380952\ntypestr z\n// output: DECIMAL64\n\nx = decimal128(1\\7, 35)\ny = decimal128(1\\6, 35)\nx*y\nx * y => Scale out of bound (valid range: [0, 38], but get: 70)\n\ndecimalMultiply(x, y, 35)\ndecimalMultiply(x, y, 35) => Decimal math overflow\n```\n\nWhen X or Y is a vector:\n\n```\nx = [decimal32(3.213312, 3), decimal32(3.1435332, 3), decimal32(3.54321, 3)]\ny = 2.1\ndecimalMultiply(x, y, 5)\n// output: [6.7473,6.6003,7.440300000000001]\n\nx = [decimal32(3.213312, 3), decimal32(3.1435332, 3), decimal32(3.54321, 3)]\ny = [decimal64(4.312412, 3), decimal64(4.53231, 3), decimal64(4.31258, 3)]\ndecimalMultiply(x, y, 5)\n// output: [13.85445,14.24407,15.27741]\n```\n" }, "declareStreamingSQLTable": { "url": "https://docs.dolphindb.com/en/Functions/d/declareStreamingSQLTable.html", "signatures": [ { "full": "declareStreamingSQLTable(table)", "name": "declareStreamingSQLTable", "parameters": [ { "full": "table", "name": "table" } ] } ], "markdown": "### [declareStreamingSQLTable](https://docs.dolphindb.com/en/Functions/d/declareStreamingSQLTable.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\ndeclareStreamingSQLTable(table)\n\n#### Details\n\nDeclare a specified table as the input table of streaming SQL. Only the declared table can be registered for streaming SQL query via `registerStreamingSQL`. This function does not affect the use of the table in regular SQL queries or other features.\n\n#### Parameters\n\n**table** A table object. Currently supports a shared table, including the in-memory table, keyed table and indexed table.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nt=table(1..10 as id,rand(100,10) as val)\nshare t as st\ndeclareStreamingSQLTable(st)\nregisterStreamingSQL(\"select avg(val) from st\")\n```\n\n**Related functions:** [listStreamingSQLTables](https://docs.dolphindb.com/en/Functions/l/listStreamingSQLTables.html), [registerStreamingSQL](https://docs.dolphindb.com/en/Functions/r/registerStreamingSQL.html), [revokeStreamingSQLTable](https://docs.dolphindb.com/en/Functions/r/revokeStreamingSQLTable.html)\n" }, "decodeShortGenomeSeq": { "url": "https://docs.dolphindb.com/en/Functions/d/decodeShortGenomeSeq.html", "signatures": [ { "full": "decodeShortGenomeSeq(X)", "name": "decodeShortGenomeSeq", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [decodeShortGenomeSeq](https://docs.dolphindb.com/en/Functions/d/decodeShortGenomeSeq.html)\n\n#### Syntax\n\ndecodeShortGenomeSeq(X)\n\nAlias: decodeSGS\n\n#### Details\n\nDecode the DNA sequences which have been encoded with `encodeShortGenomeSeg`.\n\n#### Parameters\n\n**X** is an integral scalar/vector.\n\n#### Returns\n\nA STRING scalar or vector.\n\n#### Examples\n\n```\na=encodeShortGenomeSeq(\"TCGATCG\")\ndecodeShortGenomeSeq(a)\n// output: \"TCGATCG\"\n\nb=encodeShortGenomeSeq(\"TCGATCG\" \"TCGATCGCCC\")\ndecodeShortGenomeSeq(b)\n// output: [\"TCGATCG\",\"TCGATCGCCC\"]\n \n// When the input is empty, an empty string is returned.\ndecodeShortGenomeSeq(int(NULL))\n// output: \"\"\n \n// encodeShortGenomeSeq returns NULL as the input exceeds 28 characters after \"TCGATCG\" is repeated 5 times. As a result, when decoding it, an empty string is returned.\nc=encodeShortGenomeSeq(repeat(\"TCGATCG\" \"TCGAT\", 5))\ndecodeShortGenomeSeq(c)\n// output: [,\"TCGATTCGATTCGATTCGATTCGAT\"] \n```\n\nRelated functions: [encodeShortGenomeSeq](https://docs.dolphindb.com/en/Functions/e/encodeShortGenomeSeq.html), [genShortGenomeSeq](https://docs.dolphindb.com/en/Functions/g/genShortGenomeSeq.html)\n\n" }, "decompress": { "url": "https://docs.dolphindb.com/en/Functions/d/decompress.html", "signatures": [ { "full": "decompress(X)", "name": "decompress", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [decompress](https://docs.dolphindb.com/en/Functions/d/decompress.html)\n\n\n\n#### Syntax\n\ndecompress(X)\n\n#### Details\n\nDecompress a compressed vector or a table.\n\n#### Parameters\n\n**X** is a compressed vector or a table.\n\n#### Returns\n\nA vector.\n\n#### Examples\n\n```\nx=1..100000000\ny=compress(x, \"delta\");\n\ny.typestr();\n// output: HUGE COMPRESSED VECTOR\n\nz=decompress(y);\nz.size();\n// output: 100000000\n```\n\nRelated function: [compress](https://docs.dolphindb.com/en/Functions/c/compress.html)\n" }, "deepCopy": { "url": "https://docs.dolphindb.com/en/Functions/d/deepCopy.html", "signatures": [ { "full": "deepCopy(obj)", "name": "deepCopy", "parameters": [ { "full": "obj", "name": "obj" } ] } ], "markdown": "### [deepCopy](https://docs.dolphindb.com/en/Functions/d/deepCopy.html)\n\nFirst introduced in version: 2.00.163.00.3\n\n\n\n#### Syntax\n\ndeepCopy(obj)\n\n#### Details\n\nReturns a deep copy of *obj*. A deep copy copies all mutable elements, resulting in a fully independent replica of the original object.\n\nThe difference between `copy` (shallow copy) and `deepCopy` (deep copy) is most evident when dealing with nested structures such as tuples or dictionaries of type ANY:\n\n* `copy` only duplicates the top-level structure, while sub-objects retain shared references (i.e., the sub-object addresses remain unchanged).\n* `deepCopy` recursively copies all sub-objects, ensuring fully independent references.\n\n#### Parameters\n\n**obj**can be of any data type.\n\n#### Returns\n\nAn object with the same data type and form as *obj*.\n\n#### Examples\n\nExample 1. Copy a vector\n\n```\nx = 1 2 3\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address // 000000000dd3d640\nprint constantDesc(a[0]).address // 000000000cb5a4c0\nprint constantDesc(b[0]).address // 000000000de92c20\n```\n\nExample 2. Copy a tuple\n\n```\nx = ([[1, 2], [3, 4]], \"a\")\na = x.copy()\nb = x.deepCopy();\n\nprint constantDesc(x[0]).address // 000000000c7ce880\nprint constantDesc(a[0]).address // 000000000c7ce880\nprint constantDesc(b[0]).address // 000000000c89be00\n```\n\nExample 3. Copy an ANY dictionary\n\n```\ny = dict(`A`B`C, (1 2, 3 4, 5 6))\nc = y.copy()\nd = y.deepCopy();\n\nprint constantDesc(y[`A]).address // 000000000c88c450\nprint constantDesc(c[`A]).address // 000000000c88c450\nprint constantDesc(d[`A]).address // 000000000c7cde00\n```\n\nRelated functions: [copy](https://docs.dolphindb.com/en/Functions/c/copy.html), [asis](https://docs.dolphindb.com/en/Functions/a/asis.html)\n" }, "defined": { "url": "https://docs.dolphindb.com/en/Functions/d/defined.html", "signatures": [ { "full": "defined(names, [type=VAR])", "name": "defined", "parameters": [ { "full": "names", "name": "names" }, { "full": "[type=VAR]", "name": "type", "optional": true, "default": "VAR" } ] } ], "markdown": "### [defined](https://docs.dolphindb.com/en/Functions/d/defined.html)\n\n\n\n#### Syntax\n\ndefined(names, \\[type=VAR])\n\n#### Details\n\nReturn a scalar/vector indicating whether each element of names is defined.\n\n#### Parameters\n\n**names** is a STRING scalar/vector indicating object name(s).\n\n**type** (optional) can be VAR (variable, default), SHARED (shared variable) or DEF (function definitions).\n\n#### Returns\n\nA BOOL scalar/vector.\n\n#### Examples\n\n```\nx=10\ny=20\ndef f(a){return a+1}\nshare table(1..3 as x, 4..6 as y) as t1;\n\ndefined([\"x\",\"y\",\"f\",`t1]);\n// output: [1,1,0,0]\n\ndefined([\"x\",\"y\",\"f\",`t1], DEF);\n// output: [0,0,1,0]\n\ndefined([\"x\",\"y\",\"f\",`t1], SHARED);\n// output: [0,0,0,1]\n```\n" }, "defs": { "url": "https://docs.dolphindb.com/en/Functions/d/defs.html", "signatures": [ { "full": "defs([X])", "name": "defs", "parameters": [ { "full": "[X]", "name": "X", "optional": true } ] } ], "markdown": "### [defs](https://docs.dolphindb.com/en/Functions/d/defs.html)\n\n\n\n#### Syntax\n\ndefs(\\[X])\n\n#### Details\n\n* If *X* is not specified, return all functions in the system as a table.\n* If *X* is specified, return all functions with names consistent with the pattern of *X*.\n\n#### Parameters\n\n**X** is a string. It supports wildcard symbols \"%\" and \"?\". \"%\" means 0, 1 or multiple characters and \"?\" means 1 character.\n\n#### Returns\n\nA table.\n\n#### Examples\n\n```\ndefs();\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ------- | --------- | ----------- | ------------- | ------------- | ----------- |\n| !=\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| !\\_1 | 0 | 0 | 1 | 1 | (X) |\n| $\\_2 | 0 | 0 | 2 | 2 | (obj, type) |\n| %\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| &&\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| &\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| \\*\\*\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| \\*\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| +\\_2 | 0 | 0 | 2 | 2 | (X, Y) |\n| -\\_1 | 0 | 0 | 1 | 1 | (X) |\n| ... | | | | | |\n\n```\ntypestr defs();\n// output: IN-MEMORY TABLE;\n\nselect * from defs() where name like \"bit%\";\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ------ | --------- | ----------- | ------------- | ------------- | ------ |\n| bitAnd | 0 | 0 | 2 | 2 | (X, Y) |\n| bitNot | 0 | 0 | 1 | 1 | (X) |\n| bitOr | 0 | 0 | 2 | 2 | (X, Y) |\n| bitXor | 0 | 0 | 2 | 2 | (X, Y) |\n\n```\ndefs(\"bit%\");\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ------ | --------- | ----------- | ------------- | ------------- | ------ |\n| bitAnd | 0 | 0 | 2 | 2 | (X, Y) |\n| bitNot | 0 | 0 | 1 | 1 | (X) |\n| bitOr | 0 | 0 | 2 | 2 | (X, Y) |\n| bitXor | 0 | 0 | 2 | 2 | (X, Y) |\n\n```\ndefs(\"%sin\");\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ---- | --------- | ----------- | ------------- | ------------- | ------ |\n| asin | 0 | 0 | 1 | 1 | (X) |\n| sin | 0 | 0 | 1 | 1 | (X) |\n\n```\ndefs(\"?sin\");\n```\n\n| name | isCommand | userDefined | minParamCount | maxParamCount | syntax |\n| ---- | --------- | ----------- | ------------- | ------------- | ------ |\n| asin | 0 | 0 | 1 | 1 | (X) |\n" }, "deg2rad": { "url": "https://docs.dolphindb.com/en/Functions/d/deg2rad.html", "signatures": [ { "full": "deg2rad(X)", "name": "deg2rad", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [deg2rad](https://docs.dolphindb.com/en/Functions/d/deg2rad.html)\n\n\n\n#### Syntax\n\ndeg2rad(X)\n\n#### Details\n\nConvert angle units from degrees to radians for each element of *X*.\n\n**Note:** DolphinDB's `deg2rad` function works the same as NumPy's [numpy.deg2rad](https://numpy.org/doc/stable/reference/generated/numpy.deg2rad.html), except that it only accepts a single parameter, *X*, and does not support parameters like *out* or *where* in `numpy.deg2rad`.\n\n#### Parameters\n\n**X** is a scalar/vector.\n\n#### Returns\n\nA DOUBLE scalar/vector.\n\n#### Examples\n\n```\ndeg2rad 45 90 180 360;\n// output: [0.785398,1.570796,3.141593,6.283185]\n```\n" }, "deleteChunkMetaOnMasterById": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteChunkMetaOnMasterById.html", "signatures": [ { "full": "deleteChunkMetaOnMasterById(chunkPath, chunkId)", "name": "deleteChunkMetaOnMasterById", "parameters": [ { "full": "chunkPath", "name": "chunkPath" }, { "full": "chunkId", "name": "chunkId" } ] } ], "markdown": "### [deleteChunkMetaOnMasterById](https://docs.dolphindb.com/en/Functions/d/deleteChunkMetaOnMasterById.html)\n\n\n\n#### Syntax\n\ndeleteChunkMetaOnMasterById(chunkPath, chunkId)\n\n#### Details\n\nDelete the metadata of the specified chunk on the control node based on the path and ID. This function can be called to delete the metadata of a chunk when data is unexpectedly lost on a data node. Normally, deleting chunk metadata prevents querying the data, but the data remains on the node, occupying disk space. It can only be executed by an administrator on the control node.\n\n#### Parameters\n\n**chunkPath** is a string indicating the path to the chunk.\n\n**chunkId** is a string indicating the chunk ID.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\n`deleteChunkMetaOnMasterById(chunkPath=\"/olap_value/8/40o\", chunkId=\"11d45d2d-a995-7c97-c041-32362f3400d7\")`\n```\n" }, "deleteGroup": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteGroup.html", "signatures": [ { "full": "deleteGroup(groupName)", "name": "deleteGroup", "parameters": [ { "full": "groupName", "name": "groupName" } ] } ], "markdown": "### [deleteGroup](https://docs.dolphindb.com/en/Functions/d/deleteGroup.html)\n\n\n\n#### Syntax\n\ndeleteGroup(groupName)\n\n#### Details\n\nDelete a group. It can only be executed by an administrator.\n\n#### Parameters\n\n**groupName** is a string indicating a group name.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndeleteGroup(`Production);\n```\n" }, "deleteGroupMember": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteGroupMember.html", "signatures": [ { "full": "deleteGroupMember(userIds, groupIds)", "name": "deleteGroupMember", "parameters": [ { "full": "userIds", "name": "userIds" }, { "full": "groupIds", "name": "groupIds" } ] } ], "markdown": "### [deleteGroupMember](https://docs.dolphindb.com/en/Functions/d/deleteGroupMember.html)\n\n\n\n#### Syntax\n\ndeleteGroupMember(userIds, groupIds)\n\n#### Details\n\nRemove a user from a group or multiple groups, or remove multiple users from a group.\n\nIt can only be executed by an administrator.\n\n#### Parameters\n\n**userIds** is a STRING scalar/vector indicating user name(s).\n\n**groupIds** is a STRING scalar/vector indicating group name(s).\n\n*userIds* and *groupIds* cannot both be vectors.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndeleteGroupMember(`AlexEdwards`ElizabethRoberts, `production);\n```\n" }, "deleteMarketHoliday": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteMarketHoliday.html", "signatures": [ { "full": "deleteMarketHoliday(marketName)", "name": "deleteMarketHoliday", "parameters": [ { "full": "marketName", "name": "marketName" } ] } ], "markdown": "### [deleteMarketHoliday](https://docs.dolphindb.com/en/Functions/d/deleteMarketHoliday.html)\n\nFirst introduced in version: 2.00.163.00.3\n\n\n\n#### Syntax\n\ndeleteMarketHoliday(marketName)\n\n#### Details\n\nDelete an existing trading calendar on the current node.\n\n**Note:**\n\n* This function can only be executed by an administrator.\n\n* It only takes effect on the current node. In a cluster, `pnodeRun` can be used to call this function on all data/compute nodes.\n\n#### Parameters\n\n**marketName** is a STRING scalar, indicating the identifier of the trading calendar to delete, e.g., “XNYS“.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nlistAllMarkets()\n// Output: [\"XTSE\",\"XCSE\",\"XLIM\",\"ADDA\",\"XSTO\",\"XIST\",\"AIXK\",\"SSE\",\"XMIL\",\"XFRA\",\"INE\",\"XMEX\",\"XBUD\",\"XICE\",\"XDUB\",\"SHFE\",\"CMES\",\"XOSL\",\"DCE\",\"CCFX\",\"CFFEX\",\"XIDX\",\"BVMF\",\"XBOG\",\"XKAR\",\"XSAU\",\"XBUE\",\"XTKS\",\"XBSE\",\"XMOS\"...]\n\ndeleteMarketHoliday(\"XTSE\")\n\"XTSE\" in listAllMarkets()\n// Output: false\n```\n\n**Related function: [addMarketHoliday](https://docs.dolphindb.com/en/Functions/a/addMarketHoliday.html)**\n" }, "deleteReplicas": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteReplicas.html", "signatures": [ { "full": "deleteReplicas(chunkId, nodeAlias)", "name": "deleteReplicas", "parameters": [ { "full": "chunkId", "name": "chunkId" }, { "full": "nodeAlias", "name": "nodeAlias" } ] } ], "markdown": "### [deleteReplicas](https://docs.dolphindb.com/en/Functions/d/deleteReplicas.html)\n\n\n\n#### Syntax\n\ndeleteReplicas(chunkId, nodeAlias)\n\n#### Details\n\nDelete replicas of one or multiple chunks from a node.\n\nThis command can only be executed by an administrator on a controller node.\n\n#### Parameters\n\n**chunkId** is a STRING scalar/vector indicating ID of chunks.\n\n**nodeAlias** is a string indicating the node alias.\n\n#### Returns\n\nNone.\n\n#### Examples\n\nDelete the replicas of all chunks on \"node1\".\n\n```\nchunkIds=exec chunkId from pnodeRun(getAllChunks) where node=\"node1\"\ndeleteReplicas(chunkIds,\"node1\");\n```\n" }, "deleteRule": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteRule.html", "signatures": [ { "full": "deleteRule(engineName, key)", "name": "deleteRule", "parameters": [ { "full": "engineName", "name": "engineName" }, { "full": "key", "name": "key" } ] } ], "markdown": "### [deleteRule](https://docs.dolphindb.com/en/Functions/d/deleteRule.html)\n\n\n\n#### Syntax\n\ndeleteRule(engineName, key)\n\n#### Details\n\nIf the specified *key*already exists in the rule engine, delete the corresponding rule set. The default rule set cannot be deleted.\n\n#### Parameters\n\n**engineName**is a string indicating the engine name.\n\n**key**is a STRING or INT scalar indicating the key for the rule set to be deleted.\n\n#### Returns\n\nReturns true if successful, otherwise false.\n\n#### Examples\n\n```\nx = [1, 2, NULL]\ny = [ [ < value>1 > ], [ < price<2 >, < price>6 > ], [ < value*price>10 > ] ]\nruleSets = dict(x, y)\nnames = `sym`value`price`quatity\ntypes = [INT, DOUBLE, DOUBLE, DOUBLE]\ndummy = table(10:0, names, types)\noutputNames = `sym`value`price`rule\noutputTypes = [INT, DOUBLE, DOUBLE, BOOL[]]\noutputTable = table(10:0, outputNames, outputTypes)\ntest = createRuleEngine(\"ruleEngineTest\",ruleSets,dummy ,`sym`value`price, outputTable, \"all\",`sym)\n\ntest.append!(table(1 as sym, 6 as value, 1 as price, 8 as quatity))\n// outputTable: 1\t6\t1\t[true]\n\n// delete the rule set for sym=1 and the default rule set will be applied to sym=1.\ndeleteRule(\"ruleEngineTest\",1)\ntest.append!(table(1 as sym, 6 as value, 1 as price, 8 as quatity))\n// outputTable: 1\t6\t1\t[false]\n```\n" }, "deleteScheduledJob": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteScheduledJob.html", "signatures": [ { "full": "deleteScheduledJob(jobId)", "name": "deleteScheduledJob", "parameters": [ { "full": "jobId", "name": "jobId" } ] } ], "markdown": "### [deleteScheduledJob](https://docs.dolphindb.com/en/Functions/d/deleteScheduledJob.html)\n\n\n\n#### Syntax\n\ndeleteScheduledJob(jobId)\n\n#### Details\n\nDelete a scheduled job. If the specified job ID doesn't exist, throw an exception.\n\n#### Parameters\n\n**jobId** is a string indicating a scheduled job ID.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndeleteScheduledJob(`dailyJob1);\n```\n" }, "deleteSparseReactiveMetric": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteSparseReactiveMetric.html", "signatures": [ { "full": "deleteSparseReactiveMetric(name, outputMetricKey)", "name": "deleteSparseReactiveMetric", "parameters": [ { "full": "name", "name": "name" }, { "full": "outputMetricKey", "name": "outputMetricKey" } ] } ], "markdown": "### [deleteSparseReactiveMetric](https://docs.dolphindb.com/en/Functions/d/deleteSparseReactiveMetric.html)\n\n\n\n#### Syntax\n\ndeleteSparseReactiveMetric(name, outputMetricKey)\n\n#### Details\n\nDeletes the rule corresponding to `outputMetricKey` in the specified SparseReactiveStateEngine. If it exists, it is deleted and true is returned; otherwise false is returned.\n\n#### Parameters\n\n**name** is a STRING scalar indicating the name of the SparseReactiveStateEngine.\n\n**outputMetricKey** is a STRING/SYMBOL scalar or vector indicating the output metric name(s) of the rule(s) to be deleted.\n\n#### Returns\n\nReturns a BOOL scalar. It returns true if the rule exists and is deleted; otherwise it returns false.\n\n#### Examples\n\n```\ndeleteSparseReactiveMetric(\"demoengine\", \"A002_2\")\n```\n\n**Related functions**: [createSparseReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createSparseReactiveStateEngine.html), [addSparseReactiveMetrics](https://docs.dolphindb.com/en/Functions/a/addSparseReactiveMetrics.html), [getSparseReactiveMetrics](https://docs.dolphindb.com/en/Functions/g/getSparseReactiveMetrics.html)\n" }, "deleteUser": { "url": "https://docs.dolphindb.com/en/Functions/d/deleteUser.html", "signatures": [ { "full": "deleteUser(userId)", "name": "deleteUser", "parameters": [ { "full": "userId", "name": "userId" } ] } ], "markdown": "### [deleteUser](https://docs.dolphindb.com/en/Functions/d/deleteUser.html)\n\n\n\n#### Syntax\n\ndeleteUser(userId)\n\n#### Details\n\nDelete a user. It removes the user from all the groups the user belongs to.\n\nIt can only be executed by an administrator.\n\n#### Parameters\n\n**userId** a string indicating a user name.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndeleteUser(`JohnSmith);\n```\n" }, "deleteDataViewItems": { "url": "https://docs.dolphindb.com/en/Functions/d/delete_data_view_items.html", "signatures": [ { "full": "deleteDataViewItems(engine, keys)", "name": "deleteDataViewItems", "parameters": [ { "full": "engine", "name": "engine" }, { "full": "keys", "name": "keys" } ] } ], "markdown": "### [deleteDataViewItems](https://docs.dolphindb.com/en/Functions/d/delete_data_view_items.html)\n\n\n\n#### Syntax\n\ndeleteDataViewItems(engine, keys)\n\n#### Details\n\nDeletes the data with the specified keys from a data view engine. If the key column specified in *keys* does not exist, an error will be raised during deletion.\n\nThe `deleteDataViewItems` functions can be called within a CEP engine context or outside of it.\n\n* Within a CEP engine: The system will first attempt to locate a data view engine handle with specified *engine* within the current CEP engine context. If a matching engine is found, the corresponding delete operation will be performed. If no such engine, the system will then search for a data view engine with the same handle outside of the CEP engine context.\n\n* Outside a CEP engine: The system will search for and perform corresponding operation on a data view engine handle with specified *engine* only from the context outside of any CEP engine.\n\n#### Parameters\n\n**engine** is the handle of a data view engine.\n\n**keys** is a scalar, vector, or tuple, indicating the key(s) to be removed. If the key is composite, a tuple should be provided, where each element represents a column that forms the key, and the order must be consistent with the order specified in *keyedColumns* in the engine.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nclass Monitor1:CEPMonitor{\n def addNewData(order)\n def deleteData(s)\n def Monitor1(){\n }\n def onload(){\n addEventListener(addNewData,\"Orders\",,\"all\")\n addEventListener(deleteData,\"Drop\",,\"all\")\n try{\n share(streamTable(1:0,`eventTime`sym`val0`val1`val2,[TIMESTAMP,SYMBOL,INT,FLOAT,DOUBLE]),'test_DV')\n createDataViewEngine(\"test_DV\",objByName('test_DV'),`sym,`eventTime,false)\n }catch(ex){}\n }\n def unload(){\n undef(`test_DV,SHARED)\n }\n def addNewData(order){\n getDataViewEngine('test_DV').append!(table([order.eventTime] as eventTime,[order.sym] as sym,[order.val1] as v1,[order.val2] as v2,[00i] as v3,[00i] as v4,[00i] as v5))\n }\n def deleteData(s){\n deleteDataViewItems('test_DV',s.sym)\n }\n}\nclass Orders{\n eventTime :: TIMESTAMP \n sym :: STRING\n val0 :: INT\n val1 :: FLOAT\n val2 :: DOUBLE\n def Orders(s,v0,v1,v2){\n sym = s\n val0 = v0\n val1 = v1\n val2 = v2\n eventTime = now()\n }\n}\nclass Drop{\n sym :: STRING\n eventTime :: TIMESTAMP\n def Drop(s){\n sym = s \n eventTime = now()\n }\n}\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"test_CEP\")}catch(ex){}\nengine=createCEPEngine(\"test_CEP\",,dummy,[Orders,Drop],,'eventTime',,,\"sym\")\nshare streamTable(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as input\ntry{dropStreamEngine(`serInput)}catch(ex){}\nserializer = streamEventSerializer(name=`serInput, eventSchema=Orders, outputTable=input, eventTimeField = \"eventTime\")\nsubscribeTable(,`input, `subopt1, 0,getStreamEngine('test_CEP'),true)\nappendEvent(`serInput,Orders(`a1,1,1.0,2.0))\n```\n\n**Related functions**: [createCEPEngine](https://docs.dolphindb.com/en/Functions/c/create_cep_engine.html), [createDataViewEngine](https://docs.dolphindb.com/en/Functions/c/create_data_view_engine.html), [dropDataViewEngine](https://docs.dolphindb.com/en/Functions/d/drop_data_view_engine.html), [getDataViewEngine](https://docs.dolphindb.com/en/Functions/g/get_data_view_engine.html)\n" }, "deltas": { "url": "https://docs.dolphindb.com/en/Functions/d/deltas.html", "signatures": [ { "full": "deltas(X, [n])", "name": "deltas", "parameters": [ { "full": "X", "name": "X" }, { "full": "[n]", "name": "n", "optional": true } ] } ], "markdown": "### [deltas](https://docs.dolphindb.com/en/Functions/d/deltas.html)\n\n\n\n#### Syntax\n\ndeltas(X, \\[n])\n\n#### Details\n\nFor each element *Xi* in *X*, return *Xi*-*Xi-n*, representing the differences between elements.\n\n#### Parameters\n\n**X** is a vector, matrix or table.\n\n**n** (optional) is an integer specifying the step to shift when comparing elements in *X*. The default value is 1, meaning to compare the current element with the adjacent element at left.\n\n#### Returns\n\nA vector/matrix/table with the same shape as *X*.\n\n#### Examples\n\n```\nx=7 4 5 8 9;\ndeltas(x);\n// output: [,-3,1,3,1] \n\nx=NULL 1 2 NULL 3;\ndeltas(x);\n// output: [,,1,,]\n\nm=matrix(1 3 2 5 6, 0 8 NULL 7 6);\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1 | 0 |\n| 3 | 8 |\n| 2 | |\n| 5 | 7 |\n| 6 | 6 |\n\n```\ndeltas(m);\n```\n\n| #0 | #1 |\n| -- | -- |\n| | |\n| 2 | 8 |\n| -1 | |\n| 3 | |\n| 1 | -1 |\n\nWhen *n* is a positive integer:\n\n```\nm=matrix(1 3 2 5 6, 0 8 NULL 7 6);\na=deltas(m,2)\na;\n```\n\n| 0 | 1 |\n| - | -- |\n| | |\n| | |\n| 1 | |\n| 2 | -1 |\n| 4 | |\n\nWhen n is a negative integer:\n\n```\nm = 3 4 6 9\nr2= deltas(m,-2)\nr2; \n// output: [-3,-5,,]\n```\n" }, "dema": { "url": "https://docs.dolphindb.com/en/Functions/d/dema.html", "signatures": [ { "full": "dema(X, window)", "name": "dema", "parameters": [ { "full": "X", "name": "X" }, { "full": "window", "name": "window" } ] } ], "markdown": "### [dema](https://docs.dolphindb.com/en/Functions/d/dema.html)\n\n\n\n#### Syntax\n\ndema(X, window)\n\nPlease see [TA-Lib Functions](https://docs.dolphindb.com/en/Functions/Themes/TALib.html) for the parameter description and windowing logic.\n\n#### Details\n\nCalculates the Double Exponential Moving Average (dema) for *X* in a sliding window of the given length.\n\nThe formula is:\n\n![](https://docs.dolphindb.com/en/images/ema1.png)\n\n![](https://docs.dolphindb.com/en/images/dema.png)\n\n**Note:**\n\nEquivalent to TA-Lib's `DEMA` function. The difference is that DolphinDB `dema` accepts vectors, matrices, and tables as input, whereas TA-Lib `DEMA` is primarily designed for one-dimensional NumPy arrays and does not support matrix or table inputs.\n\n#### Returns\n\nA vector with the same length as *X* or a matrix/table with the same dimensions as *X*.\n\n#### Examples\n\n```\nx=12.1 12.2 12.6 12.8 11.9 11.6 11.2\ndema(x,3);\n// output: [,,,,12.091666666666668,11.689583333333335,11.266666666666665]\n\nx=matrix(12.1 12.2 12.6 12.8 11.9 11.6 11.2, 14 15 18 19 21 12 10)\ndema(x,3);\n```\n\n| col1 | col2 |\n| ------- | ------- |\n| | |\n| | |\n| | |\n| | |\n| 12.0917 | 20.9444 |\n| 11.6896 | 14.6806 |\n| 11.2667 | 10.9444 |\n\nRelated functions: [ema](https://docs.dolphindb.com/en/Functions/e/ema.html), [tema](https://docs.dolphindb.com/en/Functions/t/tema.html)\n" }, "demean": { "url": "https://docs.dolphindb.com/en/Functions/d/demean.html", "signatures": [ { "full": "demean(X)", "name": "demean", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [demean](https://docs.dolphindb.com/en/Functions/d/demean.html)\n\n#### Syntax\n\ndemean(X)\n\n#### Details\n\nCenter a dataset (zero-centering), and return an object of DOUBLE type with the same dimension as *X*. Null values are ignored in the calculation.\n\n* If *X* is a vector, calculate X - avg(X);\n\n* If *X* is a matrix, perform calculations by columns;\n\n* If *X* is a table, perform calculations only for numeric columns.\n\n#### Parameters\n\n`X` is a numeric scalar/vector/matrix/table.\n\n#### Returns\n\nDOUBLE type.\n\n#### Examples\n\n```\nx = 1 NULL 2 3\ndemean(x)\n// output: [-1,,0,1]\n\nv = 1 0 1 1 8 2 -4 0\ndemean(v)\n// output: [-0.125,-1.125,-0.125,-0.125,6.875,0.875,-5.125,-1.125]\n```\n\n" }, "denseRank": { "url": "https://docs.dolphindb.com/en/Functions/d/denseRank.html", "signatures": [ { "full": "denseRank(X, [ascending=true],[ignoreNA=true], [percent=false])", "name": "denseRank", "parameters": [ { "full": "X", "name": "X" }, { "full": "[ascending=true]", "name": "ascending", "optional": true, "default": "true" }, { "full": "[ignoreNA=true]", "name": "ignoreNA", "optional": true, "default": "true" }, { "full": "[percent=false]", "name": "percent", "optional": true, "default": "false" } ] } ], "markdown": "### [denseRank](https://docs.dolphindb.com/en/Functions/d/denseRank.html)\n\n\n\n#### Syntax\n\ndenseRank(X, \\[ascending=true],\\[ignoreNA=true], \\[percent=false])\n\n#### Details\n\nIf *X* is a vector:\n\n* return the consecutive rank of each element in *X* based on the specified *ascending* order.\n\n* If *ignoreNA* = true, the null values are ignored in ranking and return NULL.\n\nIf *X* is a matrix, conduct the aforementioned calculation within each column of *X*. The result is a matrix with the same shape as *X*.\n\nIf *X* is a dictionary, the ranking is based on its values, and the ranks of all elements are returned.\n\nUnlike `denseRank`, [rank](https://docs.dolphindb.com/en/Functions/r/rank.html) skips positions after equal rankings.\n\n#### Parameters\n\n**X** is a vector/matrix/dictionary.\n\n**ascending** (optional) is a Boolean value indicating whether to sort in ascending order. The default value is true.\n\n**ignoreNA** (optional) is a Boolean value indicating whether null values are ignored in ranking. The default value is true. If set to false, null values are ranked as the minimum value.\n\n**percent** (optional) is a Boolean value, indicating whether to display the returned rankings in percentile form. The default value is false.\n\n#### Examples\n\n```\nx=1 5 5 6 8 8 9\nprint denseRank(x)\n// output: [0,1,1,2,3,3,4]\n\ny=time(4 1 1 2)\nprint denseRank(y, ascending=false)\n// output: [0,2,2,1]\nm = matrix(1 2 2 NULL, 0 0 0 1, 0 0 NULL 2)\ndenseRank(m, ignoreNA=false)\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 0 | 1 |\n| 2 | 0 | 1 |\n| 2 | 0 | 0 |\n| 0 | 1 | 2 |\n\n```\nt=table(`A`A`B`C`B`B`A`C`C as id,[4,1,NULL,1,2,4,5,0,-1] as val)\nselect id,val, denseRank(val) from t context by id\n```\n\n| id | val | denseRank\\_val |\n| -- | --- | -------------- |\n| A | 4 | 1 |\n| A | 1 | 0 |\n| A | 5 | 2 |\n| B | | |\n| B | 2 | 0 |\n| B | 4 | 1 |\n| C | 1 | 2 |\n| C | 0 | 1 |\n| C | -1 | 0 |\n\n```\ndenseRank(dict(`a`b`c`d, [4, 1, 1,2],true))\n// output: [2,0,0,1]\n```\n\nRelated function: [rowDenseRank](https://docs.dolphindb.com/en/Functions/r/rowDenseRank.html)\n" }, "deny": { "url": "https://docs.dolphindb.com/en/Functions/d/deny.html", "signatures": [ { "full": "deny(userId|groupId,accessType,[objs])", "name": "deny", "parameters": [ { "full": "userId|groupId", "name": "userId|groupId" }, { "full": "accessType", "name": "accessType" }, { "full": "[objs]", "name": "objs", "optional": true } ] } ], "markdown": "### [deny](https://docs.dolphindb.com/en/Functions/d/deny.html)\n\n\n\n#### Syntax\n\ndeny(userId|groupId,accessType,\\[objs])\n\n#### Details\n\nDeny specified access privileges to a user or a group.\n\nAdministrators can grant users all privileges (*accessType*) through this command, but regular users, after having the relevant OWNER privileges, can only grant the following privileges through this command: TABLE\\_READ, TABLE\\_WRITE, TABLE\\_INSERT, TABLE\\_UPDATE, TABLE\\_DELETE, DB\\_READ, DB\\_WRITE, DB\\_INSERT, DB\\_UPDATE, DB\\_DELETE, DBOBJ\\_DELETE, DBOBJ\\_CREATE and VIEW\\_EXEC.\n\nFor the types of permissions that can be denied, see [grant](https://docs.dolphindb.com/en/Functions/g/grant.html). Orca graph and stream table privileges: See Section 6.3 at [Orca Real-time Computing Platform](https://docs.dolphindb.com/en/Streaming/orca.md#).\n\nNote that when *accessType* is DB\\_OWNER, `deny` only takes effect globally.\n\n#### Parameters\n\n**userId** | **groupId** is a string indicating a user name or a group name.\n\n**accessType** is the privilege type or memory limit.\n\n**objs** (optional) is a STRING scalar/vector indicating the objects that the priviledges specified by *accessType* applies to. \"\\*\" means all objects. When *accessType* is COMPUTE\\_GROUP\\_EXEC, *objs* must be compute group(s).\n\nSee the privilege table in [User Access Control](https://docs.dolphindb.com/en/Maintenance/UserAccessControl.html) for the values that *accessType* and *objs* can take.\n\n**Note:**\n\n* When managing privileges for shared tables, stream tables or streaming engines, *objs* must be in the format \"tableName\\@nodeAlias\" or \"nodeAlias:tableName\".\n* When managing privileges for IMOLTP databases and tables, *objs* must be in the format \"oltp\\://database/table\\@nodeAlias\" or \"oltp\\://database\\@nodeAlias\".\n\n#### Returns\n\nNone.\n\n#### Examples\n\nNone of the members of the group \"production\" can read any table in the database *dfs\\://db1*:\n\n```\ndeny(`production, TABLE_READ, \"dfs://db1\")\n```\n\nNone of the members of the group \"research\" can write to the table *dfs\\://db1/t1*:\n\n```\ndeny(`research, TABLE_WRITE, \"dfs://db1/t1\")\n```\n\nNone of the members of the group \"research\" can create tables in the databases *dfs\\://db1* or *dfs\\://db2*:\n\n```\ndeny(\"research\", DBOBJ_CREATE, [\"dfs://db1\",\"dfs://db2\"])\n```\n\nThe user \"AlexSmith\" cannot create or delete databases:\n\n```\ndeny(\"AlexSmith\", DB_MANAGE)\n```\n\nThe user \"AlexSmith\" cannot execute script:\n\n```\ndeny(\"AlexSmith\", SCRIPT_EXEC)\n```\n\nThe user \"AlexSmith\" cannot test script:\n\n```\ndeny(\"AlexSmith\", TEST_EXEC)\n```\n" }, "derivative": { "url": "https://docs.dolphindb.com/en/Functions/d/derivative.html", "signatures": [ { "full": "derivative(func, X, [dx =1.0], [n=1], [order=3])", "name": "derivative", "parameters": [ { "full": "func", "name": "func" }, { "full": "X", "name": "X" }, { "full": "[dx =1.0]", "name": "[dx =1.0]" }, { "full": "[n=1]", "name": "n", "optional": true, "default": "1" }, { "full": "[order=3]", "name": "order", "optional": true, "default": "3" } ] } ], "markdown": "### [derivative](https://docs.dolphindb.com/en/Functions/d/derivative.html)\n\n\n\n#### Syntax\n\nderivative(func, X, \\[dx =1.0], \\[n=1], \\[order=3])\n\n#### Details\n\nReturn the derivative of *func* of order *n* at *X*.\n\n#### Parameters\n\n**func** is a unary function.\n\n**X** is a numeric scalar/vector indicating where the derivative is evaluated.\n\n**dx** (optional) is a scalar of FLOAT type indicating spacing. The default value is 1.0.\n\n**n** (optional) is an integer scalar indicating the order of the derivative. As of now only *n*=1 is supported.\n\n**order** (optional) is an integer scalar indicating the number of points to use. It must be an odd number. The default value is 3 and can be values between 3 and 1023.\n\n#### Returns\n\nA scalar or vector of type DOUBLE.\n\n#### Examples\n\n```\nderivative(acos, 0.458, 1e-3);\n// output: -1.12492\n\na=[0.25, -4.53, 1.85, 12.45, 2.0];\nderivative(cbrt, a, 1e-3, 1, 5);\n// output: [0.83995,0.121753,0.221189,0.062053,0.209987]\n\nderivative(pow{3,}, 5);\n// output: 324\n```\n" }, "destroyMonitor": { "url": "https://docs.dolphindb.com/en/Functions/d/destroy_monitor.html", "signatures": [ { "full": "destroyMonitor()", "name": "destroyMonitor", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [destroyMonitor](https://docs.dolphindb.com/en/Functions/d/destroy_monitor.html)\n\n\n\n#### Syntax\n\ndestroyMonitor()\n\n#### Details\n\nTerminates monitor instances.\n\nWhen a spawned monitor instance terminates, the engine invokes the monitor's `onDestroy` function, if it is defined.\n\nAfter terminating the monitor instance, the event listeners defined within that instance will cease to be triggered. It will not be removed until the next event match processing cycle starts. Note that monitors injected into the CEP Engine cannot be destroyed until the engine is deleted.\n\n#### Parameters\n\nNone.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nclass Monitor1:CEPMonitor{\n def addNewData(order)\n //def updateData(change)\n def Monitor1(){\n }\n def myDestroyMonitor(Orders){\n destroyMonitor()\n }\n def onload(){\n addEventListener(addNewData,\"Orders\",,\"all\")\n // When the Orders event has a v1 value of 5.0, this listener is triggered once,\n // and the myDestroyMonitor method is called to destroy the current monitor instance.\n addEventListener(handler=myDestroyMonitor, eventType=\"Orders\", condition=, times=1)\n try{\n share(streamTable(1:0,`eventTime`sym`val0`val1`val2,[TIMESTAMP,SYMBOL,INT,FLOAT,DOUBLE]),'test_DV')\n createDataViewEngine(\"test_DV\",objByName('test_DV'),`sym,`eventTime,false)\n }catch(ex){}\n }\n def unload(){\n undef(`test_DV,SHARED)\n }\n def addNewData(order){\n getDataViewEngine('test_DV').append!(table([order.eventTime] as eventTime,[order.sym] as sym,[order.val1] as v1,[order.val2] as v2,[00i] as v3,[00i] as v4,[00i] as v5))\n }\n\n}\nclass Orders{\n eventTime :: TIMESTAMP \n sym :: STRING\n val0 :: INT\n val1 :: FLOAT\n val2 :: DOUBLE\n def Orders(s,v0,v1,v2){\n sym = s\n val0 = v0\n val1 = v1\n val2 = v2\n eventTime = now()\n }\n}\n\ndummy = table(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs)\ntry{dropStreamEngine(\"test_CEP\")}catch(ex){}\nengine=createCEPEngine(\"test_CEP\",,dummy,Orders,,'eventTime',,,\"sym\")\nshare streamTable(array(TIMESTAMP, 0) as eventTime, array(STRING, 0) as eventType, array(BLOB, 0) as blobs) as input\ntry{dropStreamEngine(`serInput)}catch(ex){}\nserializer = streamEventSerializer(name=`serInput, eventSchema=Orders, outputTable=input, eventTimeField = \"eventTime\")\nsubscribeTable(,`input, `subopt1, 0,getStreamEngine('test_CEP'),true)\n```\n" }, "det": { "url": "https://docs.dolphindb.com/en/Functions/d/det.html", "signatures": [ { "full": "det(X)", "name": "det", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [det](https://docs.dolphindb.com/en/Functions/d/det.html)\n\n\n\n#### Syntax\n\ndet(X)\n\n#### Details\n\nReturn the determinant of matrix *X*. Null values are replaced with 0 in the calculation.\n\nDolphinDB’s `det` function and NumPy’s `numpy.linalg.det` have the same core functionality, but differ in parameter design and handling of missing values.\n\n* DolphinDB’s `det` requires the input to be a matrix object, whereas `numpy.linalg.det` accepts array-like inputs and automatically converts them to `ndarray`.\n* In terms of missing value handling, DolphinDB’s `det` treats NULL values as 0, while `numpy.linalg.det` returns NaN or Inf when the input contains NaN or Inf values. See the examples below for details.\n\n#### Parameters\n\n**X** is a matrix.\n\n#### Returns\n\nA DOUBLE scalar.\n\n#### Examples\n\n```\nx=1..4$2:2;\nx;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1 | 3 |\n| 2 | 4 |\n\n```\nx.det();\n// output: -2\n\nx=1 2 3 6 5 4 8 7 0$3:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 6 | 8 |\n| 2 | 5 | 7 |\n| 3 | 4 | 0 |\n\n```\ndet(x);\n// output: 42\n\nx=1 2 3 6 5 4 8 7 NULL $3:3;\nx;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 6 | 8 |\n| 2 | 5 | 7 |\n| 3 | 4 | |\n\n```\ndet(x);\n// output: 42\n```\n\nThe following code is executed in Python and demonstrates how NumPy’s `numpy.linalg.det` handles NaN and Inf values.\n\n```\nimport numpy as np\n\nA = np.array([\n [1, 6, 8],\n [2, 5, 7],\n [3, 4, np.nan]\n])\n\nprint(np.isnan(np.linalg.det(A)))\n# Return: True\n\nB = np.array([\n [1, 6, 8],\n [2, 5, 7],\n [3, 4, np.inf]\n])\nprint(np.isnan(np.linalg.det(B)))\n\n# Retur True\n```\n" }, "diag": { "url": "https://docs.dolphindb.com/en/Functions/d/diag.html", "signatures": [ { "full": "diag(X)", "name": "diag", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [diag](https://docs.dolphindb.com/en/Functions/d/diag.html)\n\n\n\n#### Syntax\n\ndiag(X)\n\n#### Details\n\n* If *X* is a vector, return a diagonal matrix.\n* If *X* is a square matrix, return a vector with the diagonal elements of the matrix.\n\nDolphinDB’s `diag` function and NumPy’s `numpy.diag` function are similar in their core functionality, but differ in parameter design, functional scope, and handling of missing values.\n\n* DolphinDB’s `diag` function accepts only a single argument, does not support diagonal offsets, operates only on the main diagonal, and requires the input to be either a vector or a square matrix.\n* `numpy.diag` supports an optional offset parameter, allowing extraction or construction of arbitrary diagonals, and accepts one-dimensional or two-dimensional arrays as input.\n* In terms of missing value handling, DolphinDB’s `diag` treats NULL values as 0, whereas `numpy.diag` preserves NaN/Inf values as-is.\n\n#### Parameters\n\n**X** is a numeric vector or a square matrix.\n\n#### Examples\n\n```\ndiag(1..5);\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1 | 0 | 0 | 0 | 0 |\n| 0 | 2 | 0 | 0 | 0 |\n| 0 | 0 | 3 | 0 | 0 |\n| 0 | 0 | 0 | 4 | 0 |\n| 0 | 0 | 0 | 0 | 5 |\n\n```\nm=1..4$2:2;\nm;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1 | 3 |\n| 2 | 4 |\n\n```\ndiag(m);\n// output: [1,4]\n```\n" }, "dict": { "url": "https://docs.dolphindb.com/en/Functions/d/dict.html", "signatures": [ { "full": "dict(keyObj, valueObj, [ordered=false])", "name": "dict", "parameters": [ { "full": "keyObj", "name": "keyObj" }, { "full": "valueObj", "name": "valueObj" }, { "full": "[ordered=false]", "name": "ordered", "optional": true, "default": "false" } ] }, { "full": "dict(keyType, valueType, [ordered=false])", "name": "dict", "parameters": [ { "full": "keyType", "name": "keyType" }, { "full": "valueType", "name": "valueType" }, { "full": "[ordered=false]", "name": "ordered", "optional": true, "default": "false" } ] } ], "markdown": "### [dict](https://docs.dolphindb.com/en/Functions/d/dict.html)\n\n\n\n#### Syntax\n\ndict(keyObj, valueObj, \\[ordered=false])\n\nor\n\ndict(keyType, valueType, \\[ordered=false])\n\n#### Details\n\nReturn a dictionary object.\n\n#### Parameters\n\nFor the first usage:\n\n**keyObj** is a vector indicating dictionary keys.\n\n**valueObj** is a vector indicating dictionary values.\n\nFor the second usage:\n\n**keyType** is the data type of dictionary keys. The following data categories are supported: Integral (excluding COMPRESSED), Temporal, Floating and Literal.\n\n**valueType** is the data type of dictionary values. Note that COMPLEX/POINT/DECIMAL is not supported.\n\n**ordered** (optional) is a Boolean value. The default value is false, which indicates to create a regular dictionary. True means to create an ordered dictionary. The regular dictionaries do not track the insertion order of the key-value pairs whereas the ordered dictionaries preserve the insertion order of key-value pairs.\n\n#### Examples\n\n```\nx=1 2 3\ny=4.5 7.8 4.3\nz=dict(x,y);\nz;\n/* output\n3->4.3\n1->4.5\n2->7.8\n*/\n\nz=dict(INT,DOUBLE);\nz[5]=7.9;\nz;\n// output: 5->7.9\n\nz[3]=6;\nz;\n/* output\n3->6\n5->7.9\n*/\n\ndt=dict([`test], [1]);\ndt;\n// output: test->1\n\n//create an ordered dictionary\nz=dict(x,y,true)\nz;\n/* ouput\n1->4.5\n2->7.8\n3->4.3\n*/\n\n// y is a vector of DECIMAL32 type. Create an ordered dictionary z with y as values.\nx=1 3 2\ny = decimal32\\(1.23 3 3.14, 3\\)\nz=dict\\(x,y,true\\);\nz;\n/\\* output\n1->1.230\n3->3.000\n2->3.140\n*/\n```\n\nTo get keys and values of a dictionary:\n\n```\nx=1 2 3\ny=4.5 7.8 4.3\nz=dict(x,y);\n\nz.keys();\n// output: [3,1,2]\n\nz.values();\n// output: [4.3,4.5,7.8]\n```\n\nrelated system functions: [array](https://docs.dolphindb.com/en/Functions/a/array.html), [matrix](https://docs.dolphindb.com/en/Functions/m/matrix.html), [dictUpdate!](https://docs.dolphindb.com/en/Functions/d/dictUpdate!.html), [syncDict](https://docs.dolphindb.com/en/Functions/s/syncDict.html)\n" }, "dictUpdate!": { "url": "https://docs.dolphindb.com/en/Functions/d/dictUpdate!.html", "signatures": [ { "full": "dictUpdate!(dictionary, function, keys, parameters, [initFunc=copy])", "name": "dictUpdate!", "parameters": [ { "full": "dictionary", "name": "dictionary" }, { "full": "function", "name": "function" }, { "full": "keys", "name": "keys" }, { "full": "parameters", "name": "parameters" }, { "full": "[initFunc=copy]", "name": "initFunc", "optional": true, "default": "copy" } ] } ], "markdown": "### [dictUpdate!](https://docs.dolphindb.com/en/Functions/d/dictUpdate!.html)\n\n\n\n#### Syntax\n\ndictUpdate!(dictionary, function, keys, parameters, \\[initFunc=copy])\n\n#### Details\n\nUpdate a dictionary for specified keys with the specified function.\n\n#### Parameters\n\n**dictionary** is a dictionary object.\n\n**function** is a function object.\n\n**keys** is a scalar/vector indicating for which keys to apply the *function*.\n\n**parameters** are of the same size as *keys*. The arguments passed to the applied function are *parameters* and the initial values of the dictionary.\n\n**initFunc** (optional) is a unary function. If the update operation involves new keys that did not exist in the dictionary to be updated, execute *initFunc* for these keys. If *initFunc* is specified, the values of *dictionary* must be a tuple.\n\n#### Returns\n\nAn updated table.\n\n#### Examples\n\n```\nx=dict(1 2 3, 1 1 1);\nx;\n/* output\n3->1\n1->1\n2->1\n*/\n\ndictUpdate!(x, add, 2 3, 1 2);\n/* output\n3->3\n1->1\n2->2\n*/\n\nx.dictUpdate!(mul, 3 4, 2 4);\n/* output\n4->4\n3->6\n1->1\n2->2\n*/\n\nd = dict(`IBM`MSFT, [1 2, 3 4])\nmsg = table(`IBM`MSFT`GOOG as symbol, 2 3 2 as ap)\nd.dictUpdate!(append!, msg.symbol, msg.ap, x->array(x.type(), 0, 512).append!(x))\nd;\n/* output\nMSFT->[3,4,3]\nGOOG->[2]\nIBM->[1,2,2]\n*/\n```\n" }, "difference": { "url": "https://docs.dolphindb.com/en/Functions/d/difference.html", "signatures": [ { "full": "difference(X)", "name": "difference", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [difference](https://docs.dolphindb.com/en/Functions/d/difference.html)\n\n\n\n#### Syntax\n\ndifference(X)\n\n#### Details\n\nReturn the last element minus the first element of a vector. If *X* is a scalar, it returns 0.\n\n#### Parameters\n\n**X** is a scalar/vector.\n\n#### Returns\n\nA DOUBLE scalar.\n\n#### Examples\n\n```\ndifference(2 4 2);\n// output: 0\n\ndifference(12.3 15.6 17.8);\n// output: 5.5\n\ndifference(278);\n// output: 0\n```\n" }, "differentialEvolution": { "url": "https://docs.dolphindb.com/en/Functions/d/differentialEvolution.html", "signatures": [ { "full": "differentialEvolution(func, bounds, [X0], [maxIter=1000], [popSize=15], [mutation], [recombination=0.7], [tol=0.01], [atol=0], [polish=true], [seed])", "name": "differentialEvolution", "parameters": [ { "full": "func", "name": "func" }, { "full": "bounds", "name": "bounds" }, { "full": "[X0]", "name": "X0", "optional": true }, { "full": "[maxIter=1000]", "name": "maxIter", "optional": true, "default": "1000" }, { "full": "[popSize=15]", "name": "popSize", "optional": true, "default": "15" }, { "full": "[mutation]", "name": "mutation", "optional": true }, { "full": "[recombination=0.7]", "name": "recombination", "optional": true, "default": "0.7" }, { "full": "[tol=0.01]", "name": "tol", "optional": true, "default": "0.01" }, { "full": "[atol=0]", "name": "atol", "optional": true, "default": "0" }, { "full": "[polish=true]", "name": "polish", "optional": true, "default": "true" }, { "full": "[seed]", "name": "seed", "optional": true } ] } ], "markdown": "### [differentialEvolution](https://docs.dolphindb.com/en/Functions/d/differentialEvolution.html)\n\n\n\n#### Syntax\n\ndifferentialEvolution(func, bounds, \\[X0], \\[maxIter=1000], \\[popSize=15], \\[mutation], \\[recombination=0.7], \\[tol=0.01], \\[atol=0], \\[polish=true], \\[seed])\n\n#### Details\n\nUse the Differential Evolution algorithm to calculate the global minimum of a function with multiple variables.\n\n#### Parameters\n\n**func** is the objective function to be minimized. Note that the function must return a scalar.\n\n**bounds** is a numeric matrix of shape (N, 2) indicating the bounds for parameters, where N is the number of parameters to be optimized.\n\n**X0** (optional) is a numeric vector indicating the initial guess to the minimization.\n\n**Note**:\n\n* Each row in the *bound* parameter contains two values (min, max), which define the lower and upper limits for the parameter values specified by *X0*.\n* *X0* and *bounds* must have the same length, i.e., N = size(*X0*).\n\n**maxIter** (optional) is a non-negative integer indicating the maximum number of iterations. The default value is 1000.\n\n**popSize** (optional) is a positive integer specifying the multiplier for setting the total population size. The population contains `popSize*(N - N_equal)` individuals, where `N_equal` represents the number of parameters whose bounds are equal. The default value is 15.\n\n**mutation** (optional) is a numeric pair in the format of (min, max), indicating the range of the mutation constant. It should satisfy 0 <= min <= max < 2. The default value is (0.5, 1).\n\n**recombination** (optional) is a numeric scalar in \\[0, 1], indicating the recombination constant, also known as the crossover probability.\n\n**tol** (optional) is a non-negative floating-point scalar indicating the relative tolerance for convergence. The default value is 0.01.\n\n**atol** (optional) is a non-negative floating-point scalar indicating the absolute tolerance for convergence. The default value is 0. The algorithm terminates when `stdev(population_energies) <= atol + tol * abs(mean(population_energies))`, where `population_energies` is the vector consisting of objective function values for all individuals in the population.\n\n**polish** (optional) is a Boolean scalar indicating whether to polish the differential evolution result using the L-BFGS-B method. The default value is true.\n\n**seed** (optional) is an integer indicating the random seed used in the differential evolution algorithm, allowing users to reproduce the results. If unspecified (default), a non-deterministic random number generator is used.\n\n#### Returns\n\nA dictionary containing the following keys:\n\n* xopt: A floating-point vector indicating the parameter values that minimize the objective function.\n* fopt: A floating-point scalar indicating the minimum value of the objective function, where fopt = f(xopt).\n* iterations: An integer indicating the number of iterations during the optimization process.\n* fcalls: An integer indicating the number of times the objective function is called during the optimization process.\n* converged: A Boolean scalar indicating whether the optimization result is converged.\n * true: The optimization result has been converged to below a preset tolerance and the algorithm terminates.\n * false: The algorithm terminates without converging after reaching the maximum number of iterations.\n\n#### Examples\n\nThe following example creates a user-defined function `rosen` and uses `differentialEvolution` (with *bounds* specified) to calculate the global minimum of `rosen`.\n\n```\ndef rosen(x) { \n\tN = size(x);\n\treturn sum(100.0*power(x[1:]-power(x[:N-1], 2.0), 2.0)+power(1-x[:N-1], 2.0));\n}\nbounds = matrix([0 0 0 0 0, 2 2 2 2 2])\ndifferentialEvolution(rosen, bounds)\n\n/* Ouput:\nfcalls->43656\nxopt->[1.000000000000,1.000000000000,1.000000000000,1.000000000000,1.000000000000]\nfopt->0.0\niterations->581\nconverged->true\n*/\n```\n" }, "digitize": { "url": "https://docs.dolphindb.com/en/Functions/d/digitize.html", "signatures": [ { "full": "digitize(x, bins, [right=false])", "name": "digitize", "parameters": [ { "full": "x", "name": "x" }, { "full": "bins", "name": "bins" }, { "full": "[right=false]", "name": "right", "optional": true, "default": "false" } ] } ], "markdown": "### [digitize](https://docs.dolphindb.com/en/Functions/d/digitize.html)\n\n#### Syntax\n\ndigitize(x, bins, \\[right=false])\n\n#### Details\n\nReturn the indices of the bins to which each value in *x* belongs. The return value has the same data form as *x*.\n\n| *right* | order of *bins* | returned index *i* satisfies |\n| ------- | --------------- | ---------------------------- |\n| false | increasing | bins\\[i-1] <= x < bins\\[i] |\n| true | increasing | bins\\[i-1] < x <= bins\\[i] |\n| false | decreasing | bins\\[i-1] > x >= bins\\[i] |\n| true | decreasing | bins\\[i-1] >= x > bins\\[i] |\n\nIf values in *x* are beyond the bounds of *bins*, 0 (for values beyond left bound) or length of *bins*(for values beyond right bound) is returned.\n\nThis function serves the same functionality as numpy.digitize.\n\nDifference from Python’s `numpy.digitize`: DolphinDB’s `digitize` has the same core functionality as `numpy.digitize`, and *bins* can be increasing or decreasing. In DolphinDB, *x* supports scalar or vector inputs. In NumPy, *x* can be an array of any shape, and the return value is an ndarray of the same shape.\n\n#### Parameters\n\n**x**is a scalar or vector of floating-point, integral, or DECIMAL type, indicating the value to be binned.\n\n**bins** is a monotonically increasing or decreasing vector of floating-point, integral, or DECIMAL type, indicating the bins.\n\n**right** (optional) is a Boolean value indicating whether the intervals include the right or the left bin edge. Default behavior is*right*=false indicating that the interval includes the left edge.\n\n#### Examples\n\nWhen *x* is a scalar:\n\n```\nbins = [1,3,3,5,5]\n\n// returns index i that satisfies bins[i-1] <= 3 < bins[i]\ndigitize(3, bins=bins, right=false)\n// output: 3\n\n//returns index i that satisfies bins[i-1] <= 5 < bins[i]. Since bins[i] > 5 does not exist, size(bins) is returned.\ndigitize(5, bins=bins, right=false)\n//output: 5\n\n// returns index i that satisfies bins[i-1] < 5 <= bins[i].\ndigitize(5, bins=bins, right=true)\n//output: 3\n\nbins = reverse(bins)\ndigitize(5, bins=bins, right=false)\n//output: 0\n\ndigitize(5, bins=bins, right=true)\n//output: 2\n```\n\nWhen *x* is a vector:\n\n```\nx = [-1,0,1,2,3,4,5,6]\nbins = [1,3,5]\ndigitize(x=x, bins=bins, right=false)\n//output: [0,0,1,1,2,2,3,3]\n\ndigitize(x=x, bins=bins, right=true)\n//output: [0,0,0,1,1,2,2,3]\n\nbins = reverse(bins)\ndigitize(x=x, bins=bins, right=false)\n//output: [3,3,2,2,1,1,0,0]\n\ndigitize(x=x, bins=bins, right=true)\n//output: [3,3,3,2,2,1,1,0]\n```\n\nThe following example demonstrates the difference between `digitize` and `bucket`.\n\nFor function `bucket`, if the number of elements of the input vector that belong to *dataRange*(\"\\[12, 53)\" in this case) is not a multiple of *bucketNum*(\\*\"\\*2\" in this case), an error will be thrown. The `digitize` function, however, is more flexible in customizing *bins*.\n\n```\nbucket(9 23 54 36 46 12, 12:53, 2)\n//throw an error: dataRange must be the mutltiplier of bucketNum.\n\ndigitize(9 23 54 36 46 12 , 12 40 53)\n// output: [0,1,3,1,2,1]\n```\n\n" }, "disableActivePartition": { "url": "https://docs.dolphindb.com/en/Functions/d/disableActivePartition.html", "signatures": [ { "full": "disableActivePartition(dbHandle)", "name": "disableActivePartition", "parameters": [ { "full": "dbHandle", "name": "dbHandle" } ] } ], "markdown": "### [disableActivePartition](https://docs.dolphindb.com/en/Functions/d/disableActivePartition.html)\n\n\n\n#### Syntax\n\ndisableActivePartition(dbHandle)\n\n#### Details\n\nCancel the connection between the active database and the historical database.\n\n#### Parameters\n\n**dbHandle** is the handle of the historical database.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nhistdb = database(\"C:\\DolphinDBDemo\\example\\data\\dbspace\\historical-A\\Trades2ndDomain\")\nactiveNodeAlias = getNodeAlias()\nactiveDate = today()\nenableActivePartition(histdb, activeDate, activeNodeAlias);\n\ndisableActivePartition(histdb);\n```\n" }, "disableDynamicScriptOptimization": { "url": "https://docs.dolphindb.com/en/Functions/d/disabledynamicscriptoptimization.html", "signatures": [ { "full": "enableDynamicScriptOptimization()", "name": "enableDynamicScriptOptimization", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [disableDynamicScriptOptimization](https://docs.dolphindb.com/en/Functions/d/disabledynamicscriptoptimization.html)\n\n\n\n#### Syntax\n\nenableDynamicScriptOptimization()\n\n#### Details\n\nDisable script engine optimization.\n\nThis command must be executed by an administrator on the controller node.\n\nThe effect of this command will be lost after the system restarts. To make it permanent, please modify the configuration parameter *enableDynamicScriptOptimization* in the configuration file (controller.cfg for cluster mode, dolphindb.cfg for single-node mode)\n\n#### Examples\n\n```\nenableDynamicScriptOptimize()\n```\n\n**Related Functions:** [enableDynamicScriptOptimization](https://docs.dolphindb.com/en/Functions/e/enabledynamicscriptoptimization.html)\n" }, "disableQueryMonitor": { "url": "https://docs.dolphindb.com/en/Functions/d/disableQueryMonitor.html", "signatures": [ { "full": "disableQueryMonitor()", "name": "disableQueryMonitor", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [disableQueryMonitor](https://docs.dolphindb.com/en/Functions/d/disableQueryMonitor.html)\n\n\n\n#### Syntax\n\ndisableQueryMonitor()\n\n#### Details\n\nDisable the monitor on query status.\n\nAs monitoring the query status has some memory overhead, you can disable the monitor when the system is low on memory.\n\nNote: After calling the command, users cannot get the query job status with [getQueryStatus](https://docs.dolphindb.com/en/Functions/g/getQueryStatus.html).\n\n#### Parameters\n\nNone.\n\n#### Returns\n\nNone.\n\nRelated function: [enableQueryMonitor](https://docs.dolphindb.com/en/Functions/e/enableQueryMonitor.html)\n" }, "disableResourceTracking": { "url": "https://docs.dolphindb.com/en/Functions/d/disableresourcetracking.html", "signatures": [ { "full": "disableResourceTracking()", "name": "disableResourceTracking", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [disableResourceTracking](https://docs.dolphindb.com/en/Functions/d/disableresourcetracking.html)\n\n\n\n#### Syntax\n\ndisableResourceTracking()\n\n#### Details\n\nUse this function to disable resource tracking at runtime. This function can only be called by the administrator on a data node, and it only takes effect when *resourceSamplingInterval*is set to a positive integer. Note that enabling or disabling resource tracking will not affect log retention.\n\n#### Parameters\n\nNone.\n\n#### Returns\n\nNone.\n\nRelated function: [enableResourceTracking](https://docs.dolphindb.com/en/Functions/e/enableresourcetracking.html)\n" }, "disableTablePersistence": { "url": "https://docs.dolphindb.com/en/Functions/d/disableTablePersistence.html", "signatures": [ { "full": "disableTablePersistence(table)", "name": "disableTablePersistence", "parameters": [ { "full": "table", "name": "table" } ] } ], "markdown": "### [disableTablePersistence](https://docs.dolphindb.com/en/Functions/d/disableTablePersistence.html)\n\n\n\n#### Syntax\n\ndisableTablePersistence(table)\n\n#### Details\n\nDisable a table persistence to disk. Any future update of the table will not be persisted to disk.\n\n#### Parameters\n\n**table** is a table object.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ncolName=[\"time\",\"x\"]\ncolType=[\"timestamp\",\"int\"]\nt = streamTable(100:0, colName, colType);\nshare t as st\nenableTablePersistence(table=st, cacheSize=1200000)\n```\n\n```\nfor(s in 0:200){\n n=10000\n time=2019.01.01T00:00:00.000+s*n+1..n\n x=rand(10.0, n)\n insert into st values(time, x)\n}\ndisableTablePersistence(st);\n```\n\n**Related functions:** [enableTablePersistence](https://docs.dolphindb.com/en/Functions/e/enableTablePersistence.html), [clearTablePersistence](https://docs.dolphindb.com/en/Functions/c/clearTablePersistence.html)\n" }, "disableTSDBAsyncSorting": { "url": "https://docs.dolphindb.com/en/Functions/d/disableTSDBAsyncSorting.html", "signatures": [ { "full": "disableTSDBAsyncSorting()", "name": "disableTSDBAsyncSorting", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [disableTSDBAsyncSorting](https://docs.dolphindb.com/en/Functions/d/disableTSDBAsyncSorting.html)\n\n\n\n#### Syntax\n\ndisableTSDBAsyncSorting()\n\n#### Details\n\nData written to the TSDB cache engine are sorted by *sortColumns*. The tasks of writing and sorting data can be processed synchronously or asynchronously. Execute the command to disable asynchronous sorting mode. This command can only be executed by an administrator on a data node.\n\n#### Parameters\n\nNone.\n\n#### Returns\n\nNone.\n\nRelated function: [enableTSDBAsyncSorting](https://docs.dolphindb.com/en/Functions/e/enableTSDBAsyncSorting.html)\n" }, "distance": { "url": "https://docs.dolphindb.com/en/Functions/d/distance.html", "signatures": [ { "full": "distance(X, Y)", "name": "distance", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [distance](https://docs.dolphindb.com/en/Functions/d/distance.html)\n\n\n\n#### Syntax\n\ndistance(X, Y)\n\n#### Details\n\nCalculate the distance in meters between 2 points on the earth's surface.\n\n#### Parameters\n\n**X** and **Y** can be a POINT scalar/pair/vector representing points in the coordinate system of earth.\n\n#### Examples\n\n```\np1 = point(180, 24.118418)\np2 = point(180, 24.11931)\ndistance(p1,p2)\n// output: 99.185916\n\np1 = point(117.60972, 24.118418)\np2 = point(117.50972, 24.118418)\np3 = point(117.70972, 24.118418)\np4 = point(117.75972, 24.118418)\ndistance([p1,p2], [p3,p4])\n```\n\n| 0 | 1 |\n| ---------- | ----------- |\n| 10,148.799 | 25,371.9947 |\n\nCalculate the distance between the two points p1 (Lon1,Lat1) and p2 (Lon2,Lat2) on the map. Based on the 0-degree longitude, the east longitude is taken as a positive value (Longitude), the west longitude is taken as a negative value (-Longitude), the north latitude is taken as 90-latitude, and the south latitude is taken as 90+latitude. So the calculation is:\n\n```\np1 = point(-117.60972,24.118418) //Longitude: 117.60972 W Latitude: 65.881582 N\np2 = point(117.61113,114.11931) //Longitude: 117.60972 E Latitude: 24.118418 S\ndistance(p1,p2)\n// output: 6.02098E6\n```\n" }, "distinct": { "url": "https://docs.dolphindb.com/en/Functions/d/distinct.html", "signatures": [ { "full": "distinct(X)", "name": "distinct", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [distinct](https://docs.dolphindb.com/en/Functions/d/distinct.html)\n\n\n\n#### Syntax\n\ndistinct(X)\n\n#### Details\n\nReturn the distinct elements from *X*. Since version 2.00.173.00.4, the order of the returned elements matches the order of their first appearance in the input.\n\n#### Parameters\n\n**X** is a vector or array vector.\n\n#### Examples\n\n```\ndistinct(4 5 5 2 3)\n// output: [4,5,2,3]\n\na = array(INT[], 0, 10).append!([1 2 3, 4 5, 6 7 8, 9 10])\ndistinct(a)\n// output: [1,2,3,4,5,6,7,8,9,10]\n\nt=table(3 1 2 2 3 as x);\nselect distinct x from t;\n```\n\n| distinct\\_x |\n| ----------- |\n| 3 |\n| 1 |\n| 2 |\n\n```\nselect sort(distinct(x)) as x from t;\n```\n\n| x |\n| - |\n| 1 |\n| 2 |\n| 3 |\n\nThe function `distinct` returns a vector, while the function [set](https://docs.dolphindb.com/en/Functions/s/set.html) returns a set.\n\n```\nx=set(4 5 5 2 3)\nx\n// output: set(3,2,5,4)\n\nx.intersection(set(2 5))\n// output: set(2,5)\n```\n\nFor in-memory or distributed tables, `distinct` can be used with `group by` to return an array vector of unique values for each group.\n\n```\ndbName = \"dfs://testdb\"\nif(existsDatabase(dbName)){\n dropDatabase(dbName)\n}\n\ndb=database(\"dfs://testdb\", VALUE, 2012.01.11..2012.01.29)\n\nn=100\nt=table(take(2012.01.11..2012.01.29, n) as date, symbol(take(\"A\"+string(21..60), n)) as sym, take(100, n) as val)\n\npt=db.createPartitionedTable(t, `pt, `date).append!(t)\nresult=select distinct(date) from pt group by sym\nselect sym, distinct_date from result where sym=`A21\n```\n\n| sym | distinct\\_date |\n| --- | ----------------------------------- |\n| A21 | \\[2012.01.15,2012.01.13,2012.01.11] |\n" }, "div": { "url": "https://docs.dolphindb.com/en/Functions/d/div.html", "signatures": [ { "full": "div(X, Y)", "name": "div", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [div](https://docs.dolphindb.com/en/Functions/d/div.html)\n\n\n\n#### Syntax\n\ndiv(X, Y)\n\nor\n\nX/Y\n\n#### Details\n\nReturn element-by-element division of *X* by *Y*.\n\nWhen *X* or *Y* is floating, it returns a floating value.\n\nWhen both *X* and *Y* are integers, `div` means integer division, which is the same as applying the [floor](https://docs.dolphindb.com/en/Functions/f/floor.html) function after division. For example, 5/2 is 2. If you want \"true\" division for integers, you can apply the operator [ratio(\\\\)](https://docs.dolphindb.com/en/Functions/r/ratio.html) instead. Integer division is often used together with the operator [mod](https://docs.dolphindb.com/en/Functions/m/mod.html) for grouping data. The results of `div` and `mod` should satisfy the relationship: `X=div(X,Y)*Y+mod(X,Y)`.\n\n#### Parameters\n\n**X** and **Y** can be a scalar/pair/vector/matrix. If *X* or *Y* is a pair/vector/matrix, the other is a scalar or a pair/vector/matrix of the same size.\n\n#### Examples\n\n```\n9/2:5;\n// output: 4 : 1\n\n11:25/3:4;\n// output: 3 : 6\n\nx=1 2 3;\nx/2;\n// output: [0,1,1]\n\n2/x;\n// output: [2,1,0]\n\ny=4 5 6;\nx/y;\n// output: [0,0,0]\ny/x;\n// output: [4,2,2]\n\nm1=1..6$2:3;\nm1;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nm1/2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0 | 1 | 2 |\n| 1 | 2 | 3 |\n\n```\nm2=6..1$2:3;\nm2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 6 | 4 | 2 |\n| 5 | 3 | 1 |\n\n```\nm1/m2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 0 | 0 | 2 |\n| 0 | 1 | 6 |\n\n```\n-7/5;\n// output: -2\n\n\nx=-1 2 6;\nx/-5;\n// output: [0,-1,-2]\n```\n" }, "dividedDifference": { "url": "https://docs.dolphindb.com/en/Functions/d/dividedDifference.html", "signatures": [ { "full": "dividedDifference(X, Y, resampleRule, [closed='left'], [origin='start_day'], [outputX=false])", "name": "dividedDifference", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" }, { "full": "resampleRule", "name": "resampleRule" }, { "full": "[closed='left']", "name": "closed", "optional": true, "default": "'left'" }, { "full": "[origin='start_day']", "name": "origin", "optional": true, "default": "'start_day'" }, { "full": "[outputX=false]", "name": "outputX", "optional": true, "default": "false" } ] } ], "markdown": "### [dividedDifference](https://docs.dolphindb.com/en/Functions/d/dividedDifference.html)\n\n\n\n#### Syntax\n\ndividedDifference(X, Y, resampleRule, \\[closed='left'], \\[origin='start\\_day'], \\[outputX=false])\n\n#### Details\n\nResample *X* based on the specified *resampleRule*, *closed* and *origin*. Perform divided difference interpolation on *Y* based on the resampled *X*.\n\nIf *outputX* is unspecified, return a vector of *Y* after the interpolation.\n\nIf *outputX*=true, return a tuple where the first element is the vector of resampled *X* and the second element is a vector of *Y* after the interpolation.\n\n#### Parameters\n\n**X** is a strictly increasing vector of temporal type.\n\n**Y** is a numeric vector of the same length as *X*.\n\n**resampleRule** is a string. See the parameter *rule* of function [resample](https://docs.dolphindb.com/en/Functions/r/resample.html) for the optional values.\n\n**closed** and **origin** are the same as the parameters *closed* and *origin* of function [resample](https://docs.dolphindb.com/en/Functions/r/resample.html).\n\n**outputX** is a Boolean value indicating whether to output the resampled *X*. The default value is false.\n\n#### Examples\n\n**Example 1**\n\n```\ndividedDifference([2016.02.14 00:00:00, 2016.02.15 00:00:00, 2016.02.16 00:00:00], [1.0, 2.0, 4.0], resampleRule=`60min);\n\n/* output\n[1,1.0217,1.0451,1.0703,1.0972,1.1259,1.1562,1.1884,1.2222,1.2578,\n1.2951,1.3342,1.375,1.4175,1.4618,1.5078,1.5556,1.605,1.6562,1.7092,\n1.7639,1.8203,1.8785,1.9384,2,2.0634,2.1285,2.1953,2.2639,2.3342,\n2.4062,2.48,2.5556,2.6328,2.7118,2.7925,2.875,2.9592,3.0451,3.1328,\n3.2222,3.3134,3.4062,3.5009,3.5972,3.6953,3.7951,3.8967,4]\n*/\n```\n\n**Example 2** Different values of *closed* affect the result.\n\n```\n// Data points fall exactly on 3-minute boundaries\nX = 2022.01.01T00:00:00 + [0, 3, 6, 9] * 60 // 00:00, 00:03, 00:06, 00:09\nY = [1.0, 3.0, 7.0, 13.0]\n\n// closed='left' (default): interval [t, t+3min), left-closed right-open\n// 00:03 belongs to [00:03, 00:06), the start of the second bucket\ndividedDifference(X, Y, `3min, closed=`left)\n\n// closed='right': interval (t, t+3min], left-open right-closed\n// 00:03 belongs to (00:00, 00:03], the end of the first bucket\n// Different bucket boundaries lead to different interpolation results\ndividedDifference(X, Y, `3min, closed=`right)\n```\n\n**Example 3** Different values of *origin* affect the result.\n\n```\n// Data starts at 00:00:30 and is not aligned to whole minutes\nX = 2022.01.01T00:00:30 + (0..4) * 60 // 00:00:30, 00:01:30, ..., 00:04:30\nY = [2.0, 4.0, 7.0, 11.0, 16.0]\n\n// origin='start_day' (default): align to 00:00:00 of the same day\n// Time buckets: [00:00:00, 00:01:00), [00:01:00, 00:02:00), ...\n// Resampled X: 00:00:00, 00:01:00, 00:02:00, 00:03:00, 00:04:00\ndividedDifference(X, Y, `1min, origin=`start_day, outputX=true)\n\n// origin='start': align to the first data point 00:00:30\n// Time buckets: [00:00:30, 00:01:30), [00:01:30, 00:02:30), ...\n// Resampled X: 00:00:30, 00:01:30, 00:02:30, 00:03:30, 00:04:30\ndividedDifference(X, Y, `1min, origin=`start, outputX=true)\n\n// origin=custom timestamp: align to 00:00:10\n// Time buckets: [00:00:10, 00:01:10), [00:01:10, 00:02:10), ...\n// Resampled X: 00:00:10, 00:01:10, 00:02:10, 00:03:10, 00:04:10\ndividedDifference(X, Y, `1min, origin=2022.01.01T00:00:10, outputX=true)\n```\n\n**Example 4** Different values of *outputX* affect the result.\n\n```\nX = [2016.02.14T00:00:00, 2016.02.15T00:00:00, 2016.02.16T00:00:00]\nY = [1.0, 2.0, 4.0]\n\n// outputX=false (default): return only the interpolated Y vector\ndividedDifference(X, Y, `60min)\n// Output: [1, 1.0217, ..., 4] (49 points)\n\n// outputX=true: return a tuple; [0] is the resampled X, [1] is the interpolated Y\nresult = dividedDifference(X, Y, `60min, outputX=true)\nresult[0] // Hourly timestamps, 49 in total\nresult[1] // Corresponding interpolated Y values, 49 in total\n```\n" }, "dot": { "url": "https://docs.dolphindb.com/en/Functions/d/dot.html", "signatures": [ { "full": "dot(X, Y)", "name": "dot", "parameters": [ { "full": "X", "name": "X" }, { "full": "Y", "name": "Y" } ] } ], "markdown": "### [dot](https://docs.dolphindb.com/en/Functions/d/dot.html)\n\n\n\n#### Syntax\n\ndot(X, Y)\n\nor\n\nX\\*\\*Y\n\n#### Details\n\nReturn the matrix multiplication of *X* and *Y*. If *X* and *Y* are vectors of the same length, return their inner product.\n\nDifference from Python’s `numpy.dot`: `numpy.dot` uses different multiplication rules for 1-D, 2-D, and N-D arrays and supports the *out* argument. DolphinDB’s `dot` supports scalars, vectors, and matrices. Two vectors return an inner product, matrix-vector multiplication automatically adjusts the vector dimension, and `X**Y` can be used as a matrix multiplication operator.\n\n#### Parameters\n\n**X** / **Y** can be a scalar/vector/matrix. If both of *X* and *Y* are vectors, they must have the same length. If one of *X* and *Y* is a matrix, the other is a vector/matrix and their dimensions must satisfy the rules of matrix multiplication.\n\n#### Returns\n\nReturns a scalar/vector/matrix.\n\n#### Examples\n\n```\nx=1..6$2:3;\ny=1 2 3;\nx dot y;\n```\n\n| #0 |\n| -- |\n| 22 |\n| 28 |\n\n```\nx=1..6$2:3;\ny=6..1$3:2;\nx**y;\n```\n\n| #0 | #1 |\n| -- | -- |\n| 41 | 14 |\n| 56 | 20 |\n\n```\ny**x;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 12 | 30 | 48 |\n| 9 | 23 | 37 |\n| 6 | 16 | 26 |\n\n```\na=1 2 3;\nshape a;\n// output: 3:1\n\nx**a;\n```\n\n| #0 |\n| -- |\n| 22 |\n| 28 |\n\n```\nb=1 2;\nshape b;\n// output: 2:1\n\nb**x; // for a matrix multiplication between a matrix and a vector, the system may rotate the dimension of the vector for the multiplication to go through.\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 5 | 11 | 17 |\n\n```\nx=1 2 3;\ny=4 5 6;\nx ** y;\n// output: 32 // inner product of two vectors. Equivalent to 1*4 + 2*5 + 3*6\n\nx ** 2;\n// output: [2,4,6]\n\nx=1..6$2:3\nx ** 2;\nError: Use * rather than ** for scalar and matrix multiplication.\n```\n" }, "double": { "url": "https://docs.dolphindb.com/en/Functions/d/double.html", "signatures": [ { "full": "double(X)", "name": "double", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [double](https://docs.dolphindb.com/en/Functions/d/double.html)\n\n\n\n#### Syntax\n\ndouble(X)\n\n#### Details\n\nConvert the input to the data type of DOUBLE.\n\n#### Parameters\n\n**X** can be of any data type.\n\n#### Returns\n\nDOUBLE type with the same data form as *X*.\n\n#### Examples\n\n```\n// create a DOUBLE variable with default value 0\nx=double();\nx;\n// output: 00F\ntypestr x;\n// output: DOUBLE\n\ntypestr double(`10);\n// output: DOUBLE\n\ndouble(`10.9);\n// output: 10.9\n\ndouble(now());\n// output: 5.297834e+011\n```\n" }, "drop": { "url": "https://docs.dolphindb.com/en/Functions/d/drop.html", "signatures": [ { "full": "drop(obj, count)", "name": "drop", "parameters": [ { "full": "obj", "name": "obj" }, { "full": "count", "name": "count" } ] } ], "markdown": "### [drop](https://docs.dolphindb.com/en/Functions/d/drop.html)\n\n\n\n#### Syntax\n\ndrop(obj, count)\n\n#### Details\n\nDrops a specified number of elements, columns or rows from the front or end of a vector, matrix or table.\n\n#### Parameters\n\n**obj** is a vector/matrix/table.\n\n**count** is an integer specifying the number of elements/columns/rows to drop. If negative, drop from the end of *obj*.\n\n#### Returns\n\nAn object with the same data type and form as *obj*.\n\n#### Examples\n\n```\nx=1..10;\nx.drop(2);\n// output: [3,4,5,6,7,8,9,10]\nx.drop(-2);\n// output: [1,2,3,4,5,6,7,8]\n\nx=1..10$2:5;\nx;\n```\n\n| #0 | #1 | #2 | #3 | #4 |\n| -- | -- | -- | -- | -- |\n| 1 | 3 | 5 | 7 | 9 |\n| 2 | 4 | 6 | 8 | 10 |\n\n```\ndrop(x,2);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 5 | 7 | 9 |\n| 6 | 8 | 10 |\n\n```\nx drop -2;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 3 | 5 |\n| 2 | 4 | 6 |\n\n```\nt=table(1 2 3 4 as x, 11..14 as y);\nt;\n```\n\n| x | y |\n| - | -- |\n| 1 | 11 |\n| 2 | 12 |\n| 3 | 13 |\n| 4 | 14 |\n\n```\nt.drop(2);\n```\n\n| x | y |\n| - | -- |\n| 3 | 13 |\n| 4 | 14 |\n\n**Related functions:** [pop!](https://docs.dolphindb.com/en/Functions/p/pop!.html), [removeHead!](https://docs.dolphindb.com/en/Functions/r/removeHead!.html), [removeTail!](https://docs.dolphindb.com/en/Functions/r/removeTail!.html), [remove!](https://docs.dolphindb.com/en/Functions/r/remove.html)\n" }, "dropAggregator": { "url": "https://docs.dolphindb.com/en/Functions/d/dropAggregator.html", "signatures": [ { "full": "dropStreamEngine(name)", "name": "dropStreamEngine", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropAggregator](https://docs.dolphindb.com/en/Functions/d/dropAggregator.html)\n\nAlias for [dropStreamEngine](https://docs.dolphindb.com/en/Functions/d/dropStreamEngine.html)\n\n\nDocumentation for the `dropStreamEngine` function:\n### [dropStreamEngine](https://docs.dolphindb.com/en/Functions/d/dropStreamEngine.html)\n\n\n\n#### Syntax\n\ndropStreamEngine(name)\n\nAlias: dropAggregator\n\n#### Details\n\nReleases the definition of a streaming engine from the memory.\n\n**Note:**\n\nThis function cannot be used to delete streaming engines created by Orca. To delete an Orca streaming engine, use [dropStreamGraph](https://docs.dolphindb.com/en/Functions/d/dropStreamGraph.html) to delete the stream graph to which the engine belongs.\n\n#### Parameters\n\n**name** is a string indicating the name of a created streaming engine. You can obtain all created engines with function [getStreamEngineStat](https://docs.dolphindb.com/en/Functions/g/getStreamEngineStat.html).\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesEngine = createTimeSeriesEngine(name=\"StreamEngineDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesEngine\", offset=0, handler=append!{tradesEngine}, msgAsTable=true)\n```\n\n```\ndef writeData(n){\n timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n symv =take(`A`B, n)\n qtyv = take(1, n)\n insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\n```\n\n```\n// output: select * from outputTable;\n```\n\n| time | sym | sumQty |\n| ----------------------- | --- | ------ |\n| 2018.10.08T01:01:01.003 | A | 1 |\n| 2018.10.08T01:01:01.006 | A | 1 |\n| 2018.10.08T01:01:01.006 | B | 2 |\n\n```\ndropStreamEngine(\"StreamEngineDemo\");\n```\n" }, "dropCatalog": { "url": "https://docs.dolphindb.com/en/Functions/d/dropCatalog.html", "signatures": [ { "full": "dropCatalog(catalog)", "name": "dropCatalog", "parameters": [ { "full": "catalog", "name": "catalog" } ] } ], "markdown": "### [dropCatalog](https://docs.dolphindb.com/en/Functions/d/dropCatalog.html)\n\n#### Syntax\n\ndropCatalog(catalog)\n\n#### Details\n\nDrop a catalog.\n\n#### Parameters\n\n**catalog**is a string specifying the catalog name.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndropCatalog(\"cat1\")\n```\n\n" }, "dropColumns!": { "url": "https://docs.dolphindb.com/en/Functions/d/dropColumns!.html", "signatures": [ { "full": "dropColumns!(table, colNames)", "name": "dropColumns!", "parameters": [ { "full": "table", "name": "table" }, { "full": "colNames", "name": "colNames" } ] } ], "markdown": "### [dropColumns!](https://docs.dolphindb.com/en/Functions/d/dropColumns!.html)\n\n\n\n#### Syntax\n\ndropColumns!(table, colNames)\n\nAlias: drop!\n\n#### Details\n\nDelete one or multiple columns from a table. Note that deleting a partitioning column from a DFS table is not supported.\n\n#### Parameters\n\n**table** is a table object. It is an in-memory table or a DFS table (for OLAP engine only).\n\n**colNames** is a STRING scalar/vector indicating a column name. If *table* is a DFS table, it must be a scalar.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nt=table(1 2 3 as x, 4 5 6 as y, 7..9 as z, 10..12 as a, 13..15 as b, 16..18 as c);\nt;\n```\n\n| x | y | z | a | b | c |\n| - | - | - | -- | -- | -- |\n| 1 | 4 | 7 | 10 | 13 | 16 |\n| 2 | 5 | 8 | 11 | 14 | 17 |\n| 3 | 6 | 9 | 12 | 15 | 18 |\n\n```\nt.dropColumns!(`x);\n```\n\n| y | z | a | b | c |\n| - | - | -- | -- | -- |\n| 4 | 7 | 10 | 13 | 16 |\n| 5 | 8 | 11 | 14 | 17 |\n| 6 | 9 | 12 | 15 | 18 |\n\n```\ndropColumns!(t, `a`b);\n```\n\n| y | z | c |\n| - | - | -- |\n| 4 | 7 | 16 |\n| 5 | 8 | 17 |\n| 6 | 9 | 18 |\n" }, "dropDatabase": { "url": "https://docs.dolphindb.com/en/Functions/d/dropDatabase.html", "signatures": [ { "full": "dropDatabase(dbDir)", "name": "dropDatabase", "parameters": [ { "full": "dbDir", "name": "dbDir" } ] } ], "markdown": "### [dropDatabase](https://docs.dolphindb.com/en/Functions/d/dropDatabase.html)\n\n\n\n#### Syntax\n\ndropDatabase(dbDir)\n\n#### Details\n\nDelete all physical files from the specified database.\n\n#### Parameters\n\n**dbDir** specifies the directory where the database is located. For a database in the distributed file system, the directory should start with \"dfs\\://\".\n\n#### Returns\n\nNone.\n\n#### Examples\n\nDrop a DFS database:\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x);\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb = database(\"dfs://valueDB\", VALUE, 2017.08.07..2017.08.11)\npt = loadTextEx(db, `pt1, `date, \"C:/DolphinDB/Data/t.txt\");\n\ndropDatabase(\"dfs://valueDB\")\n```\n\nDrop a database on disk:\n\n```\nn=1000000\nID=rand(10, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\nsaveText(t, \"C:/DolphinDB/Data/t.txt\");\n\ndb = database(\"C:/DolphinDB/Data/rangedb\", RANGE, 0 5 10)\npt = loadTextEx(db, `pt, `ID, \"C:/DolphinDB/Data/t.txt\");\n\ndropDatabase(\"C:/DolphinDB/Data/rangedb\");\n```\n" }, "dropDistributedInMemoryTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropDistributedInMemoryTable.html", "signatures": [ { "full": "dropDistributedInMemoryTable(tableName)", "name": "dropDistributedInMemoryTable", "parameters": [ { "full": "tableName", "name": "tableName" } ] } ], "markdown": "### [dropDistributedInMemoryTable](https://docs.dolphindb.com/en/Functions/d/dropDistributedInMemoryTable.html)\n\n\n\n#### Syntax\n\ndropDistributedInMemoryTable(tableName)\n\n#### Details\n\nDelete the specified distributed in-memory table. This function can only be executed on a data node or compute node.\n\n#### Parameters\n\n**tableName** is a STRING scalar indicating column names of a distributed in-memory table.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\npt = createDistributedInMemoryTable(`dt, `time`id`value, `DATETIME`INT`LONG, HASH, [INT, 2],`id)\ntime = take(2021.08.20 00:00:00..2021.08.30 00:00:00, 40);\nid = 0..39;\nvalue = rand(100, 40);\ntmp = table(time, id, value);\n\npt = loadDistributedInMemoryTable(`dt)\npt.append!(tmp);\ndropDistributedInMemoryTable(`dt)\n```\n\nRelated functions: [loadDistributedInMemoryTable](https://docs.dolphindb.com/en/Functions/l/loadDistributedInMemoryTable.html), [createDistributedInMemoryTable](https://docs.dolphindb.com/en/Functions/c/createDistributedInMemoryTable.html)\n" }, "dropFunctionView": { "url": "https://docs.dolphindb.com/en/Functions/d/dropFunctionView.html", "signatures": [ { "full": "dropFunctionView(name, [isNamespace=false])", "name": "dropFunctionView", "parameters": [ { "full": "name", "name": "name" }, { "full": "[isNamespace=false]", "name": "isNamespace", "optional": true, "default": "false" } ] } ], "markdown": "### [dropFunctionView](https://docs.dolphindb.com/en/Functions/d/dropFunctionView.html)\n\n\n\n#### Syntax\n\ndropFunctionView(name, \\[isNamespace=false])\n\n#### Details\n\nDelete a function view or all function views under a namespace.\n\nIt can only be executed by administrators or users with VIEW\\_OWNER permission.\n\n#### Parameters\n\n**name** is a STRING scalar indicating a user-defined function or a namespace.\n\n**isNamespace** is a Boolean value specifying whether *name* is a namespace.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ngetFunctionViews()\nname body \n--------- ------------------\nf1 def f1(){return 1}\ntest::f1 def f1(){return 2}\ntest::f2 def f2(){return 3}\n\n// Drop f1\ndropFunctionView(`f1)\n// Drop test::f1\ndropFunctionView(\"test::f1\")\n// Drop all function views under test\ndropFunctionView(\"test\",true)\n```\n" }, "dropHaMvccTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropHaMvccTable.html", "signatures": [ { "full": "dropHaMvccTable(tableName)", "name": "dropHaMvccTable", "parameters": [ { "full": "tableName", "name": "tableName" } ] } ], "markdown": "### [dropHaMvccTable](https://docs.dolphindb.com/en/Functions/d/dropHaMvccTable.html)\n\nFirst introduced in version: 2.00.183.00.5\n\n\n\n#### Syntax\n\ndropHaMvccTable(tableName)\n\n#### Details\n\nDrops the HA MVCC table with the specified name.\n\n**Notes:** This function must be executed on the Leader node of the Raft group that the table belongs to.\n\n#### Parameters\n\n**tableName** is a STRING scalar indicating the name of the HA MVCC table to drop.\n\n#### Examples\n\n```\ndropHaMvccTable(\"demoHaMvcc\")\n```\n\n**Related function**: [haMvccTable](https://docs.dolphindb.com/en/Functions/h/haMvccTable.html)\n" }, "dropIPCInMemoryTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropIPCInMemoryTable.html", "signatures": [ { "full": "dropIPCInMemoryTable(tableName)", "name": "dropIPCInMemoryTable", "parameters": [ { "full": "tableName", "name": "tableName" } ] } ], "markdown": "### [dropIPCInMemoryTable](https://docs.dolphindb.com/en/Functions/d/dropIPCInMemoryTable.html)\n\n\n\n#### Syntax\n\ndropIPCInMemoryTable(tableName)\n\n#### Details\n\nDrop an IPC in-memory table.\n\n**Note:**\n\n* This function can only be executed on Linux.\n* An IPC in-memory table cannot be deleted if a server is shut down. It still needs to be deleted through function `dropIPCInMemoryTable`.\n\n#### Parameters\n\n**tableName** is a string indicating the name of IPC in-memory table to be dropped.\n\n#### Returns\n\nA string specifying the name of the deleted IPC in-memory table.\n\n#### Examples\n\nDrop the table ipc\\_table created by function [createIPCInMemoryTable](https://docs.dolphindb.com/en/Functions/c/createIPCInMemoryTable.html).\n\n```\ndropIPCInMemoryTable(`ipc_table)\n// output: ipc_table\n```\n" }, "dropMCPPrompt": { "url": "https://docs.dolphindb.com/en/Functions/d/dropMCPPrompt.html", "signatures": [ { "full": "dropMCPPrompt(name)", "name": "dropMCPPrompt", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropMCPPrompt](https://docs.dolphindb.com/en/Functions/d/dropMCPPrompt.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\ndropMCPPrompt(name)\n\n#### Details\n\nDeletes an MCP prompt template. If the template has been published, call `withdrawMCPPrompts` to withdraw it before deleting it.\n\n#### Parameters\n\n**name** is a STRING scalar indicating the name of the prompt template.\n\n#### Returns\n\nA string indicating the name of the deleted MCP prompt template.\n\n#### Examples\n\n```\ndropMCPPrompt(\"stock_summary\")\n// output:'stock_summary'\n```\n" }, "dropMCPTool": { "url": "https://docs.dolphindb.com/en/Functions/d/dropMCPTool.html", "signatures": [ { "full": "dropMCPTool(name)", "name": "dropMCPTool", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropMCPTool](https://docs.dolphindb.com/en/Functions/d/dropMCPTool.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\ndropMCPTool(name)\n\n#### Details\n\nDeletes an MCP tool. If the tool has been published, it should be withdrawn using `withdrawMCPTools` before deletion.\n\n#### Parameters\n\n**name** is a STRING scalar indicating the tool name.\n\n#### Returns\n\nA string representing the name of the deleted tool.\n\n#### Examples\n\n```\ndropMCPTool(\"myTool\")\n```\n" }, "dropna": { "url": "https://docs.dolphindb.com/en/Functions/d/dropna.html", "signatures": [ { "full": "dropna(X, [byRow=true], [thresh])", "name": "dropna", "parameters": [ { "full": "X", "name": "X" }, { "full": "[byRow=true]", "name": "byRow", "optional": true, "default": "true" }, { "full": "[thresh]", "name": "thresh", "optional": true } ] } ], "markdown": "### [dropna](https://docs.dolphindb.com/en/Functions/d/dropna.html)\n\n\n\n#### Syntax\n\ndropna(X, \\[byRow=true], \\[thresh])\n\n#### Details\n\nIf *X* is a vector, delete all null values from *X*.\n\nIf *X* is a matrix and *byRow*=true, delete all rows with null values.\n\nIf *X* is a matrix and *byRow*=false, delete all columns with null values.\n\nIf *thresh* is specified, each row or column (as specified by *byRow*) in the result must have at least *thresh* non-null values.\n\n#### Parameters\n\n**X** is a vector or matrix.\n\n**byRow** (optional) is a Boolean value. The default value is true.\n\n**thresh** (optional) is a positive integer.\n\n#### Returns\n\nA vector or matrix with the same data type as *X*.\n\n#### Examples\n\n```\nx=1 NULL 2 3 NULL NULL 4;\nx.dropna();\n// output: [1,2,3,4]\n\nm=matrix(1 1 1 1, 1 1 1 NULL, 1 NULL 1 NULL);\nm;\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 1 | 1 |\n| 1 | 1 | |\n| 1 | 1 | 1 |\n| 1 | | |\n\n```\ndropna(m);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 1 | 1 |\n| 1 | 1 | 1 |\n\n```\ndropna(m,,2);\n```\n\n| #0 | #1 | #2 |\n| -- | -- | -- |\n| 1 | 1 | 1 |\n| 1 | 1 | |\n| 1 | 1 | 1 |\n\n```\ndropna(m,false);\n```\n\n| #0 |\n| -- |\n| 1 |\n| 1 |\n| 1 |\n| 1 |\n\n```\ndropna(m,false,3);\n```\n\n| #0 | #1 |\n| -- | -- |\n| 1 | 1 |\n| 1 | 1 |\n| 1 | 1 |\n| 1 | |\n" }, "dropOrcaStreamTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropOrcaStreamTable.html", "signatures": [ { "full": "dropOrcaStreamTable(name)", "name": "dropOrcaStreamTable", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropOrcaStreamTable](https://docs.dolphindb.com/en/Functions/d/dropOrcaStreamTable.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\ndropOrcaStreamTable(name)\n\n#### Details\n\nDeletes an Orca stream table.\n\nThe table can only be deleted if it is no longer referenced by any stream graph. You can use `getOrcaStreamTableMeta` to check its references.\n\n**Note:** Before calling this function, you must first enable the Orca feature by setting `enableORCA=true` in the configuration file `cluster.cfg` or `controller.cfg`.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\n// Create an Orca stream table\nif(!existsCatalog(\"demo\")){\n createCatalog(\"demo\")\n}\ngo\nuse catalog demo\n\ncreateOrcaStreamTable(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n\n// Delete the Orca stream table\ndropOrcaStreamTable(\"demo.orca_table.trade\")\n// or dropOrcaStreamTable(\"trade\")\n```\n" }, "dropPartition": { "url": "https://docs.dolphindb.com/en/Functions/d/dropPartition.html", "signatures": [ { "full": "dropPartition(dbHandle, partitionPaths, tableName, [forceDelete=false], [deleteSchema=false])", "name": "dropPartition", "parameters": [ { "full": "dbHandle", "name": "dbHandle" }, { "full": "partitionPaths", "name": "partitionPaths" }, { "full": "tableName", "name": "tableName" }, { "full": "[forceDelete=false]", "name": "forceDelete", "optional": true, "default": "false" }, { "full": "[deleteSchema=false]", "name": "deleteSchema", "optional": true, "default": "false" } ] } ], "markdown": "### [dropPartition](https://docs.dolphindb.com/en/Functions/d/dropPartition.html)\n\n\n\n#### Syntax\n\ndropPartition(dbHandle, partitionPaths, tableName, \\[forceDelete=false], \\[deleteSchema=false])\n\n#### Details\n\nDelete data from one or multiple partitions from a DFS database.\n\nPlease note that *dropPartition* only deletes data from selected partitions. It does not change the partitioning scheme. We do not need to reestablish these partitions if we need to append new data to them.\n\nIf *tableName* is specified: delete one or multiple partitions of the given table.\n\nIf *tableName* is not specified: delete one or multiple partitions of all tables with this partition.\n\n#### Parameters\n\n**dbHandle** is a DolphinDB database handle.\n\n**partitionPaths** can be specified in two ways:\n\n* By path: *partitionPaths* is a STRING scalar/vector indicating the path of one or multiple partitions. Each string must start with \"/\". For composite partitions, the path must include all partition levels.\n\n The partition path can be obtained from the `dfsPath` field in the return value of function [getChunksMeta](https://docs.dolphindb.com/en/Functions/g/getChunksMeta.html). This field is structured as:`///`.\n\n* By condition: *partitionPaths* is a scalar or vector indicating the value(s) in the partitioning column. The system will drop all partitions containing these values. For composite partitions, *partitionPaths* is a tuple where each element is a filtering condition for each partition level (starting from the first level). If you do not want to apply filtering at a certain partition level, leave the corresponding element empty.\n\n**tableName** is a string indicating a table name. It can be left empty if the database chunk granularity is at DATABASE level (i.e., [database](https://docs.dolphindb.com/en/Functions/d/database.html): *chunkGranularity* = 'DATABASE'). Otherwise, it is a required parameter.\n\n**forceDelete** (optional) is a Boolean value. If set to true, the specified partition(s) will be deleted even if the partition(s) is recovering. The default value is false.\n\n**Note:** When using the `dropPartition` function with *forceDelete*=false, the number of available replicas for the chunks involved in the transaction must be greater than or equal to the configured *dfsReplicationFactor*.\n\n**deleteSchema** (optional) is a Boolean value. The default value is false, indicating that only the data in the selected partitions will be deleted, but the partition schema (which you can check with `schema().partitionSchema`) is kept. When the following conditions are satisfied, you can delete the schema of the selected partitions along with the partition data by setting *deleteSchema* to true:\n\n* There's only one table in the database.\n* The partitioning type of the database is VALUE.\n* For composite partitions, the first level of partitioning type must be VALUE, and only the first level of partitions are selected for deletion.\n\n#### Returns\n\nNone.\n\n#### Examples\n\nThe script should be executed on a data node or compute node of a cluster.\n\n```\nn=1000000\nID=rand(150, n)\ndates=2017.08.07..2017.08.11\ndate=rand(dates, n)\nx=rand(10.0, n)\nt=table(ID, date, x)\ndbDate = database(, VALUE, 2017.08.07..2017.08.11)\ndbID = database(, RANGE, 0 50 100 150)\ndb = database(\"dfs://compoDB\", COMPO, [dbDate, dbID])\npt = db.createPartitionedTable(t, `pt, `date`ID)\npt.append!(t);\n```\n\nThe script above created a database with composite partition. The first level is a value partition with partitioning column of date, and the second level is a range partition with partitioning column of ID.\n\nExample 1. Delete one partition\n\nUse either of the following ways to delete the partition \"/20170807/0\\_50\".\n\n(1) Specify the partition path.\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=\"/20170807/0_50\");\n```\n\n**Note:** The *dbHandle* of `dropPartition` can also be specified as `db`, the variable used during database creation.\n\n(2) Specify the filtering condition.\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[2017.08.07, 0]);\n```\n\nHere 0 means the partition of \\[0, 50). We can choose any number from 0 to 49 to represent this partition.\n\nExample 2. Delete a first level partition\n\nUse either of the following ways to delete the first level partition of 2017.08.08.\n\n(1) Specify the path of all partitions under 2017.08.08.\n\n```\npartitions=[\"/20170808/0_50\",\"/20170808/50_100\",\"/20170808/100_150\"]\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=partitions);\n```\n\n(2) Specify the filtering condition.\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=2017.08.08, tableName=`pt);\n```\n\nAfter the deletion, check the table partitioning scheme with [schema](https://docs.dolphindb.com/en/Functions/s/schema.html)\n\n```\nschema(db);\n/*output\npartitionSchema->([2017.08.11,2017.08.10,2017.08.09,2017.08.08,2017.08.07],[0,50,100,150])\npartitionSites->\npartitionTypeName->[VALUE,RANGE]\natomic->TRANS\ndatabaseDir->dfs://compoDB\nchunkGranularity->TABLE\nengineType->OLAP\npartitionType->[1,2]\n*/\n```\n\nWe can see that \"2017.08.08\" is still in *partitionSchema* as `dropPartition` only deleted the data from this partition but kept its schema. Since \"2017.08.08\" is a first level VALUE partition, we can also delete its schema from the table partitioning scheme along with its data by specifying *deleteSchema* = true:\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=2017.08.08, tableName=`pt, deleteSchema = true);\n```\n\nCheck the table partitioning scheme with [schema](https://docs.dolphindb.com/en/Functions/s/schema.html) - \"2017.08.08\" is no longer in *partitionSchema*:\n\n```\nschema(db);\n/* output\npartitionSchema->([2017.08.11,2017.08.10,2017.08.09,2017.08.07],[0,50,100,150])\n...\n*/\n```\n\nExample 3. Delete a second level partition\n\nUse either of the following ways to delete the second level partition of \\[0,50).\n\n(1) Specify the path of all partitions of \\[0,50).\n\n```\npartitions=[\"/20170807/0_50\",\"/20170808/0_50\",\"/20170809/0_50\",\"/20170810/0_50\",\"/20170811/0_50\"]\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=partitions);\n```\n\n(2) Specify the filtering condition.\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[,[0]]);\n```\n\nExample 4. Delete multiple same level partitions\n\nTo delete the second level partitions of \\[0,50) and \\[100,150):\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=[,[0,100]]);\n```\n\nExample 5: Modify data in a distributed table on disk\n\nTo revise data in a distributed table, we need to update the entire partitions that the rows to be updated belong to. The following example adds 10 to column x of the rows with date=2017.08.10 and ID=88 in the distributed table pt.\n\n(1) First load the data of the partition with date=2017.08.10 and ID=88 into memory.\n\n```\ntmp=select * from loadTable(\"dfs://compoDB\",\"pt\") where date=2017.08.10 and 50<=ID<100 ;\n```\n\n(2) Then add 10 to column x of table tmp:\n\n```\nupdate tmp set x=x+10 where date=2017.08.10 and ID=88;\n```\n\n(3) Delete data in the relevant partition:\n\n```\ndropPartition(dbHandle=database(\"dfs://compoDB\"), partitionPaths=\"/20170810/50_100\", tableName=`pt);\n```\n\n(4) Append table tmp to table pt:\n\n```\npt.append!(tmp);\n```\n" }, "dropSchema": { "url": "https://docs.dolphindb.com/en/Functions/d/dropSchema.html", "signatures": [ { "full": "dropSchema(catalog, schema)", "name": "dropSchema", "parameters": [ { "full": "catalog", "name": "catalog" }, { "full": "schema", "name": "schema" } ] } ], "markdown": "### [dropSchema](https://docs.dolphindb.com/en/Functions/d/dropSchema.html)\n\n#### Syntax\n\ndropSchema(catalog, schema)\n\n#### Details\n\nDrop a schema from a catalog.\n\n#### Parameters\n\n**catalog**is a string specifying the catalog name.\n\n**schema**is a string indicating the schema to be deleted.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\ndropSchema(\"catalog1\", \"schema\")\n```\n\n" }, "dropStreamEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/dropStreamEngine.html", "signatures": [ { "full": "dropStreamEngine(name)", "name": "dropStreamEngine", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropStreamEngine](https://docs.dolphindb.com/en/Functions/d/dropStreamEngine.html)\n\n\n\n#### Syntax\n\ndropStreamEngine(name)\n\nAlias: dropAggregator\n\n#### Details\n\nReleases the definition of a streaming engine from the memory.\n\n**Note:**\n\nThis function cannot be used to delete streaming engines created by Orca. To delete an Orca streaming engine, use [dropStreamGraph](https://docs.dolphindb.com/en/Functions/d/dropStreamGraph.html) to delete the stream graph to which the engine belongs.\n\n#### Parameters\n\n**name** is a string indicating the name of a created streaming engine. You can obtain all created engines with function [getStreamEngineStat](https://docs.dolphindb.com/en/Functions/g/getStreamEngineStat.html).\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nshare streamTable(1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT]) as trades\noutputTable = table(10000:0, `time`sym`sumQty, [TIMESTAMP, SYMBOL, INT])\ntradesEngine = createTimeSeriesEngine(name=\"StreamEngineDemo\", windowSize=3, step=3, metrics=<[sum(qty)]>, dummyTable=trades, outputTable=outputTable, timeColumn=`time, useSystemTime=false, keyColumn=`sym, garbageSize=50)\nsubscribeTable(tableName=\"trades\", actionName=\"tradesEngine\", offset=0, handler=append!{tradesEngine}, msgAsTable=true)\n```\n\n```\ndef writeData(n){\n timev = 2018.10.08T01:01:01.001 + timestamp(1..n)\n symv =take(`A`B, n)\n qtyv = take(1, n)\n insert into trades values(timev, symv, qtyv)\n}\n\nwriteData(6);\n```\n\n```\n// output: select * from outputTable;\n```\n\n| time | sym | sumQty |\n| ----------------------- | --- | ------ |\n| 2018.10.08T01:01:01.003 | A | 1 |\n| 2018.10.08T01:01:01.006 | A | 1 |\n| 2018.10.08T01:01:01.006 | B | 2 |\n\n```\ndropStreamEngine(\"StreamEngineDemo\");\n```\n" }, "dropStreamGraph": { "url": "https://docs.dolphindb.com/en/Functions/d/dropStreamGraph.html", "signatures": [ { "full": "dropStreamGraph(name, [includeTables])", "name": "dropStreamGraph", "parameters": [ { "full": "name", "name": "name" }, { "full": "[includeTables]", "name": "includeTables", "optional": true } ] } ], "markdown": "### [dropStreamGraph](https://docs.dolphindb.com/en/Functions/d/dropStreamGraph.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\ndropStreamGraph(name, \\[includeTables])\n\n#### Details\n\nDestroys the specified stream graph. After successful execution, the stream graph’s status is set to \"destroyed\", but the metadata record is not deleted.\n\n* If *includesTables*=true, the specified stream graph and its user-created stream tables will be deleted. Ensure that these stream tables are not referenced by other stream graphs; use `getStreamTableMeta` to check table references.\n* If false, only the stream graph itself will be deleted, leaving the associated stream tables intact.\n\nIn a cluster deployment, this function can only be executed by an administrator or a user who has the COMPUTE\\_GROUP\\_EXEC permission for the compute group that was used to create the stream graph. In a single-node deployment, permission checks are not required.\n\n#### Parameters\n\n**name** is a string representing the name of the stream graph. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_graph.factors\", or just the graph name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**includesTables** (optional) is a Boolean value, indicating whether to delete user-created stream tables (e.g., source, sink) associated with the stream graph when deleting the graph. The default value is false.\n\n#### Returns\n\nNone.\n\n#### Examples\n\nCreate a stream graph named “indicators”.\n\n```\ndropStreamGraph(\"demo.orca_graph.indicators\")\n\ngetStreamGraphMeta(\"demo.orca_graph.indicators\")[\"status\"]\n// Output: [\"destroyed\"]\n```\n\n**Related functions:** [createStreamGraph](https://docs.dolphindb.com/en/Functions/c/createStreamGraph.html), [StreamGraph::dropGraph](https://docs.dolphindb.com/en/Functions/s/StreamGraph_dropGraph.html)\n" }, "dropStreamTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropStreamTable.html", "signatures": [ { "full": "dropStreamTable(tableName, [force=false])", "name": "dropStreamTable", "parameters": [ { "full": "tableName", "name": "tableName" }, { "full": "[force=false]", "name": "force", "optional": true, "default": "false" } ] } ], "markdown": "### [dropStreamTable](https://docs.dolphindb.com/en/Functions/d/dropStreamTable.html)\n\n\n\n#### Syntax\n\ndropStreamTable(tableName, \\[force=false])\n\n#### Details\n\nDelete a stream table. If the table has been persisted to disk, the persisted data on disk will be deleted as well.\n\nTo delete a high-availability stream table, we can execute the command on any data/compute node in the Raft group. The high-availability stream table with the same name on other data nodes will be deleted as well.\n\nIf the table has been persisted to disk but not yet loaded into memory, setting the parameter *force* to true can delete the table directly from disk. Note that it can only be executed by an administrator.\n\n**Note:**\n\nThis function cannot be used to delete stream tables created by Orca. To delete an Orca stream table, use [dropOrcaStreamTable](https://docs.dolphindb.com/en/Functions/d/dropOrcaStreamTable.html).\n\n#### Parameters\n\n**tableName** is a string indicating a stream table name.\n\n**force** (optional) is a Boolean scalar indicating whether to force the deletion of the stream table named *tableName* from the disk if it is not available in memory. The default value is false.\n\n#### Returns\n\nNone.\n\n#### Examples\n\nDelete stream table:\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=streamTable(1:0,colNames,colTypes)\nenableTableShareAndPersistence(t,`trades);\n\ndropStreamTable(`trades);\n```\n\nDelete a stream table that has been persisted to disk but not yet loaded into memory.\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=streamTable(1:0,colNames,colTypes)\nenableTableShareAndPersistence(t,`trades);\n\n//delete an in-memory stream table\nundef(`trades,SHARED)\n\n//failed to delete a persisted stream table\ndropStreamTable(`trades)\n//dropStreamTable(\"trades\") => Can't find stream table trades\n\n//set force to true\ndropStreamTable(tableName=`trades,force=true)\n```\n\nDelete high-availability stream table:\n\n```\ncolNames = `timestamp`sym`qty`price\ncolTypes = [TIMESTAMP,SYMBOL,INT,DOUBLE]\nt=table(1:0,colNames,colTypes)\nhaStreamTable(11,t,`trades,100000);\n\ndropStreamTable(`trades);\n```\n" }, "dropTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dropTable.html", "signatures": [ { "full": "dropTable(dbHandle, tableName)", "name": "dropTable", "parameters": [ { "full": "dbHandle", "name": "dbHandle" }, { "full": "tableName", "name": "tableName" } ] } ], "markdown": "### [dropTable](https://docs.dolphindb.com/en/Functions/d/dropTable.html)\n\n\n\n#### Syntax\n\ndropTable(dbHandle, tableName)\n\n#### Details\n\nDelete the specified table on disk. It can only be executed on a data node or compute node.\n\n#### Parameters\n\n**dnHandle** is a DolphinDB database handle.\n\n**tableName** is a string indicating a table name.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nn=1000000\nID=rand(10, n)\nx=rand(1.0, n)\nt=table(ID, x)\ndb=database(\"dfs://rangedb\", RANGE, 0 5 10)\npt = db.createPartitionedTable(t, `pt, `ID)\npt.append!(t)\n\ndropTable(db,`pt);\n```\n" }, "dropDataViewEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/drop_data_view_engine.html", "signatures": [ { "full": "dropDataViewEngine(name)", "name": "dropDataViewEngine", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [dropDataViewEngine](https://docs.dolphindb.com/en/Functions/d/drop_data_view_engine.html)\n\n\n\n#### Syntax\n\ndropDataViewEngine(name)\n\n#### Details\n\nDeletes the specified data view engine in the current CEP engine.\n\n#### Parameters\n\n**name** is a string indicating the name of the data view engine.\n\n#### Returns\n\nNone.\n\n#### Examples\n\n```\nclass MainMonitor: CEPMonitor {\n def MainMonitor(){\n }\n // Automatically called when the engine is deleted; remove the shared stream table\n def onunload(){ \n undef('orderDV', SHARED)\n dropDataViewEngine('orderDV')\n }\n\tdef checkOrders(newOrder)\n // Create a DataViewEngine, specifying the primary key as the 'code' column, \n // to keep track of the latest order information for each stock\n def onload(){\n addEventListener(checkOrders,'Orders',,'all') \n orderDV = streamTable(array(STRING, 0) as market, array(STRING, 0) as code, array(DOUBLE, 0) as price, array(INT, 0) as qty, array(TIMESTAMP, 0) as updateTime) \n share(orderDV,'orderDV') \n createDataViewEngine('orderDV', objByName('orderDV'), `code, `updateTime)\n }\n // Update the latest order information for each stock\n def checkOrders(newOrder){\n\t\tgetDataViewEngine('orderDV').append!(table(newOrder.market as market, newOrder.code as code, newOrder.price as price, newOrder.qty as qty))\n }\n}\n\n```\n\n**Related functions**: [createCEPEngine](https://docs.dolphindb.com/en/Functions/c/create_cep_engine.html), [createDataViewEngine](https://docs.dolphindb.com/en/Functions/c/create_data_view_engine.html), [deleteDataViewItems](https://docs.dolphindb.com/en/Functions/d/delete_data_view_items.html), [getDataViewEngine](https://docs.dolphindb.com/en/Functions/g/get_data_view_engine.html)\n" }, "DStream::anomalyDetectionEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_anomalyDetectionEngine.html", "signatures": [ { "full": "DStream::anomalyDetectionEngine(metrics, timeColumn, [keyColumn], [windowSize], [step], [garbageSize], [roundTime=true], [anomalyDescription])", "name": "DStream::anomalyDetectionEngine", "parameters": [ { "full": "metrics", "name": "metrics" }, { "full": "timeColumn", "name": "timeColumn" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[windowSize]", "name": "windowSize", "optional": true }, { "full": "[step]", "name": "step", "optional": true }, { "full": "[garbageSize]", "name": "garbageSize", "optional": true }, { "full": "[roundTime=true]", "name": "roundTime", "optional": true, "default": "true" }, { "full": "[anomalyDescription]", "name": "anomalyDescription", "optional": true } ] } ], "markdown": "### [DStream::anomalyDetectionEngine](https://docs.dolphindb.com/en/Functions/d/DStream_anomalyDetectionEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::anomalyDetectionEngine(metrics, timeColumn, \\[keyColumn], \\[windowSize], \\[step], \\[garbageSize], \\[roundTime=true], \\[anomalyDescription])\n\n#### Details\n\nCreates an anomaly detection engine. For details, see [createAnomalyDetectionEngine](https://docs.dolphindb.com/en/Functions/c/createAnomalyDetectionEngine.html).\n\n#### Parameters\n\n**metrics** is metacode or tuple specifying the formulas for anomaly detection. It uses functions or expressions such as `<[sum(qty)>5, avg(qty)>qty, qty<4]>` that indicate anomaly conditions and return Boolean values.\n\nNote: The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**timeColumn** is a string indicating the name of the temporal column of the input stream table.\n\n**keyColumn** (optional) is a STRING scalar or vector indicating the grouping columns. The anomaly detection engine conducts calculations within each group specified by *keyColumn*.\n\n**windowSize** (optional) is a positive integer indicating the size of window for calculation. Only the left boundary is included in the window.\n\n**step** (optional) is a positive integer indicating the duration between 2 adjacent windows. The value of *windowSize* must be a multiple of *step*.\n\nNote: If aggregate functions are used in *metrics*, parameters *windowSize* and *step* must be specified.\n\n**garbageSize** (optional) is a positive integer. The default value is 2,000 (in Bytes).\n\n* If *keyColumn* is not specified, when the number of historical records in memory exceeds *garbageSize*, the system will clear the records that are no longer needed.\n\n* If *keyColumn* is specified, garbage collection is conducted separately in each group. When the number of historical records in a group exceeds *garbageSize*, the system will clear the records that are no longer needed within the group.\n\nNote that *garbageSize* only takes effect when aggregate function(s) are specified in parameter metrics.\n\n**roundTime** (optional) is a Boolean value indicating the method to align the window boundary if the time column is in millisecond or second precision and step is greater than one minute. The default value is true indicating the alignment is based on the multi-minute rule. False means alignment is based on the one-minute rule (See [Alignment Rules](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.html)).\n\n**anomalyDescription** (optional) is a STRING vector, where each element indicates a custom description for the corresponding anomaly condition specified in *metrics*.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\nadGraph = createStreamGraph(\"anomalyDetection\")\nadGraph.source(\"trade\", 1000:0, `time`sym`qty, [TIMESTAMP, SYMBOL, INT])\n .anomalyDetectionEngine(metrics=<[sum(qty) > 5, avg(qty) > qty, qty < 4]>, timeColumn=`time, keyColumn=`sym, windowSize=3, step=3)\n .sink(\"anomal_output\")\nadGraph.submit()\ngo\n\ntimes=2024.10.08T01:01:01.001 + 1..6\nsyms=[\"A\", \"B\", \"A\", \"B\", \"A\", \"B\"]\nqtys=[6, 5, 4, 3, 2, 1]\ntmp=table(times as timestamp, syms as sym, qtys as qty)\n\nappendOrcaStreamTable(\"trade\", tmp)\n\nselect * from orca_table.anomal_output \n```\n\n| time | sym | type | metric |\n| ----------------------- | --- | ---- | -------------- |\n| 2024.10.08T01:01:01.003 | A | 0 | sum(qty) > 5 |\n| 2024.10.08T01:01:01.004 | A | 1 | avg(qty) > qty |\n| 2024.10.08T01:01:01.005 | B | 2 | qty < 4 |\n| 2024.10.08T01:01:01.006 | A | 1 | avg(qty) > qty |\n| 2024.10.08T01:01:01.006 | A | 2 | qty < 4 |\n| 2024.10.08T01:01:01.006 | B | 0 | sum(qty) > 5 |\n| 2024.10.08T01:01:01.007 | B | 1 | avg(qty) > qty |\n| 2024.10.08T01:01:01.007 | B | 2 | qty < 4 |\n" }, "DStream::asofJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_asofJoinEngine.html", "signatures": [ { "full": "DStream::asofJoinEngine(rightStream, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [delayedTime], [garbageSize], [sortByTime])", "name": "DStream::asofJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[delayedTime]", "name": "delayedTime", "optional": true }, { "full": "[garbageSize]", "name": "garbageSize", "optional": true }, { "full": "[sortByTime]", "name": "sortByTime", "optional": true } ] } ], "markdown": "### [DStream::asofJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_asofJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::asofJoinEngine(rightStream, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[delayedTime], \\[garbageSize], \\[sortByTime])\n\n#### Details\n\nCreates an asof join streaming engine. For details, see [createAsofJoinEngine](https://docs.dolphindb.com/en/Functions/c/createAsofJoinEngine.html).\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**metrics** is metacode (can be a tuple) specifying the calculation formulas. For more information about metacode, refer to [Metaprogramming](https://test.dolphindb.cn/en/Programming/Metaprogramming/MetacodeWithFunction.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (but not aggregate functions), or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n\n* *metrics* can be functions with multiple returns and the columns in the output table to hold the return values must be specified. For example, \\.\n\n* To specify a column that exists in both the left and the right tables, use the format *tableName.colName*.\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the columns to match are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If both tables share the names of all columns to match, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"orderNo\" and \"sym\" in the left table, whereas in the right table they're named \"orderNo\" and \"sym1\", then *matchingColumn* = \\[\\[\\`orderNo, \\`sym], \\[\\`orderNo,\\`sym1]].\n\n**timeColumn** (optional) specifies the name of the time column in the left table and the right table. The time columns must have the same data type. When *useSystemTime* = false, it must be specified. If the names of the time column in the left table and the right table are the same, *timeColumn* is a string. Otherwise, it is a vector of 2 strings indicating the time column in each table.\n\n**useSystemTime** (optional) indicates whether the left table and the right table are joined on the system time, instead of on *timeColumn*.\n\n* *useSystemTime* = true: join records based on the system time (timestamp with millisecond precision) when they are ingested into the engine.\n* *useSystemTime* = false (default): join records based on the specified \\*timeColumn\\* from the left table and the right table.\n\n**delayedTime** (optional) is a positive integer with the same precision as *timeColumn*, indicating the maximum time to wait before the engine joins an uncalculated record in the left table with a right table record. To specify *delayedTime*, *timeColumn* must be specified. For more information, see Details.\n\n**garbageSize** (optional) is a positive integer with the default value of 5,000 (rows). As the subscribed data is ingested into the engine, it continues to take up the memory. Within the left/right table, the records are grouped by *matchingColumn* values; When the number of records in a group exceeds *garbageSize*, the system will remove those already been calculated from memory.\n\n**sortByTime** (optional) is a Boolean value that indicates whether the output data is globally sorted by time. The default value is false, meaning the output data is sorted only within groups. Note that if *sortByTime* is set to true, the parameter *delayedTime* cannot be specified, and the data input to the left and right tables must be globally sorted.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('asofJoin')\n\ng = createStreamGraph('asofJoin')\nr = g.source(\"right\", 1024:0, `time`sym`bid`ask, [TIMESTAMP, SYMBOL, DOUBLE, DOUBLE])\ng.source(\"left\", 1024:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n .asofJoinEngine(r, <[price, bid, ask, abs(price-(bid+ask)/2)]>, `sym, `time)\n .sink(\"output\")\ng.submit()\ngo\n\ntmp1=table(2024.08.27T09:30:00.000+2 8 20 22 23 24 as time, take(`A`B, 6) as sym, 20.01 20.04 20.07 20.08 20.4 20.5 as price)\ntmp1.sortBy!(`time)\nappendOrcaStreamTable(\"left\", tmp1)\n\ntmp2=table(2024.08.27T09:30:00.000+1 5 6 11 19 20 21 as time, take(`A`B, 7) as sym, 20 20.02 20.03 20.05 20.06 20.6 20.4 as bid, 20.01 20.03 20.04 20.06 20.07 20.5 20.6 as ask)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| time | sym | price | bid | ask | abs |\n| ----------------------- | --- | ----- | ----- | ----- | -------------------- |\n| 2024.08.27 09:30:00.002 | A | 20.01 | 20.00 | 20.01 | 0.004999999999999005 |\n| 2024.08.27 09:30:00.020 | A | 20.07 | 20.06 | 20.07 | 0.005000000000002558 |\n| 2024.08.27 09:30:00.008 | B | 20.04 | 20.02 | 20.03 | 0.015000000000000568 |\n" }, "DStream::buffer": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_buffer.html", "signatures": [ { "full": "DStream::buffer(name, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::buffer", "parameters": [ { "full": "name", "name": "name" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::buffer](https://docs.dolphindb.com/en/Functions/d/DStream_buffer.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::buffer(name, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nCreates a persisted shared stream table to store intermediate results in stream processing.\n\nFor more information on table persistence, refer to the [enableTableShareAndPersistence](https://docs.dolphindb.com/en/Functions/e/enableTableShareAndPersistence.html) documentation.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", 1:0, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n .timeSeriesEngine(windowSize=60, step=60, metrics=[, , , , ], timeColumn=`time, keyColumn=`symbol)\n .buffer(\"bufferTable\")\n```\n" }, "DStream::changelogSink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_changelogSink.html", "signatures": [ { "full": "DStream::changelogSink(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::changelogSink", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::changelogSink](https://docs.dolphindb.com/en/Functions/d/DStream_changelogSink.html)\n\nFirst introduced in version: 3.00.5\n\n\n\n#### Syntax\n\nDStream::changelogSink(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nOutputs the stream data to a persisted keyed stream table with a status column.\n\nFor more information on keyed stream tables, refer to the [changelogStreamTable](https://docs.dolphindb.com/en/Functions/c/changelogStreamTable.html) documentation.\n\n#### Parameters\n\n**name** A string specifying the name of the target tream table.\n\n**keyColumn** A string scalar or vector specifying the primary key column(s).\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA table.\n\n**Related functions**: [changelogStreamTable](https://docs.dolphindb.com/en/Functions/c/changelogStreamTable.html), [StreamGraph::changelogSource](https://docs.dolphindb.com/en/Functions/s/StreamGraph_changelogSource.html)\n" }, "DStream::crossSectionalEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_crossSectionalEngine.html", "signatures": [ { "full": "DStream::crossSectionalEngine(metrics, keyColumn, [triggeringPattern='perBatch'], [triggeringInterval=1000], [useSystemTime=true], [timeColumn], [lastBatchOnly=false], [contextByColumn], [roundTime=true], [keyFilter])", "name": "DStream::crossSectionalEngine", "parameters": [ { "full": "metrics", "name": "metrics" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[triggeringPattern='perBatch']", "name": "triggeringPattern", "optional": true, "default": "'perBatch'" }, { "full": "[triggeringInterval=1000]", "name": "triggeringInterval", "optional": true, "default": "1000" }, { "full": "[useSystemTime=true]", "name": "useSystemTime", "optional": true, "default": "true" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[lastBatchOnly=false]", "name": "lastBatchOnly", "optional": true, "default": "false" }, { "full": "[contextByColumn]", "name": "contextByColumn", "optional": true }, { "full": "[roundTime=true]", "name": "roundTime", "optional": true, "default": "true" }, { "full": "[keyFilter]", "name": "keyFilter", "optional": true } ] } ], "markdown": "### [DStream::crossSectionalEngine](https://docs.dolphindb.com/en/Functions/d/DStream_crossSectionalEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::crossSectionalEngine(metrics, keyColumn, \\[triggeringPattern='perBatch'], \\[triggeringInterval=1000], \\[useSystemTime=true], \\[timeColumn], \\[lastBatchOnly=false], \\[contextByColumn], \\[roundTime=true], \\[keyFilter])\n\n#### Details\n\nCreates a cross-sectional streaming engine. For details, see [createCrossSectionalEngine](https://docs.dolphindb.com/en/Functions/c/createCrossSectionalEngine.html).\n\n#### Parameters\n\n**metrics** (optional) is metacode or a tuple specifying the formulas for calculation. It can be:\n\n* Built-in or user-defined aggregate functions, e.g., `<[sum(qty), avg(price)]>`; Or expressions on previous results, e.g., `<[avg(price1)-avg(price2)]>`; Or calculation on multiple columns, e.g., `<[std(price1-price2)]>`\n\n* Functions with multiple returns, such as ``. The column names can be specified or not. For more information about metacode, see [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**keyColumn** is a STRING scalar or vector that specifies one or more columns in the stream table as the key columns. For each unique value in the *keyColumn*, only the latest record is used in the calculation.\n\n**triggeringPattern** (optional) is a STRING scalar specifying how to trigger the calculations. The engine returns a result every time a calculation is triggered. It can take one of the following values:\n\n* 'perBatch' (default): calculates when a batch of data arrives.\n\n* 'perRow': calculates when a new record arrives.\n\n* 'interval': calculates at intervals specified by *triggeringInterval*, using system time.\n\n* 'keyCount': When data with the same timestamp arrives in batches, the calculation is triggered when:\n\n * if the number of keys with the latest timestamp reaches *triggeringInterval*;\n\n * or data with newer timestamp arrives.\n\n* 'dataInterval': calculates at intervals based on timestamps in the data. To use this, *timeColumn* must be specified and *useSystemTime* must be false.\n\nNote: To set *triggeringPattern* as 'keyCount', *timeColumn* must be specified and *useSystemTime* must be set to false. In this case, the out-of-order data will be discarded.\n\n**triggeringInterval** (optional) can be an integer or a tuple. Below explains its optional values and triggering rules:\n\n* If *triggeringPattern* = 'interval', *triggeringInterval* is a positive integer indicating the interval in milliseconds between 2 adjacent calculations. The default value is 1,000. Every *triggeringInterval* milliseconds, the system checks if the data in the engine has been calculated; if not, a calculation is triggered.\n\n* If *triggeringPattern* = 'keyCount', *triggeringInterval* can be:\n\n * an integer specifying a threshold. Before data with a greater timestamp arrives, a calculation is triggered when the number of uncalculated records reaches the threshold.\n\n * a tuple of 2 elements. The first element is an integer indicating the threshold of the number records with the latest timestamp to trigger calculation. The second element is an integer or duration value.\n\n For example, when *triggeringInterval* is set to (c1, c2):\n\n * If c2 is an integer and the number of keys with the latest timestamp t1 doesn't reach c1, calculation will not be triggered and the system goes on to save data with greater timestamp t2 (t2>t1). Data with t1 will be calculated when either of the events happens: the number of keys with timestamp t2 reaches c2, or data with greater timestamp t3 (t3>t2) arrives. Note that c2 must be smaller than c1.\n\n * If c2 is a duration and the number of keys with the latest timestamp t1 doesn't reach c1, calculation will not be triggered and the system goes on to save data with greater timestamp t2 (t2>t1) . Once data with t2 starts to come in, data with t1 will not be calculated until any of the events happens: the number of keys with timestamp t1 reaches c1, or data with greater timestamp t3 (t3>t2) arrives, or the duration c2 comes to an end.\n\n* If *triggeringPattern*= 'dataInterval', *triggeringInterval* is a positive integer measured in the same units as the timestamps in *timeColumn*. The default is 1,000. Starting with the first record, a window is started at intervals defined by *triggeringInterval*, based on the timestamp units. When the first record of the next window arrives, a calculation is triggered on all data in the current window.\n\n * In versions 2.00.11.21.30.23.2 and earlier, a calculation is triggered for each window.\n\n * Since version 2.00.11.31.30.23.3, a calculation is triggered only for windows containing data.\n\n**useSystemTime** (optional) is a Boolean value indicating whether the calculations are performed based on the system time when data is ingested into the engine.\n\n* If *useSystemTime* = true, the time column of outputTable is the system time;\n\n* If *useSystemTime* = false, the parameter timeColumn must be specified. The time column of *outputTable* uses the timestamp of each record.\n\n**timeColumn** (optional) is a STRING scalar which specifies the time column in the stream table to which the engine subscribes if *useSystemTime* = false. It can only be of TIMESTAMP type.\n\n**lastBatchOnly** (optional) is a Boolean value indicating whether to keep only the records with the latest timestamp in the engine. When *lastBatchOnly* = true, *triggeringPattern* must take the value 'keyCount', and the cross-sectional engine only maintains key values with the latest timestamp for calculation. Otherwise, the engine updates and retains all values for calculation.\n\n**contextByColumn** (optional) is a STRING scalar or vector indicating the grouping column(s) based on which calculations are performed by group. This parameter only takes effect if *metrics* and *outputTable* are specified. If *metrics* only contains aggregate functions, the calculation results would be the same as a SQL query using `group by`. Otherwise, the results would be consistent with that using `context by`.\n\n**roundTime** (optional) is a Boolean value indicating the method to align the window boundary when *triggeringPattern*='dataInterval'. The default value is true indicating the alignment is based on the multi-minute rule (see the [alignment rules](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.md#) of time-series engine). False means alignment is based on the one-minute rule.\n\n**keyFilter** (optional) is metacode of an expression or function call that returns a Boolean vector. It specifies the conditions for filtering keys in the keyed table returned by the engine. Only data with keys satisfying the filtering conditions will be taken for calculation.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('cs')\n\ncsGraph = createStreamGraph(\"cs\")\ncsGraph.source(\"trade1\", 1000:0, `time`sym`price`volume,[TIMESTAMP,SYMBOL,DOUBLE,INT])\n .crossSectionalEngine(metrics=<[avg(price), sum(volume), sum(price*volume), count(price)]>, keyColumn=`sym)\n .sink(\"cs_output\")\ncsGraph.submit()\ngo\n\ntimes=2020.08.12T09:30:00.000 + 123 234 456 678 890 901\nsyms=`A`B`A`B`B`A\nprices=10 20 10.1 20.1 20.2 10.2\nvolumes=20 10 20 30 40 20\ntmp=table(times as time, syms as sym, prices as price, volumes as volume)\n\nappendOrcaStreamTable(\"trade1\", tmp)\n\nselect * from orca_table.cs_output;\n```\n" }, "DStream::cryptoOrderBookEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_cryptoOrderBookEngine.html", "signatures": [ { "full": "DStream::cryptoOrderBookEngine(inputColMap, depth, [updateRule='direct'], [errorHandler=NULL], [cachingInterval=5000], [timeout=-1], [cachedDepth])", "name": "DStream::cryptoOrderBookEngine", "parameters": [ { "full": "inputColMap", "name": "inputColMap" }, { "full": "depth", "name": "depth" }, { "full": "[updateRule='direct']", "name": "updateRule", "optional": true, "default": "'direct'" }, { "full": "[errorHandler=NULL]", "name": "errorHandler", "optional": true, "default": "NULL" }, { "full": "[cachingInterval=5000]", "name": "cachingInterval", "optional": true, "default": "5000" }, { "full": "[timeout=-1]", "name": "timeout", "optional": true, "default": "-1" }, { "full": "[cachedDepth]", "name": "cachedDepth", "optional": true } ] } ], "markdown": "### [DStream::cryptoOrderBookEngine](https://docs.dolphindb.com/en/Functions/d/DStream_cryptoOrderBookEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::cryptoOrderBookEngine(inputColMap, depth, \\[updateRule='direct'], \\[errorHandler=NULL], \\[cachingInterval=5000], \\[timeout=-1], \\[cachedDepth])\n\n#### Details\n\nCreates a real-time order book engine for cryptocurrency stream processing, which updates the order book in real time based on full-depth snapshots and incremental depth information. For details, see [createCryptoOrderBookEngine](https://docs.dolphindb.com/en/Functions/c/createCryptoOrderBookEngine.html).\n\n#### Parameters\n\n**inputColMap** is a dictionary mapping column names in *dummyTable* to the required columns.\n\n**depth** is an integer or dictionary specifying the depth of the order book.\n\n* Integer: Applies the same depth for all cryptocurrencies.\n* Dictionary: Keys are cryptocurrency codes, and values are the depth for each. If a cryptocurrency is not specified, it will not output an order book result.\n\n**updateRule** (optional) is a string specifying the order book update rule.\n\n* \"direct\" (default): Updates directly based on isIncremental field (true for update, false for overwrite).\n* \"general\": General update rule, requiring streaming data with monotonically increasing update IDs.\n* \"Binance-spot\": Update rule for Binance spot data.\n* \"Binance-futures\": Update rule for Binance futures data.\n\n**errorHandler** (optional) is a UDF to handle errors when incremental data is missing. It takes two arguments:\n\n* The first argument is a string representing the cryptocurrency code.\n* The second argument is an integer representing the error code, with possible values:\n * **1**: Received old data.\n * **2**: Received out-of-order data expected at a future time.\n * **3**: Timeout, indicating no new order book update within the specified time.\n * **4**: Crossed prices error, where the highest bid is greater than or equal to the lowest ask.\n\n**cachingInterval**(optional) is an integer indicating the interval (in milliseconds) within which incremental data is cached. The default is 5000. For each crypto, data is retained in the cache if the time difference between the first data in cache and the latest is no greater than *cachingInterval*.\n\n**timeout** (optional) is an integer specifying the timeout period in milliseconds. The default is -1 (no timeout). If order book is not updated within this period, the *errorHandler* will be invoked.\n\n**cachedDepth** (optional) is an integer or dictionary specifying the depth for cached order books.\n\n* Integer: Applies the same depth for cached order books for all cryptocurrencies.\n* Dictionary: Keys are cryptocurrency codes, and values are the depth for each. If a cryptocurrency is not specified, full-depth order books are cached.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// Define input table schema\ncolNames = `isIncremental`exchange`eventTime`transactionTime`symbol`firstUpdateId`lastUpdateId`prevLastUpdateId`bidPrice`bidQty`askPrice`askQty\ncolTypes = [BOOL, SYMBOL, TIMESTAMP, TIMESTAMP, SYMBOL, LONG, LONG, LONG, DECIMAL128(18)[], DECIMAL128(8)[], DECIMAL128(18)[], DECIMAL128(8)[]]\n\ninputTarget = [\"symbol\", \"eventTime\", \"isIncremental\", \"bidPrice\", \"bidQty\", \"askPrice\", \"askQty\", \"lastUpdateId\", \"firstUpdateId\", \"prevLastUpdateId\"]\ninputSource = [\"symbol\", \"eventTime\", 'isIncremental', 'bidPrice', 'bidQty', 'askPrice', 'askQty', 'lastUpdateId', 'firstUpdateId', 'prevLastUpdateId']\n\n// Map input columns\ninputColMap = dict(inputTarget, inputSource)\n\n// Set depth\ndepth = dict([\"BTCUSDT\"], [1000])\n\ncptGraph = createStreamGraph(\"cptEngine\")\ncptGraph.source(\"cptInput\", 1000:0, colNames,colTypes)\n.cryptoOrderBookEngine(inputColMap, depth)\n.sink(\"output\")\ncptGraph.submit()\n```\n" }, "DStream::dailyTimeSeriesEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_dailyTimeSeriesEngine.html", "signatures": [ { "full": "DStream::dailyTimeSeriesEngine(windowSize, step, metrics, sessionBegin, [sessionEnd], [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useWindowStartTime], [roundTime=true], [fill='none'], [mergeSessionEnd=false], [forceTriggerTime], [forceTriggerSessionEndTime], [keyPurgeFreqInSecond], [closed='left'], [subWindow], [parallelism=1],[acceptedDelay=0], [keyPurgeDaily=true])", "name": "DStream::dailyTimeSeriesEngine", "parameters": [ { "full": "windowSize", "name": "windowSize" }, { "full": "step", "name": "step" }, { "full": "metrics", "name": "metrics" }, { "full": "sessionBegin", "name": "sessionBegin" }, { "full": "[sessionEnd]", "name": "sessionEnd", "optional": true }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[updateTime]", "name": "updateTime", "optional": true }, { "full": "[useWindowStartTime]", "name": "useWindowStartTime", "optional": true }, { "full": "[roundTime=true]", "name": "roundTime", "optional": true, "default": "true" }, { "full": "[fill='none']", "name": "fill", "optional": true, "default": "'none'" }, { "full": "[mergeSessionEnd=false]", "name": "mergeSessionEnd", "optional": true, "default": "false" }, { "full": "[forceTriggerTime]", "name": "forceTriggerTime", "optional": true }, { "full": "[forceTriggerSessionEndTime]", "name": "forceTriggerSessionEndTime", "optional": true }, { "full": "[keyPurgeFreqInSecond]", "name": "keyPurgeFreqInSecond", "optional": true }, { "full": "[closed='left']", "name": "closed", "optional": true, "default": "'left'" }, { "full": "[subWindow]", "name": "subWindow", "optional": true }, { "full": "[parallelism=1]", "name": "parallelism", "optional": true, "default": "1" }, { "full": "[acceptedDelay=0]", "name": "acceptedDelay", "optional": true, "default": "0" }, { "full": "[keyPurgeDaily=true]", "name": "keyPurgeDaily", "optional": true, "default": "true" } ] } ], "markdown": "### [DStream::dailyTimeSeriesEngine](https://docs.dolphindb.com/en/Functions/d/DStream_dailyTimeSeriesEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::dailyTimeSeriesEngine(windowSize, step, metrics, sessionBegin, \\[sessionEnd], \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[fill='none'], \\[mergeSessionEnd=false], \\[forceTriggerTime], \\[forceTriggerSessionEndTime], \\[keyPurgeFreqInSecond], \\[closed='left'], \\[subWindow], \\[parallelism=1],\\[acceptedDelay=0], \\[keyPurgeDaily=true])\n\n#### Details\n\nCreates a daily time-series streaming engine. For details, see [createDailyTimeSeriesEngine](https://docs.dolphindb.com/en/Functions/c/createDailyTimeSeriesEngine.html).\n\n#### Parameters\n\n**windowSize** is a scalar or vector with positive integers that specifies the size of the windows for calculation.\n\n**step** is a positive integer indicating how much each window moves forward relative to the previous one. Note that step must be divisible by *windowSize*, otherwise an exception will be thrown.\n\n**metrics** is metacode or a tuple specifying the calculation formulas. For more information about metacode please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* It can use one or more built-in or user-defined aggregate functions (which must be defined by the `defg` keyword) such as `<[sum(volume), avg(price)]>`, or expressions of aggregate functions such as as `<[avg(price1)-avg(price2)]>`, or aggregate functions involving multiple columns such as `<[std(price1-price2)]>`.\n* You can specify functions that return multiple values for *metrics*, such as `` (it's optional to specify the column names).\n* The metacode can be a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n* If *metrics* is a tuple with multiple formulas, *windowSize* is specified as a vector of the same length as *metrics*. Each element of *windowSize* corresponds to the elements in *metrics*. For example, if *windowSize*=\\[10,20], *metrics* can be `(<[min(volume), max(volume)]>, )`. *metrics* can also input nested tuple vectors, such as `[[<[min(volume), max(volume)]>, ], []]`.\n\n**Note:**\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n* Nested aggregate function calls are not supported in *metrics*.\n\n**sessionBegin** can be a scalar or vector of type SECOND, TIME or NANOTIME corresponding to the data type of the time column, indicating the starting time of each session. If it is a vector, it must be increasing.\n\n**sessionEnd** (optional) can be a scalar or vector of type SECOND, TIME or NANOTIME corresponding to the data type of the time column, indicating the end time of each session. Specify *sessionEnd* as 00:00:00 to indicate the beginning of the next day (i.e., 24:00:00 of the current day).\n\n**timeColumn** (optional) is a STRING scalar or vector specifying the time column(s) of the subscribed stream table. When *useSystemTime* = false, it must be specified.\n\n**useSystemTime** (optional) is a Boolean value indicating whether the calculations are performed based on the system time when data is ingested into the engine.\n\n* *useSystemTime* = true: the engine will regularly window the streaming data at fixed time intervals for calculations according to the ingestion time (local system time with millisecond precision, independent of any temporal columns in the streaming table) of each record. As long as a window contains data, the calculation will be performed automatically when the window ends. The first column in output table indicates the timestamp when the calculation occurred.\n* *useSystemTime* = false (default): the engine will window the streaming data according to the timeColumn in the stream table. The calculation for a window is triggered by the first record after the previous window. Note that the record which triggers the calculation will not participate in this calculation.\n\nFor example, there is a window ranges from 10:10:10 to 10:10:19. If *useSystemTime* = true and the window is not empty, the calculation will be triggered at 10:10:20. If *useSystemTime* = false and the first record after 10:10:19 is at 10:10:25, the calculation will be triggered at 10:10:25.\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the name of the grouping column(s). If it is specified, the engine conducts the calculations within each group. For example, group the data by stock symbol and apply moving aggregation functions to each stock.\n\n**updateTime** (optional) is a non-negative integer which takes the same time precision as *timeColumn*. It is used to trigger window calculations at an interval shorter than *step*. *step* must be a multiple of *updateTime*. To specify *updateTime*, *useSystemTime* must be set to false.\n\n**useWindowStartTime** (optional) is a Boolean value indicating whether the time column in *outputTable* is the starting time of the windows. The default value is false, which means the timestamps in the output table are the end time of the windows. If the *windowSize* is a vector, *useWindowStartTime* must be false.\n\n**roundTime** (optional) is a Boolean value indicating the method to align the window boundary if the time precision is milliseconds or seconds and step is bigger than one minute. The default value is true indicating the alignment is based on the multi-minute rule (see the [alignment rules](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.md#)). False means alignment is based on the one-minute rule.\n\n**fill** (optional) is a vector/scalar indicating the filling method to deal with an empty window (in a group). It can be:\n\n* 'none': no result\n* 'null': output a null value.\n* 'ffill': output the result in the last window.\n* specific value: output the specified value. Its type should be the same as metrics output's type.\n\n*fill* could be a vector to specify different filling method for each metric. The size of the vector must be consistent with the number of elements specified in *metrics*. The element in vector cannot be 'none'.\n\n**mergeSessionEnd** (optional) is a Boolean value. This parameter is only applicable when *closed* = 'left'. It determines whether the record arriving at the end of a session will be included in the calculation of the last window of that session. The default value is false, which means the record will not be included in the last window but will trigger its calculation. If the current session is not the last session of the day, the record will participate in the calculation of the first window of the next session.\n\n**forceTriggerTime** (optional) is a non-negative integer which takes the same time precision as *timeColumn*, indicating the waiting time to force trigger calculation in the uncalculated windows for each group. If *forceTriggerTime* is set, *useSystemTime* must be false and *updateTime* cannot be specified.\n\n**forceTriggerSessionEndTime** (optional) is a positive integer. The unit of *forceTriggerSessionEndTime* is consistent with the precision of *timeColumn*. It indicates the waiting time to force trigger calculation in the window containing the *sessionEnd*, if it ends without calculation.\n\n**keyPurgeFreqInSec** (optional) is a positive integer, measured in seconds. It controls the periodic cleanup of keys corresponding to groups where \"window data is empty,\" in order to prevent excessive memory usage caused by the continuous growth of keys. When this parameter is specified, if the time interval between the current data insertion time and the last cleanup time is greater than or equal to *keyPurgeFreqInSec*, the group with empty window data and its corresponding key will be deleted.\n\n**closed** (optional) is a STRING indicating whether the left or the right boundary is included.\n\n* closed = 'left': left-closed, right-open\n* closed = 'right': left-open, right-closed\n\n**subWindow**(optional)is a pair of integers or DURATION values, indicating the range of the subwindow within the window specified by *windowSize*. If specified, only results calculated within subwindows will be returned and the time column of the output table displays the end time of each subwindow. The calculation of the subwindow will be triggered by the arrival of the next record after the subwindow ends. The boundary of the subwindow is determined by parameter *closed*. When *subWindow* is a pair of integers, it takes the same time precision as *timeColumn*.\n\n**parallelism** (optional) is a positive integer no greater than 63, representing the number of worker threads for parallel computation. The default value is 1. For compute-intensive workloads, adjusting this parameter appropriately can effectively utilize computing resources and reduce computation time. It is recommended to set a value less than the number of CPU cores, normally from 4 to 8.\n\n**acceptedDelay** (optional) is a positive integer specifying the maximum delay for each window to accept data. The default value is 0.\n\n* When *useSystemTime*=true, data received within the *acceptedDelay*time after the window ends will still be considered part of the current window and participate in the computation, and will not be included in the computation of the next window.\n* When *useSystemTime*=false, a window with t as right boundary will wait until a record with a timestamp equal to or later than t + *acceptedDelay* arrives. When such a record arrives, the current window closes and performs a calculation on all records within the window frame. This handles scenarios with out-of-order data.\n\n**keyPurgeDaily** (optional) is a Boolean value determining if existing data groups are automatically removed when newer data of a subsequent calendar day is ingested. The default value is true. If set to false, groups of the previous calendar day are retained.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('DailyTimeSeries')\n\ng = createStreamGraph('DailyTimeSeries')\n\ng.source(\"trades\", 1000:0, `date`second`sym`volume, [DATE, SECOND, SYMBOL, INT])\n.dailyTimeSeriesEngine(windowSize=60, step=60, metrics=<[sum(volume)]>, sessionBegin=09:30:00 13:00:00, sessionEnd=11:30:00 15:00:00, timeColumn=`date`second, mergeSessionEnd=true)\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(date(2025.05.07),8)\nseconds=[09:25:31, 09:26:01, 09:30:02, 09:30:10, 11:29:46, 11:29:50, 11:30:00, 11:30:01]\nsyms=[\"A\", \"B\", \"A\", \"B\", \"A\", \"B\", \"B\", \"A\"]\nvolumes=[8, 10, 26, 14, 30, 11, 14, 4]\ntmp=table(dates as date, seconds as second, syms as sym, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\nselect * from orca_table.output\n```\n\n| concatDateTime | sum\\_volume |\n| ------------------- | ----------- |\n| 2025.05.07 09:31:00 | 58 |\n| 2025.05.07 11:30:00 | 55 |\n" }, "DStream::dualOwnershipReactiveStateEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_dualOwnershipReactiveStateEngine.html", "signatures": [ { "full": "DStream::dualOwnershipReactiveStateEngine(metrics1, metrics2, keyColumn1, keyColumn2, [keyPurgeFilter1], [keyPurgeFilter2], [keyPurgeFreqInSecond=0])", "name": "DStream::dualOwnershipReactiveStateEngine", "parameters": [ { "full": "metrics1", "name": "metrics1" }, { "full": "metrics2", "name": "metrics2" }, { "full": "keyColumn1", "name": "keyColumn1" }, { "full": "keyColumn2", "name": "keyColumn2" }, { "full": "[keyPurgeFilter1]", "name": "keyPurgeFilter1", "optional": true }, { "full": "[keyPurgeFilter2]", "name": "keyPurgeFilter2", "optional": true }, { "full": "[keyPurgeFreqInSecond=0]", "name": "keyPurgeFreqInSecond", "optional": true, "default": "0" } ] } ], "markdown": "### [DStream::dualOwnershipReactiveStateEngine](https://docs.dolphindb.com/en/Functions/d/DStream_dualOwnershipReactiveStateEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::dualOwnershipReactiveStateEngine(metrics1, metrics2, keyColumn1, keyColumn2, \\[keyPurgeFilter1], \\[keyPurgeFilter2], \\[keyPurgeFreqInSecond=0])\n\n#### Details\n\nCreates a dual-ownership reactive state streaming engine. For details, see [createDualOwnershipReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createDualOwnershipReactiveStateEngine.html).\n\n#### Parameters\n\nOnly the parameters of `dualOwnershipReactiveStateEngine` and `reactiveStateEngine` with different usages are explained here.\n\nFor data grouped by *keyColumn1*, they are calculated based on *metrics1* and purged based on *keyPurgeFilter1*; For data grouped by *keyColumn2*, they are calculated based on *metrics2* and purged based on *keyPurgeFilter2*.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('dualOwnershipReactive')\n\ng = createStreamGraph('dualOwnershipReactive')\n\ng.source(\"trades\", 1000:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT])\n.dualOwnershipReactiveStateEngine(metrics1=, metrics2=, keyColumn1=`date`sym, keyColumn2=`date`market)\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(2012.01.01, 10) join take(2012.01.02, 4)\ntimes=[09:00:00.030, 09:00:00.030, 09:00:00.031, 09:00:00.031, 09:00:00.031, 09:00:00.033, 09:00:00.033, 09:00:00.034, 09:00:00.034, 09:00:00.035, 09:00:00.031, 09:00:00.032, 09:00:00.032, 09:00:00.040]\nsyms=[`a, `a, `b, `a, `a, `b, `a, `b, `b, `a, `b, `a, `b, `c]\nmarkets=['B', 'B', 'A', 'B', 'A', 'B', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B']\nprices=[10.65, 10.59, 10.59, 10.65, 10.59, 10.59, 10.59, 10.59, 10.22, 11.0, 10.22, 11.0, 15.6, 13.2]\nqtys=[1500, 2500, 2500, 1500, 2500, 2500, 2500, 2500, 1200, 2500, 1200, 2500, 1300, 2000]\ntmp=table(dates as date, times as time, syms as sym, markets as market, prices as price, qtys as qty)\n\nappendOrcaStreamTable(\"trades\", tmp)\nselect * from orca_table.output\n```\n\n| date | sym | market | mfirst\\_price | mmax\\_price |\n| ---------- | --- | ------ | ------------- | ----------- |\n| 2012.01.01 | a | B |   |   |\n| 2012.01.01 | a | B |   |   |\n| 2012.01.01 | b | A |   |   |\n| 2012.01.01 | a | B | 10.65 | 10.65 |\n| 2012.01.01 | a | A | 10.59 |   |\n| 2012.01.01 | b | B |   | 10.65 |\n| 2012.01.01 | a | A | 10.65 | 10.59 |\n| 2012.01.01 | b | A | 10.59 | 10.59 |\n| 2012.01.01 | b | A | 10.59 | 10.59 |\n| 2012.01.01 | a | A | 10.59 | 11 |\n" }, "DStream::equalJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_equalJoinEngine.html", "signatures": [ { "full": "DStream::equalJoinEngine(rightStream, metrics, matchingColumn, timeColumn, [garbageSize=5000], [maxDelayedTime])", "name": "DStream::equalJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "timeColumn", "name": "timeColumn" }, { "full": "[garbageSize=5000]", "name": "garbageSize", "optional": true, "default": "5000" }, { "full": "[maxDelayedTime]", "name": "maxDelayedTime", "optional": true } ] } ], "markdown": "### [DStream::equalJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_equalJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::equalJoinEngine(rightStream, metrics, matchingColumn, timeColumn, \\[garbageSize=5000], \\[maxDelayedTime])\n\n#### Details\n\nCreates an equi join streaming engine. For details, see [createEquiJoinEngine](https://docs.dolphindb.com/en/Functions/c/createEquiJoinEngine.html).\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**metrics** is metacode (can be a tuple) specifying the calculation formulas. For more information about metacode, refer to [Metaprogramming](https://test.dolphindb.cn/en/Programming/Metaprogramming/MetacodeWithFunction.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (but not aggregate functions), or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n\n* *metrics* can be functions with multiple returns and the columns in the output table to hold the return values must be specified. For example, \\.\n\n* To specify a column that exists in both the left and the right tables, use the format *tableName.colName*.\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the columns to match are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If both tables share the names of all columns to match, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"orderNo\" and \"sym\" in the left table, whereas in the right table they're named \"orderNo\" and \"sym1\", then *matchingColumn* = \\[\\[\\`orderNo, \\`sym], \\[\\`orderNo,\\`sym1]].\n\n**timeColumn** is a STRING scalar or vector indicating the time columns in the left table and the right table. The time columns in the left and right tables must have the same data type. When the two time columns have the same column name, *timeColumn* is a string scalar; otherwise, *timeColumn* is vector of two strings.\n\n**garbageSize** (optional) is a positive integer with the default value of 5,000 (in unit of rows). When the number of rows of historical data in memory exceeds the *garbageSize*, the system will remove the historical data that is not needed for the current calculation on the following conditions:\n\n* The historical data has already been joined and returned.\n\n* For historical data that has not been joined, if the timestamp difference between the historical data and the new arriving data in left/right table has exceeded the *maxDelayedTime*, it will also be discarded.\n\n**maxDelayedTime** (optional) is a positive integer with the default value of 3 (seconds), indicating the maximum time to keep cached data in the engine. This parameter only takes effect when the conditions described in *garbageSize* are met. It is not recommended to set the *maxDelayedTime* too small in case data got removed before it is joined.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\nr = g.source(\"right\", 1024:0, `time`sym`val, [SECOND, SYMBOL, DOUBLE])\ng.source(\"left\", 1024:0, `time`sym`price, [SECOND, SYMBOL, DOUBLE])\n .equalJoinEngine(r, [, , ], `sym, `time)\n .sink(\"output\")\ng.submit()\n\ngo\n\ntmp1=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(1..20) as price)\nappendOrcaStreamTable(\"left\", tmp1)\n\ntmp2=table(13:30:10+1..20 as time, take(`AAPL, 10) join take(`IBM, 10) as sym, double(50..31) as val)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n" }, "DStream::fork": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_fork.html", "signatures": [ { "full": "DStream::fork(count)", "name": "DStream::fork", "parameters": [ { "full": "count", "name": "count" } ] } ], "markdown": "### [DStream::fork](https://docs.dolphindb.com/en/Functions/d/DStream_fork.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::fork(count)\n\n#### Details\n\nForks the stream data into multiple downstream branches by broadcasting the data to each. Each resulting DStream can be processed independently, supporting parallel or divergent processing logic.\n\n#### Parameters\n\n**count** An integer specifying the number of branches.\n\n#### Returns\n\nA list of DStream instances.\n\n#### Examples\n\nForks the stream data for downstream 1-minute and 5-minute factor calculations:\n\n```\nuse catalog test\n\ng = createStreamGraph(\"indicators\")\nsourceStreams = g.source(\"trade\", 1024:0, `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n    .fork(2)\nstream_1min = sourceStreams[0]\n    .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_1min\")\nstream_5min = sourceStreams[1]\n    .timeSeriesEngine(5*60*1000, 5*60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n    .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n    .sink(\"output_5min\")\ng.submit()\n```\n" }, "DStream::getOutputSchema": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_getOutputSchema.html", "signatures": [ { "full": "DStream::getOutputSchema()", "name": "DStream::getOutputSchema", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [DStream::getOutputSchema](https://docs.dolphindb.com/en/Functions/d/DStream_getOutputSchema.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::getOutputSchema()\n\n#### Details\n\nReturns the schema of the current DStream object.\n\n#### Parameters\n\nNone.\n\n#### Examples\n\n```\naggGraph = createStreamGraph(\"aggregation\")\nengine = aggGraph.source(\"trade\", 1000:0, `time`sym`price, [TIMESTAMP, SYMBOL, FLOAT])\n\t.timeSeriesEngine(windowSize=60, step=60, metrics=[], \ntimeColumn=\"time\", keyColumn=\"sym\")\nengine.getOutputSchema()\n\n/* output:\ntime sym sum_price\n---- --- ---------\n*/\n```\n" }, "DStream::haBuffer": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_haBuffer.html", "signatures": [ { "full": "DStream::haBuffer(name, raftGroup, cacheLimit, [retentionMinutes=1440])", "name": "DStream::haBuffer", "parameters": [ { "full": "name", "name": "name" }, { "full": "raftGroup", "name": "raftGroup" }, { "full": "cacheLimit", "name": "cacheLimit" }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" } ] } ], "markdown": "### [DStream::haBuffer](https://docs.dolphindb.com/en/Functions/d/DStream_haBuffer.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::haBuffer(name, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### Details\n\nCreates a high-availability stream table to store intermediate results in stream processing.\n\nFor more information on table persistence, refer to the [haStreamTable](https://docs.dolphindb.com/en/Functions/h/haStreamTable.html) documentation.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**raftGroup** can be either an integer greater than 1 or a string.\n\n* Integer: represents the raft group ID.\n* String: represents a raft group alias, which must be preconfigured via *streamingRaftGroupAliases*.\n\n**cacheSize** is a positive integer representing the maximum number of rows of the high-availability stream table to be kept in memory. If *cacheSize*>1000, it is automatically adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer specifying for how long (in terms of minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file only keeps data in the past 24 hours.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nlogin(`admin,`123456)\n\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n .timeSeriesEngine(windowSize=60, step=60, metrics=[, , , , ], timeColumn=`time, keyColumn=`symbol)\n .haBuffer(name=\"ha_Table\", raftGroup=3, cacheLimit=5)\n```\n" }, "DStream::haKeyedBuffer": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_haKeyedBuffer.html", "signatures": [ { "full": "DStream::haKeyedBuffer(name, keyColumn, raftGroup, cacheLimit, [retentionMinutes=1440])", "name": "DStream::haKeyedBuffer", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "raftGroup", "name": "raftGroup" }, { "full": "cacheLimit", "name": "cacheLimit" }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" } ] } ], "markdown": "### [DStream::haKeyedBuffer](https://docs.dolphindb.com/en/Functions/d/DStream_haKeyedBuffer.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::haKeyedBuffer(name, keyColumn, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### Details\n\nCreates a high-availability keyed stream table to store intermediate results in stream processing.\n\nFor more information on table persistence, refer to the [haStreamTable](https://docs.dolphindb.com/en/Functions/h/haStreamTable.html) documentation.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**keyColumn** A string scalar or vector specifying the primary key column(s).\n\n**raftGroup** can be either an integer greater than 1 or a string.\n\n* Integer: represents the raft group ID.\n* String: represents a raft group alias, which must be preconfigured via *streamingRaftGroupAliases*.\n\n**cacheSize** is a positive integer representing the maximum number of rows of the high-availability stream table to be kept in memory. If *cacheSize*>1000, it is automatically adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer specifying for how long (in terms of minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file only keeps data in the past 24 hours.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n .timeSeriesEngine(windowSize=60, step=60, metrics=[, , , , ], timeColumn=`time, keyColumn=`symbol)\n .haKeyedBuffer(name=\"ha_keyedTable\", keyColumn=`symbol, raftGroup=3, cacheLimit=5000)\n```\n" }, "DStream::haKeyedSink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_haKeyedSink.html", "signatures": [ { "full": "DStream::haKeyedSink(name, keyColumn, raftGroup, cacheLimit, [retentionMinutes=1440])", "name": "DStream::haKeyedSink", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "raftGroup", "name": "raftGroup" }, { "full": "cacheLimit", "name": "cacheLimit" }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" } ] } ], "markdown": "### [DStream::haKeyedSink](https://docs.dolphindb.com/en/Functions/d/DStream_haKeyedSink.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::haKeyedSink(name, keyColumn, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### Details\n\nOutputs stream data to a high-availability keyed stream table.\n\nFor more information on HA stream tables, refer to the [haStreamTable](https://docs.dolphindb.com/en/Functions/h/haStreamTable.html) documentation.\n\n#### Parameters\n\n**name** A string specifying the name of the target stream table.\n\n**keyColumn** A string scalar or vector specifying the primary key column(s).\n\n**raftGroup** can be either an integer greater than 1 or a string.\n\n* Integer: represents the raft group ID.\n* String: represents a raft group alias, which must be preconfigured via *streamingRaftGroupAliases*.\n\n**cacheSize** is a positive integer representing the maximum number of rows of the high-availability stream table to be kept in memory. If *cacheSize*>1000, it is automatically adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer specifying for how long (in terms of minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file only keeps data in the past 24 hours.\n\n#### Returns\n\nA DStream object.\n" }, "DStream::haSink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_haSink.html", "signatures": [ { "full": "DStream::haSink(name, raftGroup, cacheLimit, [retentionMinutes=1440])", "name": "DStream::haSink", "parameters": [ { "full": "name", "name": "name" }, { "full": "raftGroup", "name": "raftGroup" }, { "full": "cacheLimit", "name": "cacheLimit" }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" } ] } ], "markdown": "### [DStream::haSink](https://docs.dolphindb.com/en/Functions/d/DStream_haSink.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::haSink(name, raftGroup, cacheLimit, \\[retentionMinutes=1440])\n\n#### Details\n\nOutputs the stream data to a high-availability stream table.\n\nFor more information on HA stream tables, refer to the [haStreamTable](https://docs.dolphindb.com/en/Functions/h/haStreamTable.html) documentation.\n\n#### Parameters\n\n**name** A string specifying the name of the target stream table.\n\n**raftGroup** can be either an integer greater than 1 or a string.\n\n* Integer: represents the raft group ID.\n* String: represents a raft group alias, which must be preconfigured via *streamingRaftGroupAliases*.\n\n**cacheSize** is a positive integer representing the maximum number of rows of the high-availability stream table to be kept in memory. If *cacheSize*>1000, it is automatically adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer specifying for how long (in terms of minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file only keeps data in the past 24 hours.\n\n#### Returns\n\nA DStream object.\n" }, "DStream::keyedBuffer": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_keyedBuffer.html", "signatures": [ { "full": "DStream::keyedBuffer(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::keyedBuffer", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::keyedBuffer](https://docs.dolphindb.com/en/Functions/d/DStream_keyedBuffer.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::keyedBuffer(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nCreates a persisted keyed stream table to store intermediate results in stream processing.\n\nFor more information on table persistence, refer to the [keyedStreamTable](https://docs.dolphindb.com/en/Functions/k/keyedStreamTable.html) documentation.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", 1:0, `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n .timeSeriesEngine(windowSize=60, step=60, metrics=[, , , , ], timeColumn=`time, keyColumn=`symbol)\n .keyedBuffer(name=\"bufferTable\", keyColumn=\"symbol\")\n```\n" }, "DStream::keyedSink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_keyedSink.html", "signatures": [ { "full": "DStream::keyedSink(name, keyColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::keyedSink", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::keyedSink](https://docs.dolphindb.com/en/Functions/d/DStream_keyedSink.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::keyedSink(name, keyColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nOutputs the stream data to a persisted keyed stream table.\n\nFor more information on keyed stream tables, refer to the [keyedStreamTable](https://docs.dolphindb.com/en/Functions/k/keyedStreamTable.html) documentation.\n\n#### Parameters\n\n**name** A string specifying the name of the target tream table.\n\n**keyColumn** A string scalar or vector specifying the primary key column(s).\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n" }, "DStream::latestKeyedBuffer": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_latestKeyedBuffer.html", "signatures": [ { "full": "DStream::latestKeyedBuffer(name, keyColumn, timeColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::latestKeyedBuffer", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "timeColumn", "name": "timeColumn" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::latestKeyedBuffer](https://docs.dolphindb.com/en/Functions/d/DStream_latestKeyedBuffer.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::latestKeyedBuffer(name, keyColumn, timeColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nCreates a persisted keyed stream table that retains only the latest record for each unique primary key based on a time column, used to store intermediate results in stream processing.\n\nFor more information on table persistence, refer to the [latestKeyedStreamTable](https://docs.dolphindb.com/en/Functions/l/latestKeyedStreamTable.html) documentation.\n\n#### Parameters\n\n**name** is a string representing the name of the Orca stream table. You can provide either the fully qualified name (FQN), such as \"trading.orca\\_table.factors\", or just the table name, like \"factors\". If only the name is given, the system will automatically complete it using the current catalog.\n\n**keyColumn** is a string scalar or vector indicating the name of the primary key columns (which must be of INTEGRAL, TEMPORAL, LITERAL or FLOATING type).\n\n**timeColumn** specifies the time column(s) and can be either:\n\n* A string indicates a single column of integral or temporal type, or\n* A two-element vector indicates two columns that combine to form a unique timestamp: a DATE column and a TIME, SECOND, or NANOTIME column.\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\ng = createStreamGraph(\"indicators\")\n\ng.source(\"trade\", `time`symbol`price`volume, [DATETIME,SYMBOL,DOUBLE,LONG])\n .timeSeriesEngine(windowSize=60, step=60, metrics=[, , , , ], timeColumn=`time, keyColumn=`symbol)\n .latestKeyedBuffer(name=\"bufferTable\", keyColumn=\"symbol\", timeColumn=`time)\n```\n" }, "DStream::latestKeyedSink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_latestKeyedSink.html", "signatures": [ { "full": "DStream::latestKeyedSink(name, keyColumn, timeColumn, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [preCache], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::latestKeyedSink", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "timeColumn", "name": "timeColumn" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[preCache]", "name": "preCache", "optional": true }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::latestKeyedSink](https://docs.dolphindb.com/en/Functions/d/DStream_latestKeyedSink.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::latestKeyedSink(name, keyColumn, timeColumn, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[preCache], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nOutputs stream data to a persisted keyed stream table that retains only the latest record for each unique primary key based on a time column.\n\nFor more information on latest keyed stream tables, refer to the [latestKeyedStreamTable](https://docs.dolphindb.com/en/Functions/l/latestKeyedStreamTable.html) documentation.\n\n#### Parameters\n\n**name** A string specifying the name of the target stream table.\n\n**keyColumn** is a string scalar or vector indicating the name of the primary key columns (which must be of INTEGRAL, TEMPORAL, LITERAL or FLOATING type).\n\n**timeColumn** specifies the time column(s) and can be either:\n\n* A string indicates a single column of integral or temporal type, or\n* A two-element vector indicates two columns that combine to form a unique timestamp: a DATE column and a TIME, SECOND, or NANOTIME column.\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n" }, "DStream::leftSemiJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_leftSemiJoinEngine.html", "signatures": [ { "full": "DStream::leftSemiJoinEngine(rightStream, metrics, matchingColumn, [garbageSize=5000], [updateRightTable=false])", "name": "DStream::leftSemiJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[garbageSize=5000]", "name": "garbageSize", "optional": true, "default": "5000" }, { "full": "[updateRightTable=false]", "name": "updateRightTable", "optional": true, "default": "false" } ] } ], "markdown": "### [DStream::leftSemiJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_leftSemiJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::leftSemiJoinEngine(rightStream, metrics, matchingColumn, \\[garbageSize=5000], \\[updateRightTable=false])\n\n#### Details\n\nCreates a left semi join streaming engine. For details, see [createLeftSemiJoinEngine](https://docs.dolphindb.com/en/Functions/c/createLeftSemiJoinEngine.html) .\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**metrics** is metacode (can be a tuple) specifying the calculation formulas. For more information about metacode, refer to [Metaprogramming](https://test.dolphindb.cn/en/Programming/Metaprogramming/MetacodeWithFunction.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (but not aggregate functions), or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n\n* *metrics* can be functions that return multiple values and the columns in the output table to hold the return values must be specified. For example, \\.\n\nTo specify a column that exists in both the left and the right tables, use the format *tableName.colName*. By default, the column from the left table is used.\n\n**Note:** The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the columns to match are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If both tables share the names of all columns to match, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]].\n\n**garbageSize** (optional) is a positive integer. The default value is 5,000. Unlike other join engines, the *garbageSize* parameter for left semi join engine is only used to remove the historical data from the left table. The system will clear the data from the left table when the number of joined records exceeds *garbageSize*.\n\n**updateRightTable** (optional) is a Boolean value indicating whether to output the first record (*updateRightTable* = true) or the latest record (*updateRightTable* = false) when there are more than one matching records in the right table. The default value is false.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", 1024:0, `time`sym1`vol, [TIMESTAMP, SYMBOL, INT])\ng.source(\"left\", 1024:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n .leftSemiJoinEngine(r, metrics=<[price, vol,price*vol]>, matchingColumn=[[`time,`sym], [`time,`sym1]], updateRightTable=true)\n .sink(\"output\")\ng.submit()\n\ngo\n\nv = [1, 5, 10, 15]\ntmp1=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 4) as sym, rand(100,4) as price)\nappendOrcaStreamTable(\"left\", tmp1)\n\nv = [1, 1, 3, 4, 5, 5, 5, 15]\ntmp2=table(2012.01.01T00:00:00.000+v as time, take(`AAPL, 8) as sym, rand(100,8) as vol)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| time | sym | price | vol | price\\_mul |\n| ----------------------- | ---- | ----- | --- | ---------- |\n| 2012.01.01 00:00:00.001 | AAPL | 36 | 62 | 2,232 |\n| 2012.01.01 00:00:00.005 | AAPL | 82 | 35 | 2,870 |\n| 2012.01.01 00:00:00.015 | AAPL | 60 | 23 | 1,380 |\n" }, "DStream::lookupJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_lookupJoinEngine.html", "signatures": [ { "full": "DStream::lookupJoinEngine(rightStream, metrics, matchingColumn, [rightTimeColumn], [checkTimes], [keepDuplicates=false])", "name": "DStream::lookupJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[rightTimeColumn]", "name": "rightTimeColumn", "optional": true }, { "full": "[checkTimes]", "name": "checkTimes", "optional": true }, { "full": "[keepDuplicates=false]", "name": "keepDuplicates", "optional": true, "default": "false" } ] } ], "markdown": "### [DStream::lookupJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_lookupJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::lookupJoinEngine(rightStream, metrics, matchingColumn, \\[rightTimeColumn], \\[checkTimes], \\[keepDuplicates=false])\n\n#### Details\n\nCreates a lookup join streaming engine. For details, see [createLookupJoinEngine](https://docs.dolphindb.com/en/Functions/c/createLookupJoinEngine.html).\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**metrics** is metacode (can be a tuple) specifying the calculation formulas. For more information about metacode, refer to [Metaprogramming](https://test.dolphindb.cn/en/Programming/Metaprogramming/MetacodeWithFunction.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (but not aggregate functions), or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n\n* *metrics* can be functions that return multiple values and the columns in the output table to hold the return values must be specified. For example, \\.\n\nTo specify a column that exists in both the left and the right tables, use the format *tableName.colName*. By default, the column from the left table is used.\n\n**Note:** The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the columns to match are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n\n* When there are multiple columns to match - If both tables share the names of all columns to match, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]].\n\n**rightTimeColumn** (optional) is a STRING scalar indicating the time column in the right table. If the parameter is specified, the right table will keep the record with the latest timestamp. If there are multiple records with identical timestamps, only the latest record is retained. If the parameter is not specified, the latest ingested record (based) on the system time will be kept.\n\n**checkTimes** (optional) is a vector of temporal values or a DURATION scalar. If it is specified, the system will regularly update the right table (keeping only the latest data) and ingests the latest data to the lookup join engine. If the right table does not need to be updated regularly, you can leave *checkTimes* empty, but make sure to manually ingest the table data to the engine after it has been created.\n\n* If *checkTimes* is a vector of temporal values, it must be of SECOND, TIME or NANOTIME type. The lookup join engine updates the right table according to the time specified by each element in the vector on a daily basis.\n\n* If *checkTimes* is a DURATION scalar, it indicates the interval to update the right table.\n\n**keepDuplicates** (optional) is a Boolean value indicating whether to keep all records in each group of the right table. When set to false (default), the engine keeps the latest record in each group. When set to true, the engine keeps all records in each group - in this case, the engine performs inner join, i.e., output is only generated if a match is found.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", 1024:0, `timestamps`sym`val`id, [TIMESTAMP, SYMBOL, DOUBLE, INT])\ng.source(\"left\", 1024:0, `timestamps`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n .lookupJoinEngine(r, metrics=<[price,val,price*val]>, matchingColumn=`sym)\n .sink(\"output\")\ng.submit()\n\ngo\nn = 15\ntmp1 = table( (2018.10.08T01:01:01.001 + 1..12) join (2018.10.08T01:01:01.001 + 1..3)as timestamps,take(`A`B`C, n) as sym,take(1..15,n) as val,1..15 as id)\nappendOrcaStreamTable(\"right\", tmp1)\n\nn = 10\ntmp2 = table( 2019.10.08T01:01:01.001 + 1..n as timestamps,take(`A`B`C, n) as sym,take(0.1+10..20,n) as price)\nappendOrcaStreamTable(\"left\", tmp2)\n\nselect * from orca_table.output\n```\n\n| sym | price | val | price\\_mul |\n| --- | ----- | --- | ---------- |\n| A | 10.1 | 13 | 131.30 |\n| B | 11.1 | 14 | 155.40 |\n| C | 12.1 | 15 | 181.50 |\n| A | 13.1 | 13 | 170.30 |\n| B | 14.1 | 14 | 197.40 |\n| C | 15.1 | 15 | 226.50 |\n| A | 16.1 | 13 | 209.30 |\n| B | 17.1 | 14 | 239.40 |\n| C | 18.1 | 15 | 271.50 |\n| A | 19.1 | 13 | 248.30 |\n" }, "DStream::map": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_map.html", "signatures": [ { "full": "DStream::map(func)", "name": "DStream::map", "parameters": [ { "full": "func", "name": "func" } ] } ], "markdown": "### [DStream::map](https://docs.dolphindb.com/en/Functions/d/DStream_map.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::map(func)\n\n#### Details\n\nApplies the specified function to the input streams. It is suitable for stateless data processing scenarios (e.g., data filtering).\n\n#### Parameters\n\n**func** A unary function that takes a table composed of streaming data messages as input and returns a table. Downstream engines infer processing logic based on the schema of the returned table.\n\nNote: This function must be a pure function, meaning it must satisfy the following properties:\n\n* Deterministic: Given the same input, it always produces the same output.\n* No side effects: The function must not cause any observable interaction with the outside world. Specifically, it must not:\n * Modify global or external variables.\n * Write to databases or files.\n * Call external APIs or services.\n * Mutate the input table (e.g., by modifying its values in-place).\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\nDefine `map` to generate OHLC data for AAPL:\n\n```\nuse catalog test\n\ng = createStreamGraph(\"graph\")\ng.source(\"trade\", 1024:0, `symbol`datetime`price`volume, [SYMBOL,TIMESTAMP,DOUBLE,INT])\n .map(msg -> select * from msg where symbol == \"AAPL\")\n .timeSeriesEngine(60, 60, <[first(price) as open, max(price) as high, min(price) as low, last(price) as close, sum(volume) as volume]>, \"datetime\", false, \"symbol\")\n .sink(\"output\")\n```\n\n**Related function**: [DStream::udfEngine](https://docs.dolphindb.com/en/Functions/d/DStream_udfEngine.html)\n" }, "DStream::narrowReactiveStateEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_narrowReactiveStateEngin.html", "signatures": [ { "full": "DStream::narrowReactiveStateEngine(metrics, metricNames, keyColumn, [filter], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [keyCapacity=1024], [parallelism=1])", "name": "DStream::narrowReactiveStateEngine", "parameters": [ { "full": "metrics", "name": "metrics" }, { "full": "metricNames", "name": "metricNames" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[filter]", "name": "filter", "optional": true }, { "full": "[keepOrder]", "name": "keepOrder", "optional": true }, { "full": "[keyPurgeFilter]", "name": "keyPurgeFilter", "optional": true }, { "full": "[keyPurgeFreqInSecond=0]", "name": "keyPurgeFreqInSecond", "optional": true, "default": "0" }, { "full": "[keyCapacity=1024]", "name": "keyCapacity", "optional": true, "default": "1024" }, { "full": "[parallelism=1]", "name": "parallelism", "optional": true, "default": "1" } ] } ], "markdown": "### [DStream::narrowReactiveStateEngine](https://docs.dolphindb.com/en/Functions/d/DStream_narrowReactiveStateEngin.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::narrowReactiveStateEngine(metrics, metricNames, keyColumn, \\[filter], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond=0], \\[keyCapacity=1024], \\[parallelism=1])\n\n#### Details\n\nCreates a reactive state engine that returns a table in narrow format. For details, see [createNarrowReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createNarrowReactiveStateEngine.html).\n\n#### Parameters\n\n**metrics** is metacode or a tuple of metacode containing columns from the input table (excluding *keyColumn*, optional) or factors (formulas for calculation, required).\n\n**metricNames** is a STRING scalar or vector, indicating the name for each factor specified in *metrics*. The number and order of names must align to that of factors specified in *metrics*.\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the grouping column(s). The calculation is conducted within each group.\n\n**filter** (optional) is the metacode that indicates the filtering conditions. A filtering condition must be an expression and only columns of *dummyTable*can be included. You can specify multiple conditions with logical operators (and, or). Only the results that satisfy the filter conditions are ingested to the output table.\n\n**keepOrder** (optional) specifies whether to preserve the insertion order of the records in the output table. If *keyColumn* contains a time column, the default value is true, and otherwise false.\n\nTo clean up the data that is no longer needed after calculation, specify parameters *keyPurgeFilter* and *keyPurgeFreqInSecond*.\n\n**keyPurgeFilter** (optional) indicates the filtering conditions that identify the data to be purged from the cache. It is metacode composed of conditional expressions, and these expressions must refer to the columns in the *outputTable*. *keyPurgeFilter* is effective only when *keyColumn* is specified.\n\n**keyPurgeFreqInSecond** (optional) is a positive integer indicating the time interval (in seconds) to trigger a purge. *keyPurgeFreqInSecond* is effective only when *keyColumn* is specified.\n\nFor each data ingestion, the engine starts a purge if all of the following conditions are satisfied:\n\n(1) The time elapsed since the last data ingestion is equal to or greater than *keyPurgeFreqInSecond* (For the first check, the time elapsed between the ingestion of data and the creation of the engine is used);\n\n(2) If the first condition is satisfied, the engine applies *keyPurgeFilter* to the cached data to get the data to be purged.\n\n(3) The number of groups which contain data to be purged is equal to or greater than 10% of the total number of groups in the engine.\n\nTo check the engine status before and after the purge, call `getStreamEngineStat().ReactiveStreamEngine` (see [getStreamEngineStat](https://docs.dolphindb.com/en/Functions/g/getStreamEngineStat.html)) where the *numGroups* field indicates the number of groups in the reactive state streaming engine.\n\n**keyCapacity** (optional) is a positive integer indicating the amount of memory allocated for buffering state of each group (defined by *keyColumn*) on a row basis. The default value is 1024. For data with large amount of groups, setting of this parameter can reduce the latency that may occur.\n\n**parallelism** (optional) is a positive integer no greater than 63, indicating the maximum number of workers that can run in parallel. The default value is 1. For large computation workloads, reasonable adjustment of this parameter can effectively utilize computing resources and reduce computation time.\n\n**Note**: *parallelism* cannot exceed the lesser of the numbers of licensed cores and logical cores minus one.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\nfactor = [, ,,]\n\ng.source(\"trades\", 1000:0, [\"securityID1\",\"securityID2\",\"securityID3\",\"createTime\",\"updateTime\",\"upToDatePrice\",\"qty\",\"value\"], [STRING,STRING,STRING,TIMESTAMP,TIMESTAMP,DOUBLE,DOUBLE,INT])\n.narrowReactiveStateEngine(metrics=factor,metricNames=[\"factor1\",\"factor2\"], keyColumn=[\"securityID1\",\"securityID2\",\"securityID3\"])\n.sink(\"output\")\ng.submit()\ngo\n\ndates=take(2012.01.01, 10) join take(2012.01.02, 4)\ntimes=[09:00:00.030, 09:00:00.030, 09:00:00.031, 09:00:00.031, 09:00:00.031, 09:00:00.033, 09:00:00.033, 09:00:00.034, 09:00:00.034, 09:00:00.035, 09:00:00.031, 09:00:00.032, 09:00:00.032, 09:00:00.040]\nsyms=[`a, `a, `b, `a, `a, `b, `a, `b, `b, `a, `b, `a, `b, `c]\nmarkets=['B', 'B', 'A', 'B', 'A', 'B', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B']\nprices=[10.65, 10.59, 10.59, 10.65, 10.59, 10.59, 10.59, 10.59, 10.22, 11.0, 10.22, 11.0, 15.6, 13.2]\nqtys=[1500, 2500, 2500, 1500, 2500, 2500, 2500, 2500, 1200, 2500, 1200, 2500, 1300, 2000]\ntmp=table(dates as date, times as time, syms as sym, markets as market, prices as price, qtys as qty)\n\nnum = 5\ntmp = table(take(\"A\" + lpad(string(1..4),4,\"0\"),num) as securityID1,take(\"CC.HH\" + lpad(string(21..34),4,\"0\"),num) as securityID2,take(\"FFICE\" + lpad(string(13..34),4,\"0\"),num) as securityID3, 2023.09.01 00:00:00+(1..num) as createTime, 2023.09.01 00:00:00+take(1..num, num).sort() as updateTime,take(rand(100.0,num) join take(int(),30),num) as upToDatePrice,take(take(100.0,num) join take(int(),30),num)+30 as qty,take(1..20 join take(int(),5),num) as value)\n\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| securityID1 | securityID2 | securityID3 | createTime | updateTime | metricName | metricValue |\n| ----------- | ----------- | ----------- | ----------------------- | ----------------------- | ---------- | ------------------ |\n| A0001 | CC.HH0021 | FFICE0013 | 2023.09.01 00:00:01.000 | 2023.09.01 00:00:01.000 | factor1 | 130 |\n| A0001 | CC.HH0021 | FFICE0013 | 2023.09.01 00:00:01.000 | 2023.09.01 00:00:01.000 | factor2 | 5.729826227745667 |\n| A0002 | CC.HH0022 | FFICE0014 | 2023.09.01 00:00:02.000 | 2023.09.01 00:00:02.000 | factor1 | 130 |\n| A0002 | CC.HH0022 | FFICE0014 | 2023.09.01 00:00:02.000 | 2023.09.01 00:00:02.000 | factor2 | 40.09022097935429 |\n| A0003 | CC.HH0023 | FFICE0015 | 2023.09.01 00:00:03.000 | 2023.09.01 00:00:03.000 | factor1 | 130 |\n| A0003 | CC.HH0023 | FFICE0015 | 2023.09.01 00:00:03.000 | 2023.09.01 00:00:03.000 | factor2 | 40.181519178922024 |\n| A0004 | CC.HH0024 | FFICE0016 | 2023.09.01 00:00:04.000 | 2023.09.01 00:00:04.000 | factor1 | 130 |\n| A0004 | CC.HH0024 | FFICE0016 | 2023.09.01 00:00:04.000 | 2023.09.01 00:00:04.000 | factor2 | 21.328769097950172 |\n| A0001 | CC.HH0025 | FFICE0017 | 2023.09.01 00:00:05.000 | 2023.09.01 00:00:05.000 | factor1 | 130 |\n| A0001 | CC.HH0025 | FFICE0017 | 2023.09.01 00:00:05.000 | 2023.09.01 00:00:05.000 | factor2 | 50.23656470375805 |\n" }, "DStream::nearestJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_nearestJoinEngine.html", "signatures": [ { "full": "DStream::nearestJoinEngine(rightStream, kNearest, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize = 5000], [maxDelayedTime], [nullFill], [cachedTableCapacity=1024])", "name": "DStream::nearestJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "kNearest", "name": "kNearest" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[garbageSize = 5000]", "name": "[garbageSize = 5000]" }, { "full": "[maxDelayedTime]", "name": "maxDelayedTime", "optional": true }, { "full": "[nullFill]", "name": "nullFill", "optional": true }, { "full": "[cachedTableCapacity=1024]", "name": "cachedTableCapacity", "optional": true, "default": "1024" } ] } ], "markdown": "### [DStream::nearestJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_nearestJoinEngine.html)\n\nFirst introduced in versions: 3.00.4, 3.00.3.1\n\n\n\n#### Syntax\n\nDStream::nearestJoinEngine(rightStream, kNearest, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize = 5000], \\[maxDelayedTime], \\[nullFill], \\[cachedTableCapacity=1024])\n\n#### Details\n\nCreates a nearest-neighbor join streaming engine. For details, see [createNearestJoinEngine](https://docs.dolphindb.com/en/Functions/c/createNearestJoinEngine.html).\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**kNearest** is a positive integer. For each row in the left table, the engine retrieves the *k* nearest rows from the right table whose timestamps are less than or equal to the current row's timestamp.\n\n**metrics** is metacode (which can be a tuple) specifying the calculation formulas. For more information about metacode, please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions.\n* *metrics* can be functions that return multiple values and the columns in the output table to hold the return values must be specified. For example, \\.\n* The columns in right table can be converted into array vectors using `toArray`, e.g., ``.\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\nIf you want to specify a column that exists in both the left and the right tables, use the format *tableName.colName*. By default, the column from the left table is used.\n\nThe following functions are optimized in the engine when they are applied only to the columns from the right table: `sum`, `sum2`, `avg`, `std`, `var`, `corr`, `covar`, `wavg`, `wsum`, `beta`, `max`, `min`, `last`, `first`, `med`, `percentile`.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the matching column are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If the names of all the columns to match are the same in both tables, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then matchingColumn = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]].\n\n**timeColumn** (optional) When *useSystemTime* = false, it must be specified to indicate the name(s) of the time column in the left table and the right table. The time columns must have the same data type. If the names of the time column in the left table and the right table are the same, *timeColumn* is a string. Otherwise, it is a vector of 2 strings indicating the time column in each table.\n\n**useSystemTime** (optional) indicates whether the left table and the right table are joined on the system time, instead of on the *timeColumn*.\n\n* *useSystemTime* = true: join records based on the system time (timestamp with millisecond precision) when they are ingested into the engine.\n\n* *useSystemTime* = false (default): join records based on the specified timeColumn from the left table and the right table.\n\n**garbageSize** (optional) is a positive integer with the default value of 5,000 (rows). As the subscribed data is ingested into the engine, it continues to take up the memory. Within the left/right table, the records are grouped by *matchingColumn* values; When the number of records in a group exceeds *garbageSize*, the system will remove those already been calculated from memory.\n\n**maxDelayedTime** (optional) is a positive integer. *maxDelayedTime* only takes effect when *timeColumn* is specified and the two arguments must have the same time precision. Use *maxDelayedTime* to trigger windows which remain uncalculated long past its end. The default *maxDelayedTime* is 3 seconds. For more information about this parameter, see \"Window triggering rules\" in the Details section.\n\n**Note:** Please configure the *maxDelayedTime* parameter appropriately. When the left table contains sparse data and the right table has a high data frequency, setting *maxDelayedTime* too small may cause the system to prematurely clean up older data from the right table before certain group computations are triggered.\n\n**nullFill** (optional) is a tuple of the same size as the number of output columns. It is used to fill in the null values in the output table. The data type of each element corresponds to each output column.\n\n**cachedTableCapacity** (optional) is a positive integer indicating the initial capacity (in terms of the number of rows) of the left and right cache tables for each group. The default value is 1024.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('nearestEngine')\ng = createStreamGraph('nearestEngine')\n\nleftStream = g.source(\"leftTable\", 1024:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\nrightStream = g.source(\"rightTable\", 1024:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\nleftStream.nearestJoinEngine(rightStream=rightStream,kNearest=8, metrics=<[price,toArray(val),sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=NULL)\n\t\t.sink(\"output\")\ng.submit()\ngo\n\nn=10\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..10),2*n) as val)\ntp2.sortBy!(`time)\nappendOrcaStreamTable(`rightTable, tp2)\ntp1=table(take(2012.01.01T00:00:00.003+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\n\nappendOrcaStreamTable(`leftTable, tp1)\n\nselect * from orca_table.output\n```\n\n| time | sym | price | toArray\\_val | sum\\_val |\n| ----------------------- | --- | ------------------ | ------------------------- | -------- |\n| 2012.01.01 00:00:00.003 | A | | \\[1, 2, 3, 4] | 10 |\n| 2012.01.01 00:00:00.004 | A | 3.4822947595856824 | \\[1, 2, 3, 4, 5] | 15 |\n| 2012.01.01 00:00:00.005 | A | 7.86139521284484 | \\[1, 2, 3, 4, 5, 6] | 21 |\n| 2012.01.01 00:00:00.006 | A | 3.1722617468716185 | \\[1, 2, 3, 4, 5, 6, 7] | 28 |\n| 2012.01.01 00:00:00.007 | A | 5.3532539582956415 | \\[1, 2, 3, 4, 5, 6, 7, 8] | 36 |\n| 2012.01.01 00:00:00.008 | A | 6.732663744145904 | \\[2, 3, 4, 5, 6, 7, 8, 9] | 44 |\n| 2012.01.01 00:00:00.003 | B | 3.4822947595856824 | \\[2, 3, 4, 5] | 14 |\n| 2012.01.01 00:00:00.004 | B | 7.86139521284484 | \\[2, 3, 4, 5, 6] | 20 |\n| 2012.01.01 00:00:00.005 | B | 3.1722617468716185 | \\[2, 3, 4, 5, 6, 7] | 27 |\n| 2012.01.01 00:00:00.006 | B | 5.3532539582956415 | \\[2, 3, 4, 5, 6, 7, 8] | 35 |\n" }, "DStream::parallelize": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_parallelize.html", "signatures": [ { "full": "DStream::parallelize(columnName, count)", "name": "DStream::parallelize", "parameters": [ { "full": "columnName", "name": "columnName" }, { "full": "count", "name": "count" } ] } ], "markdown": "### [DStream::parallelize](https://docs.dolphindb.com/en/Functions/d/DStream_parallelize.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::parallelize(columnName, count)\n\n#### Details\n\nPartitions the stream data using a hash function based on the specified column. It generates multiple parallel DStream objects for concurrent processing. Null values in the *columnName* will be filtered out.\n\nNote: The `DStream::parallelize` and `DStream::sync` methods must be called together.\n\n#### Parameters\n\n**columnName** A string specifying the name of the column used for partitioning.\n\n**count** An integer representing the degree of parallelism.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\nPartition the stream data into four streams based on the symbol column for downstream calculations:\n\n```\nuse catalog test\n\ng = createStreamGraph(name)\ng.source(\"trade\", 1024:0, `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n .parallelize(\"symbol\", 4)\n .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n .sync()\n .sink(\"output\")\n.g.submit()\n```\n" }, "DStream::pricingEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_pricingEngine.html", "signatures": [ { "full": "DStream::pricingEngine(timeColumn, typeColumn, securityType, method, [securityReference], [keyColumn], [extraMetrics])", "name": "DStream::pricingEngine", "parameters": [ { "full": "timeColumn", "name": "timeColumn" }, { "full": "typeColumn", "name": "typeColumn" }, { "full": "securityType", "name": "securityType" }, { "full": "method", "name": "method" }, { "full": "[securityReference]", "name": "securityReference", "optional": true }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[extraMetrics]", "name": "extraMetrics", "optional": true } ] } ], "markdown": "### [DStream::pricingEngine](https://docs.dolphindb.com/en/Functions/d/DStream_pricingEngine.html)\n\n#### Syntax\n\nDStream::pricingEngine(timeColumn, typeColumn, securityType, method, \\[securityReference], \\[keyColumn], \\[extraMetrics])\n\n#### Details\n\nCreates a pricing engine. For details, see [createPricingEngine](https://docs.dolphindb.com/en/Functions/c/createPricingEngine.html).\n\n**Return value**: A DStream object.\n\n#### Arguments\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ntypeList=[0,1,2]\nstart=2022.07.15\nmaturity=2072.07.15\nissuePrice=100\ncoupon=0.034\nfrequency=\"Semiannual\"\ndayCountConvention=\"ActualActual\"\nbondType=\"FixedRate\"\nsettlement=2025.04.10\nprice=0.02\npriceType=\"YTM\"\n\nmethodList=[,\n ,\n ]\nsecurityReference= table(take(0 1 2, 100) as type, take(1 2 3 4, 100) as assetType,\"s\"+string(1..100) as symbol, 2025.07.25+1..100 as maturity, rand(10.0, 100) as coupon, rand(10,100) as frequency,take([1],100) as basis )\n\n\ng.source(\"trades\", 1000:0, `tradeTime`Symbol`realTimeX`predictY`price,[TIMESTAMP,SYMBOL, DOUBLE, DOUBLE, DOUBLE])\n.pricingEngine(timeColumn=`tradeTime, typeColumn=`type, securityType=typeList, method=methodList, securityReference=securityReference, keyColumn=`Symbol, extraMetrics=[, ])\n.sink(\"output\")\ng.submit()\ngo\n\ndata = table(take(now(), 100)as tradeTime,\"s\"+string(1..100) as symbol, rand(10.0, 100) as realTimeX, rand(10.0, 100) as predictY, rand(10.0, 100) as price)\n\nappendOrcaStreamTable(\"trades\", data)\n```\n" }, "DStream::reactiveStateEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_reactiveStateEngine.html", "signatures": [ { "full": "DStream::reactiveStateEngine(metrics, [keyColumn], [filter], [keepOrder], [keyPurgeFilter], [keyPurgeFreqInSecond=0], [keyCapacity=1024], [parallelism=1])", "name": "DStream::reactiveStateEngine", "parameters": [ { "full": "metrics", "name": "metrics" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[filter]", "name": "filter", "optional": true }, { "full": "[keepOrder]", "name": "keepOrder", "optional": true }, { "full": "[keyPurgeFilter]", "name": "keyPurgeFilter", "optional": true }, { "full": "[keyPurgeFreqInSecond=0]", "name": "keyPurgeFreqInSecond", "optional": true, "default": "0" }, { "full": "[keyCapacity=1024]", "name": "keyCapacity", "optional": true, "default": "1024" }, { "full": "[parallelism=1]", "name": "parallelism", "optional": true, "default": "1" } ] } ], "markdown": "### [DStream::reactiveStateEngine](https://docs.dolphindb.com/en/Functions/d/DStream_reactiveStateEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::reactiveStateEngine(metrics, \\[keyColumn], \\[filter], \\[keepOrder], \\[keyPurgeFilter], \\[keyPurgeFreqInSecond=0], \\[keyCapacity=1024], \\[parallelism=1])\n\n#### Details\n\nCreates a reactive state engine. For details, see [createReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createReactiveStateEngine.html).\n\n#### Parameters\n\n**metrics** is metacode specifying the formulas for calculation. The metacode can include one or more expressions, built-in or user-defined functions, or a constant scalar/vector. Note that the output column for a constant vector must be in array vector form. For more information about metacode refer to [Metaprogramming](https://docs.dolphindb.cn/en/Programming/Metaprogramming/MetacodeWithFunction.html). To use a user-defined function in the reactive state engine,\n\n(1) Add `@state` to declare the function before the definition. For state functions, the following statements are supported:\n\n* Assignment and return statements\n\n* `if...else` statements with scalar expressions (since 1.30.21/2.00.9)\n\n* `for` loops, including `break` and `continue` (since 1.30.23/2.00.11). Loop iterations must be under 100 times. Nested `for` loops are currently unsupported.\n\n(2) Stateless or state functions can be used in a reactive state engine, but the *metrics* parameter cannot be specified as the stateless function nesting with the state function.\n\n(3) If the rvalue of an assignment statement is a built-in or user-defined function that returns multiple values, the values must be assigned to variables at the same time. In the following example, the user-defined state function references linearTimeTrend, which returns two values.\n\n```\n@state\ndef forcast2(S, N){\n\tlinearregIntercept, linearregSlope = linearTimeTrend(S, N)\n\treturn (N - 1) * linearregSlope + linearregIntercept\n}\n```\n\n(4) In the reactive state engine, custom state functions cannot contain self-assignment statements such as `a=a+b`. In the following example, when the condition is false, the `iif` expression returns out, which results in self-assignment (`out = out`) and triggers an error.\n\n```\nout = iif((p1 > 0) and (p2 == 0), p1, out)\n// An assignment statement in state function 'xxx' can't use self reference\n```\n\nNote: The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the grouping column(s). The calculation is conducted within each group.\n\n**filter** (optional) is the metacode that indicates the filtering conditions. A filtering condition must be an expression and only columns of *dummyTable*can be included. You can specify multiple conditions with logical operators (and, or). Only the results that satisfy the filter conditions are ingested to the output table.\n\n**keepOrder** (optional) specifies whether to preserve the insertion order of the records in the output table. If *keyColumn* contains a time column, the default value is true, and otherwise false.\n\nTo clean up the data that is no longer needed after calculation, specify parameters *keyPurgeFilter* and *keyPurgeFreqInSecond*.\n\n**keyPurgeFilter** (optional) indicates the filtering conditions that identify the data to be purged from the cache. It is metacode composed of conditional expressions, and these expressions must refer to the columns in the *outputTable*. *keyPurgeFilter* is effective only when *keyColumn* is specified.\n\n**keyPurgeFreqInSecond** (optional) is a positive integer indicating the time interval (in seconds) to trigger a purge. *keyPurgeFreqInSecond* is effective only when *keyColumn* is specified.\n\nFor each data ingestion, the engine starts a purge if all of the following conditions are satisfied:\n\n(1) The time elapsed since the last data ingestion is equal to or greater than *keyPurgeFreqInSecond* (For the first check, the time elapsed between the ingestion of data and the creation of the engine is used);\n\n(2) If the first condition is satisfied, the engine applies *keyPurgeFilter* to the cached data to get the data to be purged.\n\n(3) The number of groups which contain data to be purged is equal to or greater than 10% of the total number of groups in the engine.\n\nTo check the engine status before and after the purge, call `getStreamEngineStat().ReactiveStreamEngine` (see [getStreamEngineStat](https://docs.dolphindb.com/en/Functions/g/getStreamEngineStat.html)) where the *numGroups* field indicates the number of groups in the reactive state streaming engine.\n\n**keyCapacity** (optional) is a positive integer indicating the amount of memory allocated for buffering state of each group (defined by *keyColumn*) on a row basis. The default value is 1024. For data with large amount of groups, setting of this parameter can reduce the latency that may occur.\n\n**parallelism** (optional) is a positive integer no greater than 63, indicating the maximum number of workers that can run in parallel. The default value is 1. For large computation workloads, reasonable adjustment of this parameter can effectively utilize computing resources and reduce computation time.\n\n**Note**: *parallelism* cannot exceed the lesser of the numbers of licensed cores and logical cores minus one.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", 1000:0, `date`time`sym`market`price`qty, [DATE, TIME, SYMBOL, CHAR, DOUBLE, INT])\n.reactiveStateEngine(metrics=, keyColumn=[\"date\",\"sym\"], filter=, keepOrder=true)\n.sink(\"output\")\ng.submit()\ngo\n\nn=100\ntmp = table(rand(2012.01.01..2012.01.10, n) as date, rand(09:00:00.000..15:59:59.999, n) as time, rand(\"A\"+string(1..10), n) as sym, rand(['B', 'S'], n) as market, rand(100.0, n) as price, rand(1000..2000, n) as qty)\n\nappendOrcaStreamTable(\"trades\", tmp)\n```\n" }, "DStream::reactiveStatelessEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_reactiveStatelessEngine.html", "signatures": [ { "full": "DStream::reactiveStatelessEngine(metrics)", "name": "DStream::reactiveStatelessEngine", "parameters": [ { "full": "metrics", "name": "metrics" } ] } ], "markdown": "### [DStream::reactiveStatelessEngine](https://docs.dolphindb.com/en/Functions/d/DStream_reactiveStatelessEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::reactiveStatelessEngine(metrics)\n\n#### Details\n\nCreates a reactive stateless engine. For details, see [createReactiveStatelessEngine](https://docs.dolphindb.com/en/Functions/c/createReactiveStatelessEngine.html).\n\n#### Parameters\n\n**metrics** is a vector of dictionaries, specifying the calculation formulas and their dependencies. Each dictionary has the following key-value pairs:\n\n* \"outputName\"->productName:metricName\n\n* \"formula\"->\\\n\n The value of *formula*is a metacode expression defining the formula for calculation, which can reference other variables. For example, the expression can be ``, and A and B are precedent variables for this formula.\n\n* Key-value pairs specifying the precedent variable locations used in the *formula*above. For exmaple, for ``, specify:\n\n * \"A\"->productName:metricName\n * \"B\"->productName:metricName\n The *productName*and *metricName*uniquely specify the location of the variable, which can be the input or output table.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\n\ng = createStreamGraph('engine')\n\nmetrics = array(ANY, 0, 0)\nmetric1 = dict(STRING,ANY)\n// product_B:value=product_A:factor1+product_A:factor2+product_B:factor1\nmetric1[\"outputName\"] = `product_B:`value\nmetric1[\"formula\"] = \nmetric1[\"A\"] = `product_A:`factor1\nmetric1[\"B\"] = `product_A:`factor2\nmetric1[\"C\"] = `product_B:`factor1\nmetrics.append!(metric1)\n// product_C:value=product_B:value*product_C:factor1\nmetric2 = dict(STRING, ANY)\nmetric2[\"outputName\"] =`product_C:`value\nmetric2[\"formula\"] = \nmetric2[\"A\"] = `product_B:`value \nmetric2[\"B\"] = `product_C:`factor1\nmetrics.append!(metric2)\n\ng.source(\"input\", 1000:0, `product`factor`value, [STRING, STRING, DOUBLE])\n.reactiveStatelessEngine(metrics)\n.sink(\"output\")\ng.submit()\ngo\n\nproducts = take(\"product_A\", 2)\nfactors = [\"factor1\", \"factor2\"]\nvalues = [1.0, 2.0]\ntmp = table(products as product, factors as factor, values as value)\nappendOrcaStreamTable(\"input\", tmp)\n\nproducts = take(\"product_B\", 1)\nfactors = take(\"factor1\", 1)\nvalues = take(1.0, 1)\ntmp = table(products as product, factors as factor, values as value)\nappendOrcaStreamTable(\"input\", tmp)\n\n\nselect * from orca_table.output\n```\n\n| productName | metricName | metricsResults |\n| ----------- | ---------- | -------------- |\n| product\\_B | value |   |\n| product\\_C | value |   |\n| product\\_B | value | 4 |\n| product\\_C | value |   |\n" }, "DStream::ruleEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_ruleEngine.html", "signatures": [ { "full": "DStream::ruleEngine(ruleSets, outputColumns, [policy], [ruleSetColumn], [callback])", "name": "DStream::ruleEngine", "parameters": [ { "full": "ruleSets", "name": "ruleSets" }, { "full": "outputColumns", "name": "outputColumns" }, { "full": "[policy]", "name": "policy", "optional": true }, { "full": "[ruleSetColumn]", "name": "ruleSetColumn", "optional": true }, { "full": "[callback]", "name": "callback", "optional": true } ] } ], "markdown": "### [DStream::ruleEngine](https://docs.dolphindb.com/en/Functions/d/DStream_ruleEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::ruleEngine(ruleSets, outputColumns, \\[policy], \\[ruleSetColumn], \\[callback])\n\n#### Details\n\nCreates a rule engine that supports multiple rule sets. For details, see [createRuleEngine](https://docs.dolphindb.com/en/Functions/c/createRuleEngine.html).\n\n#### Parameters\n\n**ruleSets** is a dictionary specifying the rule set. Its key is of STRING or INT type, and the value is a tuple with metacode. If the key is NULL, the rule is treated as the default rule. If *ruleSetColumn* is not specified or the data does not match any rule, the default rule will be used for checking data. A rule set must include a default rule.\n\n**outputColumns** is a STRING vector indicating the input columns to be preserved in the output table.\n\n**policy**(optional) is a STRING scalar indicating the rule-checking policy. It can take the following values:\n\n**ruleSetColumn**(optional) is a STRING scalar indicating an input column name. If it is not set or the specified column does not match any rule set, then the default rule set is applied.\n\n**callback** (optional) is a function that takes a tuple as input. The table contains a record output by the engine. If specified, the callback function is invoked with each output passed in as an argument. If not specified, the engine will only insert the checking results into the output table.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\n// define rule sets\nx = [1, 2, NULL]\ny = [ [ < value > 1 > ], [ < price < 2 >, < price > 6 > ], [ < value*price > 10 > ] ]\nruleSets = dict(x, y)\n\n// create a DFS table to write results to the callback function\nif(existsDatabase(\"dfs://temp\")){\n dropDatabase(\"dfs://temp\")\n}\ndb = database(\"dfs://temp\", VALUE, 1..3)\nt1 = table(1:0, `sym`value`price, [INT,DOUBLE,DOUBLE])\npt = db.createPartitionedTable(t1,`pt,`sym)\n\n// create callback function\ndef writeBack(result){\n if(result.rule[0]==false){\n temp = select sym,value,price from result\n loadTable(\"dfs://temp\",`pt).append!(temp)\n }\n}\n\ng.source(\"trades\", 1000:0, `sym`value`price`quantity, [INT, DOUBLE, DOUBLE, DOUBLE])\n.ruleEngine(ruleSets=ruleSets, outputColumns=[\"sym\",\"value\",\"price\"], policy=\"all\", ruleSetColumn=\"sym\", callback=writeBack)\n.sink(\"output\")\ng.submit()\ngo\n\ntmp=table(1 1 as sym, 0 2 as value, 2 2 as price, 3 3 as quantity)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| sym | value | price | rule |\n| --- | ----- | ----- | -------- |\n| 1 | 0 | 2 | \\[false] |\n| 1 | 2 | 2 | \\[true] |\n" }, "DStream::sessionWindowEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_sessionWindowEngine.html", "signatures": [ { "full": "DStream::sessionWindowEngine(sessionGap, metrics, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useSessionStartTime=true], [forceTriggerTime])", "name": "DStream::sessionWindowEngine", "parameters": [ { "full": "sessionGap", "name": "sessionGap" }, { "full": "metrics", "name": "metrics" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[updateTime]", "name": "updateTime", "optional": true }, { "full": "[useSessionStartTime=true]", "name": "useSessionStartTime", "optional": true, "default": "true" }, { "full": "[forceTriggerTime]", "name": "forceTriggerTime", "optional": true } ] } ], "markdown": "### [DStream::sessionWindowEngine](https://docs.dolphindb.com/en/Functions/d/DStream_sessionWindowEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::sessionWindowEngine(sessionGap, metrics, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useSessionStartTime=true], \\[forceTriggerTime])\n\n#### Details\n\nCreates a session window streaming engine. For details, see [createSessionWindowEngine](https://docs.dolphindb.com/en/Functions/c/createSessionWindowEngine.html).\n\n#### Parameters\n\n**sessionGap** a positive integer indicating the gap between 2 session windows. Its unit is determined by the parameter *useSystemTime*.\n\n**metrics** is metacode or a tuple specifying the calculation formulas. For more information about metacode please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* It can use one or more built-in or user-defined aggregate functions (which must be defined by the `defg` keyword) such as `<[sum(volume), avg(price)]>`, or expressions of aggregate functions such as as `<[avg(price1)-avg(price2)]>`, or aggregate functions involving multiple columns such as `<[std(price1-price2)]>`.\n* You can specify functions that return multiple values for *metrics*, such as `` (it's optional to specify the column names).\n* The metacode can be a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n* If *metrics* is a tuple with multiple formulas, *windowSize* is specified as a vector of the same length as *metrics*. Each element of *windowSize* corresponds to the elements in *metrics*. For example, if *windowSize*=\\[10,20], *metrics* can be `(<[min(volume), max(volume)]>, )`. *metrics* can also input nested tuple vectors, such as `[[<[min(volume), max(volume)]>, ], []]`.\n\n**Note:**\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n* Nested aggregate function calls are not supported in *metrics*.\n\n**timeColumn** (optional) is a STRING scalar or vector specifying the time column(s) of the subscribed stream table. When *useSystemTime* = false, it must be specified.\n\n**useSystemTime** (optional) is a Boolean value indicating whether the calculations are performed based on the system time when data is ingested into the engine.\n\n* *useSystemTime* = true: the engine will regularly window the streaming data at fixed time intervals for calculations according to the ingestion time (local system time with millisecond precision, independent of any temporal columns in the streaming table) of each record. As long as a window contains data, the calculation will be performed automatically when the window ends. The first column in output table indicates the timestamp when the calculation occurred.\n* *useSystemTime* = false (default): the engine will window the streaming data according to the timeColumn in the stream table. The calculation for a window is triggered by the first record after the previous window. Note that the record which triggers the calculation will not participate in this calculation.\n\nFor example, there is a window ranges from 10:10:10 to 10:10:19. If *useSystemTime* = true and the window is not empty, the calculation will be triggered at 10:10:20. If *useSystemTime* = false and the first record after 10:10:19 is at 10:10:25, the calculation will be triggered at 10:10:25.\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the name of the grouping column(s). If it is specified, the engine conducts the calculations within each group. For example, group the data by stock symbol and apply moving aggregation functions to each stock.\n\n**updateTime** (optional) is a non-negative integer which takes the same time precision as *timeColumn*. It is used to trigger window calculations at an interval shorter than *step*. *step* must be a multiple of *updateTime*. To specify *updateTime*, *useSystemTime* must be set to false.\n\n**useSessionStartTime** (optional) is a Boolean value. Defaults to true indicating whether the first column in *outputTable* is the starting time of the windows, i.e., the timestamp of the first record in each window. Setting it to false means the timestamps in the output table are the ending time of the windows, i.e., timestamp of the last record in window + *sessionGap*. If *updateTime* is specified, *useSessionStartTime* must be true.\n\n**forceTriggerTime** (optional) is a non-negative integer. Its unit is the same as the time precision of *timeColumn*. *forceTriggerTime* indicates the waiting time to force trigger calculation in uncalculated windows for each group.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", 1000:0, `time`sym`volume, [TIMESTAMP, SYMBOL, INT])\n.sessionWindowEngine(sessionGap = 5, metrics = , timeColumn = `time, keyColumn=`sym)\n.sink(\"output\")\ng.submit()\ngo\n\nn = 5\ntime = 2018.10.12T10:01:00.000 + (1..n)\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nn = 5\ntime = 2018.10.12T10:01:00.010 + (1..n)\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nn = 6\ntime = 2018.10.12T10:01:00.020 + 1 2 3 8 14 20\nsym = take(`A`B`C, n)\nvolume = (1..n) % 1000\ntmp = table(time as time, sym as sym, volume as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| time | sym | volume |\n| ----------------------- | --- | ------ |\n| 2018.10.12 10:01:00.001 | A | 5 |\n| 2018.10.12 10:01:00.002 | B | 7 |\n| 2018.10.12 10:01:00.003 | C | 3 |\n| 2018.10.12 10:01:00.011 | A | 5 |\n| 2018.10.12 10:01:00.012 | B | 7 |\n| 2018.10.12 10:01:00.013 | C | 3 |\n| 2018.10.12 10:01:00.021 | A | 1 |\n| 2018.10.12 10:01:00.022 | B | 2 |\n| 2018.10.12 10:01:00.023 | C | 3 |\n" }, "DStream::setEngineName": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_setEngineName.html", "signatures": [ { "full": "DStream::setEngineName(name)", "name": "DStream::setEngineName", "parameters": [ { "full": "name", "name": "name" } ] } ], "markdown": "### [DStream::setEngineName](https://docs.dolphindb.com/en/Functions/d/DStream_setEngineName.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::setEngineName(name)\n\n#### Details\n\nSets a name for the current streaming engine. If an engine with the same name already exists, an exception will be thrown.\n\n#### Parameters\n\n**name** is a string representing the name of the streaming egine. You can provide either the fully qualified name (FQN), such as \"catalog\\_name.orca\\_engine.engine\\_name\", or just the engine name, like \"engine\\_name\". If only the name is given, the system will automatically complete it using the current catalog.\n\n#### Returns\n\nA streaming engine object.\n" }, "DStream::sharedDict": { "url": "https://docs.dolphindb.com/en/Functions/d/dstream_shareddict.html", "signatures": [ { "full": "DStream::sharedDict(name, keyObj, valueObj, [ordered=false])", "name": "DStream::sharedDict", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyObj", "name": "keyObj" }, { "full": "valueObj", "name": "valueObj" }, { "full": "[ordered=false]", "name": "ordered", "optional": true, "default": "false" } ] }, { "full": "DStream::sharedDict(name, keyType, valueType, [ordered=false])", "name": "DStream::sharedDict", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyType", "name": "keyType" }, { "full": "valueType", "name": "valueType" }, { "full": "[ordered=false]", "name": "ordered", "optional": true, "default": "false" } ] } ], "markdown": "### [DStream::sharedDict](https://docs.dolphindb.com/en/Functions/d/dstream_shareddict.html)\n\n\n\n#### Syntax\n\nDStream::sharedDict(name, keyObj, valueObj, \\[ordered=false])\n\nor\n\nDStream::sharedDict(name, keyType, valueType, \\[ordered=false])\n\n#### Details\n\nCreates a shared dictionary in Orca, which is only usable within `DStream::udfEngine`. For details about dictionaries, refer to [dict](https://docs.dolphindb.com/en/Functions/d/dict.html).\n\n#### Parameters\n\n**name** is a STRING scalar indicating the shared dictionary name.\n\nFor the first usage:\n\n**keyObj** is a vector indicating dictionary keys.\n\n**valueObj** is a vector indicating dictionary values.\n\nFor the second usage:\n\n**keyType** is the data type of dictionary keys. The following data categories are supported: Integral (excluding COMPRESSED), Temporal, Floating and Literal.\n\n**valueType** is the data type of dictionary values. Note that COMPLEX/POINT/DECIMAL is not supported.\n\n**ordered** (optional) is a Boolean value. The default value is false, which indicates to create a regular dictionary. True means to create an ordered dictionary. The regular dictionaries do not track the insertion order of the key-value pairs whereas the ordered dictionaries preserve the insertion order of key-value pairs.\n\n#### Returns\n\nA dictionary.\n\n#### Examples\n\nIn this example, we use `DStream::sharedDict` and `DStream::udfEngine` to implement a count-based conditional alerting mechanism. The `DStream::sharedDict` is used to track the occurrence count of each key, and when the count for a key exceeds a predefined threshold, an alert message is sent downstream.\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// Create stream graph\ng = createStreamGraph(\"counter\")\ng.sharedDict(\"counts\", STRING, LONG)\ng.source(\"items\", [\"key\"], [STRING])\n .udfEngine(def(msg) {\n counts = orcaObj(\"counts\")\n triggered = table(100:0, `key`count, [STRING, LONG])\n for(i in 0:msg.size()) {\n keyVal = msg.key[i]\n // Read current count\n current = 0\n if (keyVal in counts) {\n current = counts[keyVal]\n }\n newCount = current + 1\n // Update count\n counts[keyVal] = newCount\n // Check if threshold is triggered\n if(newCount >= 3) {\n triggered.append!(table(keyVal as key, newCount as count))\n }\n }\n return triggered\n })\n .sink(\"alerts\")\ng.submit()\ngo\n// Generate mock data\nkeys = [\"A\", \"B\", \"A\", \"C\", \"B\", \"A\", \"B\", \"B\", \"C\", \"C\"]\nmockData1 = table(take(keys[0:3], 3) as key)\nmockData2 = table(take(keys[3:6], 3) as key)\nmockData3 = table(take(keys[6:10], 4) as key)\n// Insert data\nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData1)\nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData2) \nappendOrcaStreamTable(\"orcaCatalog.orca_table.items\", mockData3)\n// Wait for processing and inspect results\nsleep(1000)\nselect * from orcaCatalog.orca_table.alerts;\n```\n\n| key | count |\n| --- | ----- |\n| A | 3 |\n| B | 3 |\n| B | 4 |\n| C | 3 |\n" }, "DStream::sharedKeyedTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dstream_sharedkeyedtable.html", "signatures": [ { "full": "DStream::sharedKeyedTable(name, keyColumns, X, [X1], [X2], .....)", "name": "DStream::sharedKeyedTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumns", "name": "keyColumns" }, { "full": "X", "name": "X" }, { "full": "[X1]", "name": "X1", "optional": true }, { "full": "[X2]", "name": "X2", "optional": true }, { "full": ".....", "name": "....." } ] }, { "full": "DStream::sharedKeyedTable(name, keyColumns, capacity:size, colNames, colTypes)", "name": "DStream::sharedKeyedTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumns", "name": "keyColumns" }, { "full": "capacity:size", "name": "capacity:size" }, { "full": "colNames", "name": "colNames" }, { "full": "colTypes", "name": "colTypes" } ] }, { "full": "DStream::sharedKeyedTable(name, keyColumns, table)", "name": "DStream::sharedKeyedTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "keyColumns", "name": "keyColumns" }, { "full": "table", "name": "table" } ] } ], "markdown": "### [DStream::sharedKeyedTable](https://docs.dolphindb.com/en/Functions/d/dstream_sharedkeyedtable.html)\n\n\n\n#### Syntax\n\nDStream::sharedKeyedTable(name, keyColumns, X, \\[X1], \\[X2], .....)\n\nor\n\nDStream::sharedKeyedTable(name, keyColumns, capacity:size, colNames, colTypes)\n\nor\n\nDStream::sharedKeyedTable(name, keyColumns, table)\n\n#### Details\n\nCreates a shared keyed table in Orca, which is only usable within `DStream::udfEngine`. For details about keyed tables, refer to [keyedTable](https://docs.dolphindb.com/en/Functions/k/keyedTable.html).\n\n#### Parameters\n\n**name** is a STRING scalar indicating the shared keyed table name.\n\n**keyColumn** is a string scalar or vector indicating the name(s) of the primary key column(s). The column type must be INTEGRAL, TEMPORAL or LITERAL.\n\nFor the first scenario: **X**, **X1**, **X2** ... can be vectors, matrices or tuples. Each vector, each matrix column and each tuple element must have the same length. **When \\_Xk\\_is a tuple:**\n\n* If the elements of *Xk*are vectors of equal length, each element of the tuple will be treated as a column in the table.\n* If *Xk*contains elements of different types or unequal lengths, it will be treated as a single column in the table (with the column type set to ANY), and each element will correspond to the value of that column in each row.\n\nFor the second scenario:\n\n* **capacity** is a positive integer indicating the amount of memory (in terms of the number of rows) allocated to the table. When the number of rows exceeds capacity, the system will first allocate memory of 1.2\\~2 times of capacity, copy the data to the new memory space, and release the original memory. For large tables, these steps may use significant amount of memory.\n\n* **size** is an integer no less than 0 indicating the initial size (in terms of the number of rows) of the table. If *size*=0, create an empty table; If *size*>0, the initialized values are:\n * false for Boolean type;\n * 0 for numeric, temporal, IPADDR, COMPLEX, and POINT types;\n * Null value for Literal, INT128 types.\n\n* **Note:** If *colTypes* is an array vector, *size* must be 0.\n\n* **colNames** is a STRING vector of column names.\n\n* **colTypes** is a string vector of data types. The non-key columns can be specified as an array vector type or ANY type.\n\nFor the third scenario, **table** is a table. Please note that *keyColumns* in *table* cannot have duplicate values.\n\n#### Returns\n\nA keyed table.\n\n#### Examples\n\nIn this example, we use `DStream::sharedKeyedTable` and `DStream::udfEngine` to implement a historical delta computation.\n\nThe `DStream::sharedKeyedTable` is used to maintain the most recent record for each ID. When a new record arrives, if an entry with the same id already exists in the table, the UDF outputs the difference between the new value and the previously stored (historical) value. If the ID does not exist, the new record is inserted into the table without producing any output.\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// Create stream graph\ng = createStreamGraph(\"compare\")\ng.sharedKeyedTable(\"history\", \"id\", 1:0, `id`value, [INT, DOUBLE])\ng.source(\"data\", `id`value`time, [INT, DOUBLE, TIMESTAMP])\n .udfEngine(def(msg) {\n history = orcaObj(\"history\")\n diffTable = table(100:0, `id`diff, [INT, DOUBLE])\n for(i in 0:msg.size()) {\n idVal = msg.id[i]\n valueVal = msg.value[i]\n // Read historical value\n old = select value from history where id = idVal\n // Write new value\n newRow = table(idVal as id, valueVal as value)\n history.append!(newRow)\n // Compute delta\n if(old.size() > 0) {\n diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))\n }\n }\n return diffTable\n })\n .sink(\"comparison\")\ng.submit()\n// Generate mock data\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// Insert data\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// Generate data with duplicate IDs\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// Insert data\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// Wait for processing and inspect results\nsleep(1000)\nselect * from orcaCatalog.orca_table.comparison\n```\n\n| id | diff |\n| -- | ------------------- |\n| 1 | 35.55946895749296 |\n| 2 | -3.4362593906550387 |\n| 3 | 36.283468999034596 |\n| 4 | 68.97968558337999 |\n| 5 | -91.64246928217878 |\n" }, "DStream::sharedTable": { "url": "https://docs.dolphindb.com/en/Functions/d/dstream_sharedtable.html", "signatures": [ { "full": "DStream::sharedTable(name, X, [X1], [X2], .....)", "name": "DStream::sharedTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "X", "name": "X" }, { "full": "[X1]", "name": "X1", "optional": true }, { "full": "[X2]", "name": "X2", "optional": true }, { "full": ".....", "name": "....." } ] }, { "full": "DStream::sharedTable(name, capacity:size, colNames, colTypes)", "name": "DStream::sharedTable", "parameters": [ { "full": "name", "name": "name" }, { "full": "capacity:size", "name": "capacity:size" }, { "full": "colNames", "name": "colNames" }, { "full": "colTypes", "name": "colTypes" } ] } ], "markdown": "### [DStream::sharedTable](https://docs.dolphindb.com/en/Functions/d/dstream_sharedtable.html)\n\n\n\n#### Syntax\n\nDStream::sharedTable(name, X, \\[X1], \\[X2], .....)\n\nor\n\nDStream::sharedTable(name, capacity:size, colNames, colTypes)\n\n#### Details\n\nCreates a shared table in Orca, which is only usable within `DStream::udfEngine`. For details about table s, refer to [table](https://docs.dolphindb.com/en/Functions/t/table.html).\n\n#### Parameters\n\n**name** is a STRING scalar indicating the shared table name.\n\nFor the first scenario: **X**, **X1**, **X2** ... can be vectors, matrices or tuples. Each vector, each matrix column and each tuple element must have the same length. **When \\_Xk\\_is a tuple:**\n\n* If the elements of *Xk*are vectors of equal length, each element of the tuple will be treated as a column in the table.\n* If *Xk*contains elements of different types or unequal lengths, it will be treated as a single column in the table (with the column type set to ANY), and each element will correspond to the value of that column in each row.\n\nFor the second scenario:\n\n* **capacity** is a positive integer indicating the amount of memory (in terms of the number of rows) allocated to the table. When the number of rows exceeds capacity, the system will first allocate memory of 1.2\\~2 times of capacity, copy the data to the new memory space, and release the original memory. For large tables, these steps may use significant amount of memory.\n\n* **size** is an integer no less than 0 indicating the initial size (in terms of the number of rows) of the table. If *size*=0, create an empty table; If *size*>0, the initialized values are:\n\n * false for Boolean type;\n\n * 0 for numeric, temporal, IPADDR, COMPLEX, and POINT types;\n\n * Null value for Literal, INT128 types.\n\n **Note:** If *colTypes* is an array vector, *size* must be 0.\n\n* **colNames** is a STRING vector of column names.\n\n* **colTypes** is a STRING vector of data types. It can use either the reserved words for data types or corresponding strings.\n\n#### Returns\n\nA table.\n\n#### Examples\n\nIn this example, we use`DStream::sharedTable` and `DStream::udfEngine` to implement real-time computation and output of the current average. The `DStream::sharedTable` stores all previously computed average values. Each time new data is processed, the UDF recalculates the average based on the latest data, appends the result to the `DStream::sharedTable`, and outputs only the most recent row—i.e., the latest computed average—to the downstream.\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n\n// Create stream graph\ng = createStreamGraph(\"avgCalc\")\ng.sharedTable(\"stats\", 1:0, `sum`count, [DOUBLE, LONG])\n\ng.source(\"numbers\", [\"value\"], [DOUBLE])\n .udfEngine(def(msg) {\n stats = orcaObj(\"stats\")\n \n // Read historical value\n if(stats.size() > 0) {\n lastSum = exec last(sum) from stats\n lastCount = exec last(count) from stats\n } else {\n lastSum = 0.0\n lastCount = 0\n }\n \n // Compute new value\n newSum = lastSum + sum(msg.value)\n newCount = lastCount + msg.size()\n if (newCount > 0) {\n avgValue = newSum / newCount\n } else {\n avgValue = 0.0\n }\n \n // Write new value\n newRow = table(newSum as sum, newCount as count)\n stats.append!(newRow)\n \n // Return the result\n return table(newSum as total, newCount as count, avgValue as avg)\n })\n .sink(\"output\")\n\ng.submit()\n\n// Generate mock data\nmockData1 = table(rand(10.0, 3) as value)\nmockData2 = table(rand(10.0, 5) as value)\nmockData3 = table(rand(10.0, 2) as value)\n\n// Insert data, wait for processing and inspect results\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData1)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData2)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\nappendOrcaStreamTable(\"orcaCatalog.orca_table.numbers\", mockData3)\nselect * from orcaCatalog.orca_table.numbers;\nselect * from orcaCatalog.orca_table.output;\n```\n" }, "DStream::sink": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_sink.html", "signatures": [ { "full": "DStream::sink(dest|name, [asyncWrite=true], [compress=true], [cacheSize], [retentionMinutes=1440], [flushMode=0], [cachePurgeTimeColumn], [cachePurgeInterval], [cacheRetentionTime])", "name": "DStream::sink", "parameters": [ { "full": "dest|name", "name": "dest|name" }, { "full": "[asyncWrite=true]", "name": "asyncWrite", "optional": true, "default": "true" }, { "full": "[compress=true]", "name": "compress", "optional": true, "default": "true" }, { "full": "[cacheSize]", "name": "cacheSize", "optional": true }, { "full": "[retentionMinutes=1440]", "name": "retentionMinutes", "optional": true, "default": "1440" }, { "full": "[flushMode=0]", "name": "flushMode", "optional": true, "default": "0" }, { "full": "[cachePurgeTimeColumn]", "name": "cachePurgeTimeColumn", "optional": true }, { "full": "[cachePurgeInterval]", "name": "cachePurgeInterval", "optional": true }, { "full": "[cacheRetentionTime]", "name": "cacheRetentionTime", "optional": true } ] } ], "markdown": "### [DStream::sink](https://docs.dolphindb.com/en/Functions/d/DStream_sink.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::sink(dest|name, \\[asyncWrite=true], \\[compress=true], \\[cacheSize], \\[retentionMinutes=1440], \\[flushMode=0], \\[cachePurgeTimeColumn], \\[cachePurgeInterval], \\[cacheRetentionTime])\n\n#### Details\n\nOutputs the stream data to a persisted and shared stream table, a DFS table, or a function.\n\nIn Orca, the `sink` interface is the terminal node in the declarative API (DStream API). It is used to define the output destination of a streaming graph, writing stream data into a persistent shared stream table, a DFS table, or a function.\n\nWhen the sink target is a stream table, if the table does not already exist, it will be automatically created on the first write based on the structure of the input data, and schema inference will be performed.\n\nFor subsequent sink operations targeting the same stream table, the schema must remain consistent; otherwise, the system will throw a schema conflict error.\n\nFor more information on table persistence, refer to the [enableTableShareAndPersistence](https://docs.dolphindb.com/en/Functions/e/enableTableShareAndPersistence.html) documentation.\n\n#### Parameters\n\n**dest | name** The destination for the output stream, which can be:\n\n* A string specifying the fully qualified name of the target stream table or DFS table (e.g., \"trading.orca\\_table.factors\", \"trading.dbName.tableName\") or the DFS table path (e.g., \"dfs\\://dbName/tableName\").\n* A unary function that takes the stream table as input, whose return value will be ignored.\n\n**asyncWrite** (optional) is a Boolean value indicating whether persistence is enabled in asynchronous mode. The default value is true, meaning asynchronous persistence is enabled. In this case, once data is written into memory, the write is deemed complete. The data stored in memory is then persisted to disk by another thread.\n\n**compress** (optional) is a Boolean value indicating whether to save a table to disk in compression mode. The default value is true.\n\n**cacheSize** (optional) is an integer used to determine the maximum number of records to retain in memory. If set to 0 or not specified, all records will be retained. Any positive integer smaller than 1000 will automatically be adjusted to 1000.\n\n**retentionMinutes** (optional) is an integer indicating for how long (in minutes) a log file larger than 1GB will be kept after last update. The default value is 1440, which means the log file is kept for 1440 minutes, i.e., 1 day.\n\n**flushMode** (optional) is an integer indicating whether to enable synchronous disk flush. It can be 0 or 1. The persistence process first writes data from memory to the page cache, then flushes the cached data to disk. If *flushMode* is 0 (default), asynchronous disk flushing is enabled. In this case, once data is written from memory to the page cache, the flush is deemed complete and the next batch of data can be written to the table. If *flushMode* is set to 1, the current batch of data must be flushed to disk before the next batch can be written.\n\n**preCache** (optional) is an integer indicating the number of records to be loaded into memory from the persisted stream table on disk when DolphinDB restarts. If it is not specified, all records are loaded into memory when DolphinDB restarts.\n\n**cachePurgeTimeColumn** (optional) is a STRING scalar indicating the time column in the stream table.\n\n**cachePurgeInterval** (optional) is a DURATION scalar indicating the interval to trigger cache purge.\n\n**cacheRetentionTime** (optional) is a DURATION scalar indicating the retention time of cached data. Note: Since version 3.00.2/2.00.14, *cacheRetentionTime* must be smaller than *cachePurgeInterval*.\n\n#### Returns\n\nA DStream object.\n" }, "DStream::snapshotJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_snapshotJoinEngine.html", "signatures": [ { "full": "DStream::snapshotJoinEngine(rightStream, metrics, matchingColumn, [timeColumn], [keepLeftDuplicates=false], [keepRightDuplicates=false], [isInnerJoin=true])", "name": "DStream::snapshotJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[keepLeftDuplicates=false]", "name": "keepLeftDuplicates", "optional": true, "default": "false" }, { "full": "[keepRightDuplicates=false]", "name": "keepRightDuplicates", "optional": true, "default": "false" }, { "full": "[isInnerJoin=true]", "name": "isInnerJoin", "optional": true, "default": "true" } ] } ], "markdown": "### [DStream::snapshotJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_snapshotJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::snapshotJoinEngine(rightStream, metrics, matchingColumn, \\[timeColumn], \\[keepLeftDuplicates=false], \\[keepRightDuplicates=false], \\[isInnerJoin=true])\n\n#### Details\n\nCreates a snapshot join streaming engine. For details, see [createSnapshotJoinEngine](https://docs.dolphindb.com/en/Functions/c/createSnapshotJoinEngine.html).\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**metrics** is metacode (can be a tuple) specifying the calculation formulas. For more information about metacode, refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/metaprogramming.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (but not aggregate functions).\n* *metrics* can be functions that return multiple values and the columns in the output table to hold the return values must be specified. For example, ``.\n\nTo specify a column that exists in both the left and the right tables, use the format *tableName.colName*. By default, the column from the left table is used.\n\n**Note:** The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\n**matchingColumn** is a STRING scalar/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the columns to match are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If both tables share the names of all columns to match, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then *matchingColumn* = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]].\n\n**timeColumn** (optional) is a STRING scalar/vector indicating the name of the time column in the left table and the right table. The time columns must have the same data type. If the names of the time column in the left table and the right table are the same, *timeColumn* is a string. Otherwise, it is a vector of 2 strings indicating the time column in each table.\n\n**keepLeftDuplicates** (optional) is a Boolean value indicating whether to match all records in each group of the left table. When set to false (default), the engine matches only the latest record in each group. When set to true, the engine matches all records in each group.\n\n**keepRightDuplicates** (optional) is a Boolean value indicating whether to match all records in each group of the right table. When set to false (default), the engine matches the latest record in each group. When set to true, the engine matches all records in each group.\n\n**isInnerJoin** (optional) is a Boolean value to determine whether an inner join or full outer join is performed.\n\n* If *isInnerJoin*=true (default), an inner join is performed. Results are only generated when matches are found between both tables.\n* If *isInnerJoin*=false, an outer join is performed. Results are generated whether or not a match is found. If there are unmatched records, entries from the other table are null padded.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('joinEngine')\n\ng = createStreamGraph('joinEngine')\nr = g.source(\"right\", 1024:0, `timestamp`sym2`id`price`qty, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\ng.source(\"left\", 1024:0, `timestamp`sym1`id`price`val, [TIMESTAMP, SYMBOL, INT, DOUBLE, DOUBLE])\n .snapshotJoinEngine(r, metrics=[, ], matchingColumn = [[\"id\",\"sym1\"],[\"id\",\"sym2\"]], \ntimeColumn = `timestamp, isInnerJoin=true, keepLeftDuplicates=true,keepRightDuplicates=true)\n .sink(\"output\")\ng.submit()\ngo\n\ntimestamp = 2024.10.10T15:12:01.507+1..10\nsym = take([\"a\",\"b\",\"c\",\"d\"],10)\nid = [1,1,2,1,5,2,4,4,1,4]\nprice = [2.53,7.61,8.07,7.87,7.29,9.39,5.98,9.49,9.20,9.17]\nval = [101,108,101,109,104,100,108,100,107,104]\ntmp1 = table(timestamp as timestamp,sym as sym1,id as id,price as price,val as val)\nappendOrcaStreamTable(\"left\", tmp1)\n\nid = [1,2,4,3,5,5,4,2,5,5]\nprice = [1.08,9.08,9.97,7.60,1.91,6.77,7.81,8.81,0.61,5.92]\nqty = [208,200,203,202,204,201,206,207,205,205]\ntmp2 = table(timestamp as timestamp,sym as sym2,id as id,price as price,qty as qty)\nappendOrcaStreamTable(\"right\", tmp2)\n\nselect * from orca_table.output\n```\n\n| id | sym1 | timestamp | right\\_timestamp | val\\_mul | qty |\n| -- | ---- | ----------------------- | ----------------------- | -------- | --- |\n| 0 | a | 2024.10.10 15:12:01.508 | 2024.10.10 15:12:01.508 | 1,010 | 208 |\n| 1 | a | 2024.10.10 15:12:01.512 | 2024.10.10 15:12:01.512 | 1,040 | 204 |\n| 2 | a | 2024.10.10 15:12:01.512 | 2024.10.10 15:12:01.516 | 1,040 | 205 |\n| 3 | b | 2024.10.10 15:12:01.513 | 2024.10.10 15:12:01.509 | 1,000 | 200 |\n| 4 | c | 2024.10.10 15:12:01.514 | 2024.10.10 15:12:01.510 | 1,080 | 203 |\n| 5 | c | 2024.10.10 15:12:01.514 | 2024.10.10 15:12:01.514 | 1,080 | 206 |\n| 6 | a | 2024.10.10 15:12:01.516 | 2024.10.10 15:12:01.508 | 1,070 | 208 |\n" }, "DStream::sparseReactiveStateEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_SparseReactiveStateEngine.html", "signatures": [ { "full": "DStream::sparseReactiveStateEngine(metrics, keyColumn, [extraColumn])", "name": "DStream::sparseReactiveStateEngine", "parameters": [ { "full": "metrics", "name": "metrics" }, { "full": "keyColumn", "name": "keyColumn" }, { "full": "[extraColumn]", "name": "extraColumn", "optional": true } ] } ], "markdown": "### [DStream::sparseReactiveStateEngine](https://docs.dolphindb.com/en/Functions/d/DStream_SparseReactiveStateEngine.html)\n\nFirst introduced in version: 3.00.5\n\n\n\n#### Syntax\n\nDStream::sparseReactiveStateEngine(metrics, keyColumn, \\[extraColumn])\n\n#### Details\n\nCreates a sparse reactive state engine for sparse state computation. For details, see [createSparseReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createSparseReactiveStateEngine.html).\n\n#### Parameters\n\n**metrics** is a table representing the set of sparse state computation rules. It must contain at least 3 columns: `keyColumn(s), formula, outputMetricKey`.\n\n* The first N columns are input metric identifier columns. Their count and order must match those specified by *keyColumn*. Each row provides some values of *keyColumn* in the input table (e.g., if the input table identifies metrics by `deviceID`, values can be `\"A001\"`, `\"R131\"`, etc.).\n* **formula** is a STRING scalar/vector or metacode representing the computation expression for the metric. Variable names in the expression correspond to value columns in the input table (e.g., `metricValue`; also multi-value columns such as `Value1`, `Value2`).\n* **outputMetricKey** is a STRING scalar/vector indicating the new output metric name (must be unique), e.g., `\"A001_event_B\"`.\n\n**Notes**: In Orca, the formula column with user-defined functions supports only metacode in `<>` format.\n\n**keyColumn** is a STRING scalar/vector indicating the primary key column names of the input table (used to identify “which metric/device the current row belongs to”). If *keyColumn* has N columns, *metrics* must have N corresponding leading identifier columns.\n\n**extraColumn** (optional) is a STRING scalar/vector indicating the column names in the input table that should be carried to the output table unchanged (e.g., time columns).\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\n// Create a catalog if it does not exist\nif (!existsCatalog(\"orca\")) { \n createCatalog(\"orca\") \n} \ngo \nuse catalog orca \n \n// If a stream graph with the same name already exists, destroy it first\n// dropStreamGraph(\"sparseGraph\")\ng = createStreamGraph(\"sparseGraph\")\n\n// Define the schema of inputTable and outputTable, as well as the SparseReactiveStateEngine\n\nbaseStream = g.source(\"trade\", `timestamp`date`deviceId1`deviceId2`deviceId3`value1`value2`value3, [TIMESTAMP, DATE, STRING, STRING, STRING, DOUBLE, DOUBLE, DOUBLE])\nformulas = [, , , , , , , , , , , ]\nkeys = \"A\"+string(1..size(formulas))\nkeys1 = keys.shuffle()\nkeys2 = keys.shuffle()\noutKeys = \"event\"+string(1..size(formulas))\nmetrics = table(\n keys1 as deviceId1,\n keys2 as deviceId2,\n formulas as formula,\n outKeys as outputMetricKey\n)\nbaseStream.sparseReactiveStateEngine(metrics, `deviceId1`deviceId2, `timestamp`date)\n.setEngineName(\"srsEngine\")\n.sink(\"output\")\ng.submit()\ngo\n\n\n// Append data and view the ouput\nn = 10000\nfor(i in 1..5){\n data = table(rand(timestamp(1..1000), n) as timestamp, rand(date(1..1000), n) as date, rand(keys, n) as deviceId1, rand(keys, n) as deviceId2, take(keys, n) as deviceId3, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value1, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value2, rand(rand(-1000.0:1000.0, n) join take(double(), n/5), n) as value3)\n appendOrcaStreamTable(\"trade\", data)\n}\nsleep(3000)\nres = select * from orca_table.output\n```\n\n**Related function**: [createSparseReactiveStateEngine](https://docs.dolphindb.com/en/Functions/c/createSparseReactiveStateEngine.html)\n" }, "DStream::sync": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_sync.html", "signatures": [ { "full": "DStream::sync()", "name": "DStream::sync", "parameters": [ { "full": "", "name": "" } ] } ], "markdown": "### [DStream::sync](https://docs.dolphindb.com/en/Functions/d/DStream_sync.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::sync()\n\n#### Details\n\nWaits for all parallel tasks to complete before proceeding with downstream operations. Typically used to synchronize and merge parallel processing branches.\n\nNote: The `DStream::parallelize` and `DStream::sync` methods must be called together.\n\n#### Parameters\n\nNone\n\n#### Examples\n\nPartition the stream data into four streams based on the symbol column for downstream calculations:\n\n```\nuse catalog test\n\ng = createStreamGraph(name)\ng.source(\"trade\", 1024:0, `symbol`datetime`price`volume, [SYMBOL, TIMESTAMP,DOUBLE, INT])\n .parallelize(\"symbol\", 4)\n .timeSeriesEngine(60*1000, 60*1000, <[first(price),max(price),min(price),last(price),sum(volume)]>, \"datetime\", false, \"symbol\")\n .reactiveStateEngine(<[datetime, first_price, max_price, min_price, last_price, sum_volume, mmax(max_price, 5), mavg(sum_volume, 5)]>, `symbol)\n .sync()\n .sink(\"output\")\n.g.submit()\n```\n" }, "DStream::timeBucketEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_timeBucketEngine.html", "signatures": [ { "full": "DStream::timeBucketEngine(timeCutPoints, metrics, timeColumn, [keyColumn], [useWindowStartTime], [closed='left'], [fill='none'], [keyPurgeFreqInSecond=-1], [parallelism=1])", "name": "DStream::timeBucketEngine", "parameters": [ { "full": "timeCutPoints", "name": "timeCutPoints" }, { "full": "metrics", "name": "metrics" }, { "full": "timeColumn", "name": "timeColumn" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[useWindowStartTime]", "name": "useWindowStartTime", "optional": true }, { "full": "[closed='left']", "name": "closed", "optional": true, "default": "'left'" }, { "full": "[fill='none']", "name": "fill", "optional": true, "default": "'none'" }, { "full": "[keyPurgeFreqInSecond=-1]", "name": "keyPurgeFreqInSecond", "optional": true, "default": "-1" }, { "full": "[parallelism=1]", "name": "parallelism", "optional": true, "default": "1" } ] } ], "markdown": "### [DStream::timeBucketEngine](https://docs.dolphindb.com/en/Functions/d/DStream_timeBucketEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::timeBucketEngine(timeCutPoints, metrics, timeColumn, \\[keyColumn], \\[useWindowStartTime], \\[closed='left'], \\[fill='none'], \\[keyPurgeFreqInSecond=-1], \\[parallelism=1])\n\n#### Details\n\nCreates a time-series aggregation engine that processes data in custom time windows. For details, see [createTimeBucketEngine](https://docs.dolphindb.com/en/Functions/c/createTimeBucketEngine.html).\n\n#### Parameters\n\n**timeCutPoints** is a vector of MINUTE or SECOND type defining window boundaries. Each adjacent pair of elements forms a window. Note:\n\n* Must contain no null values.\n* The timestamp precision of *timeCutPoints* must be equal to or coarser than the precision of *timeColumn*.\n* Its precision determines the exact window boundary behavior. For example, minute-precision window \\[09:00, 09:05) excludes data ≥ 09:04:00; second-precision window \\[09:00:00, 09:05:00) excludes data ≥ 09:04:59.\n\n**metrics** is metacode or a tuple specifying the calculation formulas. For more information about metacode please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* It can use one or more built-in or user-defined aggregate functions (which must be defined by the `defg` keyword) such as `<[sum(volume), avg(price)]>`, or expressions of aggregate functions such as as `<[avg(price1)-avg(price2)]>`, or aggregate functions involving multiple columns such as `<[std(price1-price2)]>`.\n* You can specify functions that return multiple values for *metrics*, such as `` (it's optional to specify the column names).\n* The metacode can be a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n* If *metrics* is a tuple with multiple formulas, *windowSize* is specified as a vector of the same length as *metrics*. Each element of *windowSize* corresponds to the elements in *metrics*. For example, if *windowSize*=\\[10,20], *metrics* can be `(<[min(volume), max(volume)]>, )`. *metrics* can also input nested tuple vectors, such as `[[<[min(volume), max(volume)]>, ], []]`.\n\n**Note:**\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n* Nested aggregate function calls are not supported in *metrics*.\n\n**timeColumn** is a STRING scalar or vector specifying the time column(s) of the subscribed stream table.\n\nNote: If *timeColumn* is a vector, it must have a date element (of DATE type) and a time element (of TIME, SECOND or NANOTIME type). In this case, the first column in *outputTable* must take the data type of concatDateTime(date, time).\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the name of the grouping column(s). If it is specified, the engine conducts the calculations within each group. For example, group the data by stock symbol and apply moving aggregation functions to each stock.\n\n**useWindowStartTime** (optional) is a Boolean value indicating whether the time column in *outputTable* is the starting time of the windows. The default value is false, which means the timestamps in the output table are the end time of the windows.\n\n**closed** (optional) is a STRING indicating whether the left or the right boundary is included.\n\n* closed = 'left': left-closed, right-open\n* closed = 'right': left-open, right-closed\n\n**fill** (optional) is a vector/scalar indicating the filling method to deal with an empty window (in a group). It can be:\n\n* 'none': no result\n* 'null': output a null value.\n* 'ffill': output the result in the last window.\n* specific value: output the specified value. Its type should be the same as metrics output's type.\n\n*fill* could be a vector to specify different filling method for each metric. The size of the vector must be consistent with the number of elements specified in *metrics*. The element in vector cannot be 'none'.\n\n**keyPurgeFreqInSec** (optional) is a positive integer indicating the interval (in seconds) to remove groups with no incoming data for a long time. If a group has no incoming data for at least *keyPurgeFreqInSec* seconds after the last time of data purging, it will be removed.\n\nNote: To specify this parameter, parameter *keyColumn* must be specified and parameter *fill* cannot be specified.\n\n**parallelism** (optional) is a positive integer no greater than 63, representing the number of worker threads for parallel computation. The default value is 1. For compute-intensive workloads, adjusting this parameter appropriately can effectively utilize computing resources and reduce computation time. It is recommended to set a value less than the number of CPU cores, normally from 4 to 8.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", 1000:0, `time`sym`price`volume, [TIMESTAMP, SYMBOL, DOUBLE, INT])\n.timeSeriesEngine(windowSize=60000, step=60000, metrics=<[first(price), max(price), min(price), last(price), sum(volume)]>, timeColumn=`time, useSystemTime=false, keyColumn=`sym, useWindowStartTime=false)\n.timeBucketEngine(timeCutPoints=[10:00m, 10:05m, 10:10m, 10:15m], metrics=<[first(first_price), max(max_price), min(min_price), last(last_price), sum(sum_volume)]>, timeColumn=`time, keyColumn=`sym)\n.sink(\"output\")\ng.submit()\ngo\n\ntimes = [2024.10.08T10:01:01.785, 2024.10.08T10:01:02.125, 2024.10.08T10:01:12.457, 2024.10.08T10:03:10.789, 2024.10.08T10:03:12.005, 2024.10.08T10:08:02.236, 2024.10.08T10:08:04.412, 2024.10.08T10:08:05.152, 2024.10.08T10:08:30.021, 2024.10.08T10:10:20.123, 2024.10.08T10:11:02.236, 2024.10.08T10:13:04.412, 2024.10.08T10:15:12.005]\nsyms = [`A, `B, `A, `A, `B, `A, `B, `B, `A, `A, `A, `B, `B]\nprices = [10.83, 21.73, 10.79, 11.81, 22.96, 11.25, 23.03, 23.18, 11.04, 11.85, 11.06, 23.15, 22.06]\nvolumes = [2110, 1600, 2850, 2250, 1980, 2400, 2130, 1900, 2300, 2200, 2200, 1880, 2100]\ntmp = table(times as time, syms as sym, prices as price, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\nselect * from orca_table.output\n```\n\n| time | sym | first\\_first\\_price | max\\_max\\_price | min\\_min\\_price | last\\_last\\_price | sum\\_sum\\_volume |\n| ----------------------- | --- | ------------------- | --------------- | --------------- | ----------------- | ---------------- |\n| 2024.10.08 10:05:00.000 | A | 10.83 | 11.81 | 10.79 | 11.81 | 7,210 |\n| 2024.10.08 10:05:00.000 | B | 21.73 | 22.96 | 21.73 | 22.96 | 3,580 |\n| 2024.10.08 10:10:00.000 | A | 11.25 | 11.25 | 11.04 | 11.04 | 4,700 |\n| 2024.10.08 10:10:00.000 | B | 23.03 | 23.18 | 23.03 | 23.18 | 4,030 |\n| 2024.10.08 10:15:00.000 | B | 23.15 | 23.15 | 23.15 | 23.15 | 1,880 |\n" }, "DStream::timerEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_timerEngine.html", "signatures": [ { "full": "DStream::timerEngine(interval, func, args...)", "name": "DStream::timerEngine", "parameters": [ { "full": "interval", "name": "interval" }, { "full": "func", "name": "func" }, { "full": "args...", "name": "args..." } ] } ], "markdown": "### [DStream::timerEngine](https://docs.dolphindb.com/en/Functions/d/DStream_timerEngine.html)\n\n\n\n#### Syntax\n\nDStream::timerEngine(interval, func, args...)\n\n#### Details\n\nDefine a time-triggered engine to periodically execute *func* at intervals. This job does not block or modify the data flow of the stream graph.\n\n#### Parameters\n\n**interval** An INTEGRAL scalar representing the time interval (in second) between job executions.\n\n**func** A FUNCTIONDEF scalar representing the scheduled job.\n\n**args…** The parameter passed to *func*, used similarly to the *args…* parameter of the remote procedure call function [rpc](https://docs.dolphindb.com/en/Functions/r/rpc.html). Can be omitted when *func* is a parameterless function.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\nSubmit the job:\n\n```\nif (!existsCatalog(\"test\")) {\n\tcreateCatalog(\"test\")\t\n}\ngo\nuse catalog test\n\n// Define the job\ndef myFunc(x,y,z){\n writeLog(x,y,z)\n}\n\n// Define the parameter\na = \"aaa\"\nb = \"bbb\"\nc = \"ccc\"\n\n// Submit the steam graph\ng = createStreamGraph(\"timerEngineDemo\")\ng.source(\"trade\", `id`price, [INT, DOUBLE])\n .timerEngine(3, myFunc, a, b, c)\n .setEngineName(\"myJob\")\n .sink(\"result\")\ng.submit()\n```\n\nStop job execution:\n\n```\nuseOrcaStreamEngine(\"myJob\", stopTimerEngine)\n```\n\nResume job execution:\n\n```\nuseOrcaStreamEngine(\"myJob\", resumeTimerEngine)\n```\n\n**Related functions:**[resumeTimerEngine](https://docs.dolphindb.com/en/Functions/r/resumeTimerEngine.html), [stopTimerEngine](https://docs.dolphindb.com/en/Functions/s/stopTimerEngine.html)\n" }, "DStream::timeSeriesEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_timeSeriesEngine.html", "signatures": [ { "full": "DStream::timeSeriesEngine(windowSize, step, metrics, [timeColumn], [useSystemTime=false], [keyColumn], [updateTime], [useWindowStartTime], [roundTime=true], [fill='none'], [forceTriggerTime], [keyPurgeFreqInSecond=-1], [closed='left'], [subWindow], [parallelism=1], [acceptedDelay=0])", "name": "DStream::timeSeriesEngine", "parameters": [ { "full": "windowSize", "name": "windowSize" }, { "full": "step", "name": "step" }, { "full": "metrics", "name": "metrics" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[keyColumn]", "name": "keyColumn", "optional": true }, { "full": "[updateTime]", "name": "updateTime", "optional": true }, { "full": "[useWindowStartTime]", "name": "useWindowStartTime", "optional": true }, { "full": "[roundTime=true]", "name": "roundTime", "optional": true, "default": "true" }, { "full": "[fill='none']", "name": "fill", "optional": true, "default": "'none'" }, { "full": "[forceTriggerTime]", "name": "forceTriggerTime", "optional": true }, { "full": "[keyPurgeFreqInSecond=-1]", "name": "keyPurgeFreqInSecond", "optional": true, "default": "-1" }, { "full": "[closed='left']", "name": "closed", "optional": true, "default": "'left'" }, { "full": "[subWindow]", "name": "subWindow", "optional": true }, { "full": "[parallelism=1]", "name": "parallelism", "optional": true, "default": "1" }, { "full": "[acceptedDelay=0]", "name": "acceptedDelay", "optional": true, "default": "0" } ] } ], "markdown": "### [DStream::timeSeriesEngine](https://docs.dolphindb.com/en/Functions/d/DStream_timeSeriesEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::timeSeriesEngine(windowSize, step, metrics, \\[timeColumn], \\[useSystemTime=false], \\[keyColumn], \\[updateTime], \\[useWindowStartTime], \\[roundTime=true], \\[fill='none'], \\[forceTriggerTime], \\[keyPurgeFreqInSecond=-1], \\[closed='left'], \\[subWindow], \\[parallelism=1], \\[acceptedDelay=0])\n\n#### Details\n\nCreates a time-series streaming engine. For details, see [createTimeSeriesEngine](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.html).\n\n#### Parameters\n\n**windowSize** is a scalar or vector with positive integers that specifies the size of the windows for calculation.\n\n**step** is a positive integer indicating how much each window moves forward relative to the previous one. Note that step must be divisible by *windowSize*, otherwise an exception will be thrown.\n\n* If *useSystemTime* =true, the unit of *windowSize* and *step* is millisecond.\n* If *useSystemTime* =false, the unit of *windowSize* and *step* is the same as the unit of *timeColumn*.\n\n**metrics** is metacode or a tuple specifying the calculation formulas. For more information about metacode please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* It can use one or more built-in or user-defined aggregate functions (which must be defined by the `defg` keyword) such as `<[sum(volume), avg(price)]>`, or expressions of aggregate functions such as as `<[avg(price1)-avg(price2)]>`, or aggregate functions involving multiple columns such as `<[std(price1-price2)]>`.\n* You can specify functions that return multiple values for *metrics*, such as `` (it's optional to specify the column names).\n* The metacode can be a constant scalar/vector. Note that the output column for a constant vector must be in array vector form.\n* If *metrics* is a tuple with multiple formulas, *windowSize* is specified as a vector of the same length as *metrics*. Each element of *windowSize* corresponds to the elements in *metrics*. For example, if *windowSize*=\\[10,20], *metrics* can be `(<[min(volume), max(volume)]>, )`. *metrics* can also input nested tuple vectors, such as `[[<[min(volume), max(volume)]>, ], []]`.\n\n**Note:**\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n* Nested aggregate function calls are not supported in *metrics*.\n\n**timeColumn** (optional) is a STRING scalar or vector specifying the time column(s) of the subscribed stream table. When *useSystemTime* = false, it must be specified.\n\n**useSystemTime** (optional) is a Boolean value indicating whether the calculations are performed based on the system time when data is ingested into the engine.\n\n* *useSystemTime* = true: the engine will regularly window the streaming data at fixed time intervals for calculations according to the ingestion time (local system time with millisecond precision, independent of any temporal columns in the streaming table) of each record. As long as a window contains data, the calculation will be performed automatically when the window ends. The first column in output table indicates the timestamp when the calculation occurred.\n* *useSystemTime* = false (default): the engine will window the streaming data according to the timeColumn in the stream table. The calculation for a window is triggered by the first record after the previous window. Note that the record which triggers the calculation will not participate in this calculation.\n\nFor example, there is a window ranges from 10:10:10 to 10:10:19. If *useSystemTime* = true and the window is not empty, the calculation will be triggered at 10:10:20. If *useSystemTime* = false and the first record after 10:10:19 is at 10:10:25, the calculation will be triggered at 10:10:25.\n\n**keyColumn** (optional) is a STRING scalar/vector indicating the name of the grouping column(s). If it is specified, the engine conducts the calculations within each group. For example, group the data by stock symbol and apply moving aggregation functions to each stock.\n\n**updateTime** (optional) is a non-negative integer which takes the same time precision as *timeColumn*. It is used to trigger window calculations at an interval shorter than *step*. *step* must be a multiple of *updateTime*. To specify *updateTime*, *useSystemTime* must be set to false.\n\nIf *updateTime* is not specified, calculation for a window will not occur before the window ends. By specifying *updateTime*, you can calculate the values for several times in an window of which calculation hasn't been triggered for a long time.\n\n**useWindowStartTime** (optional) is a Boolean value indicating whether the time column in *outputTable* is the starting time of the windows. The default value is false, which means the timestamps in the output table are the end time of the windows. If the *windowSize* is a vector, *useWindowStartTime* must be false.\n\n**roundTime** (optional) is a Boolean value indicating the method to align the window boundary if the time precision is milliseconds or seconds and step is bigger than one minute. The default value is true indicating the alignment is based on the multi-minute rule (see the [alignment rules](https://docs.dolphindb.com/en/Functions/c/createTimeSeriesEngine.md#)). False means alignment is based on the one-minute rule.\n\n**fill** (optional) is a vector/scalar indicating the filling method to deal with an empty window (in a group). It can be:\n\n* 'none': no result\n* 'null': output a null value.\n* 'ffill': output the result in the last window.\n* specific value: output the specified value. Its type should be the same as metrics output's type.\n\n*fill* could be a vector to specify different filling method for each metric. The size of the vector must be consistent with the number of elements specified in *metrics*. The element in vector cannot be 'none'.\n\n**forceTriggerTime** (optional) is a non-negative integer which takes the same time precision as *timeColumn*, indicating the waiting time to force trigger calculation in the uncalculated windows for each group. If *forceTriggerTime* is set, *useSystemTime* must be false and *updateTime* cannot be specified.\n\nThe rules are as follow:\n\n(1) Suppose the end time of the uncalculated window is t, and an incoming record of another group arrives at t1: when t1-t>=forceTriggerTime, calculation of the window will be triggered.\n\n(2) If no data is ingested into a group after the last window is calculated, and new data continues to ingest into other groups, the specified *fill* parameter can be used to fill results for empty windows of that group. The group's windows will still be output at the latest time point. If parameter *fill* is not specified, no new windows will be generated for that group after the last window has been triggered for computation.\n\nNote the following points when setting *forceTriggerTime* or *updateTime*:\n\n* If *updateTime* is specified, the result of the current window calculation will be updated again when data belonging to the current window still arrives after the calculation is triggered.\n* If *forceTriggerTime* is specified, the incoming data with a timestamp within the current window will be discarded after the calculation is forced to be triggered.\n* If the time specified by `timeColumn` is of type `TIME`, it cannot determine the chronological order of data across different days based on time alone. As a result, forced triggering may fail when data spans multiple days. The time in `timeColumn` needs to include the date.\n\n**keyPurgeFreqInSec** (optional) is a positive integer, measured in seconds. It controls the periodic cleanup of keys corresponding to groups where \"window data is empty,\" in order to prevent excessive memory usage caused by the continuous growth of keys. When this parameter is specified, if the time interval between the current data insertion time and the last cleanup time is greater than or equal to *keyPurgeFreqInSec*, the group with empty window data and its corresponding key will be deleted.\n\nNote: To specify this parameter, parameter *forceTriggerTime* must be specified and parameter *fill* cannot be specified.\n\nYou can check the number of groups in a time-series streaming engine based on the column \"numGroups\" returned by [getStreamEngineStat](https://docs.dolphindb.com/en/Functions/g/getStreamEngineStat.html).\n\n**closed** (optional) is a STRING indicating whether the left or the right boundary is included.\n\n* closed = 'left': left-closed, right-open\n* closed = 'right': left-open, right-closed\n\n**subWindow**(optional)is a pair of integers or DURATION values, indicating the range of the subwindow within the window specified by *windowSize*. If specified, only results calculated within subwindows will be returned and the time column of the output table displays the end time of each subwindow. The calculation of the subwindow will be triggered by the arrival of the next record after the subwindow ends. The boundary of the subwindow is determined by parameter *closed*. When *subWindow* is a pair of integers, it takes the same time precision as *timeColumn*.\n\n**parallelism** (optional) is a positive integer no greater than 63, representing the number of worker threads for parallel computation. The default value is 1. For compute-intensive workloads, adjusting this parameter appropriately can effectively utilize computing resources and reduce computation time. It is recommended to set a value less than the number of CPU cores, normally from 4 to 8.\n\n**acceptedDelay** (optional) is a positive integer specifying the maximum delay for each window to accept data. The default value is 0.\n\n* When *useSystemTime*=true, data received within the *acceptedDelay*time after the window ends will still be considered part of the current window and participate in the computation, and will not be included in the computation of the next window.\n* When *useSystemTime*=false, a window with t as right boundary will wait until a record with a timestamp equal to or later than t + *acceptedDelay* arrives. When such a record arrives, the current window closes and performs a calculation on all records within the window frame. This handles scenarios with out-of-order data.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('engine')\ng = createStreamGraph('engine')\n\ng.source(\"trades\", 1000:0, [\"time\",\"sym\",\"volume\"], [TIMESTAMP, SYMBOL, INT])\n.timeSeriesEngine(windowSize=60000, step=60000, metrics=<[sum(volume)]>, timeColumn=\"time\", useSystemTime=false, keyColumn=\"sym\", useWindowStartTime=false)\n.sink(\"output\")\ng.submit()\ngo\n\ntimes = [2018.10.08T01:01:01.785, 2018.10.08T01:01:02.125, 2018.10.08T01:01:10.263, 2018.10.08T01:01:12.457, 2018.10.08T01:02:10.789, 2018.10.08T01:02:12.005, 2018.10.08T01:02:30.021, 2018.10.08T01:04:02.236, 2018.10.08T01:04:04.412, 2018.10.08T01:04:05.152]\nsyms = [`A, `B, `B, `A, `A, `B, `A, `A, `B, `B]\nvolumes = [10, 26, 14, 28, 15, 9, 10, 29, 32, 23]\n\ntmp = table(times as time, syms as sym, volumes as volume)\nappendOrcaStreamTable(\"trades\", tmp)\n\n\nselect * from orca_table.output\n```\n\n\n
\n\ntime\n\n\n\nsym\n\n\n\nsum\\_volume\n\n
\n\n2018.10.08 01:02:00.000\n\n\n\nA\n\n\n\n38\n\n
\n\n2018.10.08 01:02:00.000\n\n\n\nB\n\n\n\n40\n\n
\n\n2018.10.08 01:03:00.000\n\n\n\nA\n\n\n\n25\n\n
\n\n2018.10.08 01:03:00.000\n\n\n\nB\n\n\n\n9\n\n
\n" }, "DStream::udfEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_udfEngine.html", "signatures": [ { "full": "DStream::udfEngine(func)", "name": "DStream::udfEngine", "parameters": [ { "full": "func", "name": "func" } ] } ], "markdown": "### [DStream::udfEngine](https://docs.dolphindb.com/en/Functions/d/DStream_udfEngine.html)\n\nFirst introduced in version: 3.00.4\n\n\n\n#### Syntax\n\nDStream::udfEngine(func)\n\n#### Details\n\n`DStream::udfEngine` is an extension engine in Orca stream graphs used to execute user-defined processing logic. When the built-in streaming engine cannot meet specific business requirements, users can define functions via `DStream::udfEngine` to process each stream record.\n\nTo enable stateful computation, UDF functions can access shared variables declared via `DStream::sharedTable`, `DStream::sharedDict`, or `DStream::sharedKeyedTable`. These shared variables can be used across multiple `udfEngine` instances and tasks within the same stream graph. Orca automatically persists their state using the Checkpoint mechanism and restores them during failure recovery.\n\nNote: UDF functions are not allowed to access any external variables. Only local variables or shared variables referenced via `orcaObj(\"name\")` are permitted.\n\n**Constraints on Shared Variable**\n\n* Shared variables must be declared in advance using `DStream::sharedTable`, `DStream::sharedDict`, or `DStream::sharedKeyedTable`. Within a UDF function, they can be referenced via `orcaObj(\"name\")`. Note that `orcaObj` is only valid in the execution context of the UDF.\n\n* Each shared variable follows a single-writer, multiple-reader pattern: only one `udfEngine` instance can write to it, while multiple instances may read it concurrently.\n\n* All tasks that access the same shared variable are scheduled by Orca on the same physical node to ensure local access and state consistency.\n\n#### Parameters\n\n**func** A user-defined function. It accepts only one parameter, which is a stream table. This parameter must not be modified in place or treated as a mutable object. Within the function, shared variables defined by `DStream::sharedTable`, `DStream::sharedDict`, or `DStream::sharedKeyedTable` can be read and written for state updates. If the function returns a value, it must be either a dictionary or a table.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\nIn this example, we use `DStream::sharedKeyedTable` and `DStream::udfEngine` to implement a historical delta computation.\n\nThe `DStream::sharedKeyedTable` is used to maintain the most recent record for each ID. When a new record arrives, if an entry with the same id already exists in the table, the UDF outputs the difference between the new value and the previously stored (historical) value. If the ID does not exist, the new record is inserted into the table without producing any output.\n\n```\nif(existsCatalog(\"orcaCatalog\")) dropCatalog(\"orcaCatalog\")\ncreateCatalog(\"orcaCatalog\")\ngo\nuse catalog orcaCatalog\n// Create stream graph\ng = createStreamGraph(\"compare\")\ng.sharedKeyedTable(\"history\", \"id\", 1:0, `id`value, [INT, DOUBLE])\ng.source(\"data\", `id`value`time, [INT, DOUBLE, TIMESTAMP])\n .udfEngine(def(msg) {\n history = orcaObj(\"history\")\n diffTable = table(100:0, `id`diff, [INT, DOUBLE])\n for(i in 0:msg.size()) {\n idVal = msg.id[i]\n valueVal = msg.value[i]\n // Read historical value\n old = select value from history where id = idVal\n // Write new value\n newRow = table(idVal as id, valueVal as value)\n history.append!(newRow)\n // Compute delta\n if(old.size() > 0) {\n diffTable.append!(table(idVal as id, (valueVal - old.value[0]) as diff))\n }\n }\n return diffTable\n })\n .sink(\"comparison\")\ng.submit()\n// Generate mock data\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// Insert data\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// Generate data with duplicate IDs\nmockData = table(1..5 as id, rand(100.0, 5) as value, now() + 1..5 as time)\n// Insert data\nappendOrcaStreamTable(\"orcaCatalog.orca_table.data\", mockData)\n// Wait for processing and inspect results\nsleep(1000)\nselect * from orcaCatalog.orca_table.comparison\n```\n\n| id | diff |\n| -- | ------------------- |\n| 1 | 35.55946895749296 |\n| 2 | -3.4362593906550387 |\n| 3 | 36.283468999034596 |\n| 4 | 68.97968558337999 |\n| 5 | -91.64246928217878 |\n\n**Related functions**: [DStream::map](https://docs.dolphindb.com/en/Functions/d/DStream_map.html), [getUdfEngineVariable](https://docs.dolphindb.com/en/Functions/g/getUdfEngineVariable.html)\n" }, "DStream::windowJoinEngine": { "url": "https://docs.dolphindb.com/en/Functions/d/DStream_windowJoinEngine.html", "signatures": [ { "full": "DStream::windowJoinEngine(rightStream, window, metrics, matchingColumn, [timeColumn], [useSystemTime=false], [garbageSize], [maxDelayedTime], [nullFill], [sortByTime], [closed])", "name": "DStream::windowJoinEngine", "parameters": [ { "full": "rightStream", "name": "rightStream" }, { "full": "window", "name": "window" }, { "full": "metrics", "name": "metrics" }, { "full": "matchingColumn", "name": "matchingColumn" }, { "full": "[timeColumn]", "name": "timeColumn", "optional": true }, { "full": "[useSystemTime=false]", "name": "useSystemTime", "optional": true, "default": "false" }, { "full": "[garbageSize]", "name": "garbageSize", "optional": true }, { "full": "[maxDelayedTime]", "name": "maxDelayedTime", "optional": true }, { "full": "[nullFill]", "name": "nullFill", "optional": true }, { "full": "[sortByTime]", "name": "sortByTime", "optional": true }, { "full": "[closed]", "name": "closed", "optional": true } ] } ], "markdown": "### [DStream::windowJoinEngine](https://docs.dolphindb.com/en/Functions/d/DStream_windowJoinEngine.html)\n\nFirst introduced in version: 3.00.3\n\n\n\n#### Syntax\n\nDStream::windowJoinEngine(rightStream, window, metrics, matchingColumn, \\[timeColumn], \\[useSystemTime=false], \\[garbageSize], \\[maxDelayedTime], \\[nullFill], \\[sortByTime], \\[closed])\n\n#### Details\n\nCreates a window join streaming engine. For details, see [createWindowJoinEngine](https://docs.dolphindb.com/en/Functions/c/createWindowJoinEngine.html).\n\n**Note:** In Orca, the column types in the output table are inferred automatically:\n\n* window = 0:0 (special window): For non-aggregated results, the output is inferred as an array vector by default. If the result type does not support array vectors, it is automatically converted to a columnar tuple.\n\n* window ≠ 0:0 (regular window): The output is inferred as an array vector only when `toArray` is explicitly specified.\n\n#### Parameters\n\n**rightStream** is a DStream object indicating the input data source of the right table.\n\n**window** is a pair of integers or duration values, indicating the range of a sliding window, including both left and right bounds.\n\n**metrics** is metacode (which can be a tuple) specifying the calculation formulas. For more information about metacode, please refer to [Metaprogramming](https://docs.dolphindb.com/en/Programming/Metaprogramming/functional_meta.html).\n\n* *metrics* can use one or more expressions, built-in or user-defined functions (both aggregate functions and non-aggregate functions are accepted).\n\n* *metrics* can be functions that return multiple values and the columns in the output table to hold the return values must be specified. For example, \\.\n\n* The column names specified in *metrics* are not case-sensitive and can be inconsistent with the column names of the input tables.\n\nIf you want to specify a column that exists in both the left and the right tables, use the format *tableName.colName*. By default, the column from the left table is used.\n\nWhen an array vector result is required, explicitly apply the `toArray` function to convert the result type.\n\nThe `toColumnarTuple` function is supported to convert non-aggregated computation results into columnar tuples.\n\nThe following functions are optimized in the engine when they are applied only to the columns from the right table: `sum`, `sum2`, `avg`, `std`, `var`, `corr`, `covar`, `wavg`, `wsum`, `beta`, `max`, `min`, `last`, `first`, `med`, `percentile`.\n\n**matchingColumn** is a STRING scaler/vector/tuple indicating the column(s) on which the tables are joined. It supports integral, temporal or literal (except UUID) types.\n\n* When there is only 1 column to match - If the names of the matching column are the same in both tables, *matchingColumn* should be specified as a STRING scalar; otherwise it's a tuple of two elements. For example, if the column is named \"sym\" in the left table and \"sym1\" in the right table, then *matchingColumn* = \\[\\[\\`sym],\\[\\`sym1]].\n* When there are multiple columns to match - If the names of all the columns to match are the same in both tables, *matchingColumn* is a STRING vector; otherwise it's a tuple of two elements. For example, if the columns are named \"timestamp\" and \"sym\" in the left table, whereas in the right table they're named \"timestamp\" and \"sym1\", then matchingColumn = \\[\\[\\`timestamp, \\`sym], \\[\\`timestamp,\\`sym1]].\n\n**timeColumn** (optional) When *useSystemTime* = false, it must be specified to indicate the name(s) of the time column in the left table and the right table. The time columns must have the same data type. If the names of the time column in the left table and the right table are the same, *timeColumn* is a string. Otherwise, it is a vector of 2 strings indicating the time column in each table.\n\n**useSystemTime** (optional) indicates whether the left table and the right table are joined on the system time, instead of on the *timeColumn*.\n\n* *useSystemTime* = true: join records based on the system time (timestamp with millisecond precision) when they are ingested into the engine.\n\n* *useSystemTime* = false (default): join records based on the specified timeColumn from the left table and the right table.\n\n**garbageSize** (optional) is a positive integer with the default value of 5,000 (rows). As the subscribed data is ingested into the engine, it continues to take up the memory. Within the left/right table, the records are grouped by *matchingColumn* values; When the number of records in a group exceeds *garbageSize*, the system will remove those already been calculated from memory.\n\n**maxDelayedTime** (optional) is a positive integer. *maxDelayedTime* only takes effect when *timeColumn* is specified and the two arguments must have the same time precision. Use *maxDelayedTime* to trigger windows which remain uncalculated long past its end. The default *maxDelayedTime* is 3 seconds. For more information about this parameter, see \"Window triggering rules\" in the Details section.\n\n**nullFill** (optional) is a tuple of the same size as the number of output columns. It is used to fill in the null values in the output table. The data type of each element corresponds to each output column.\n\n**sortByTime** (optional) is a Boolean value that indicates whether the output data is globally sorted by time. The default value is false, meaning the output data is sorted only within groups. Note that if *sortByTime* is set to true, the data input to the left and right tables must be globally sorted, and the parameter *maxDelayedTime* cannot be specified (i.e., no delayed triggering allowed).\n\n**closed**(optional) is a string that indicates whether the left or the right boundary is included. It only takes effect when *window*=0:0.\n\n#### Returns\n\nA DStream object.\n\n#### Examples\n\n```\nif (!existsCatalog(\"orca\")) {\n\tcreateCatalog(\"orca\")\n}\ngo\nuse catalog orca\n\n// If a stream graph with the same name already exists, destroy it first.\n// dropStreamGraph('joinEngine')\ng = createStreamGraph('joinEngine')\n\nr = g.source(\"right\", 1024:0, `time`sym`val, [TIMESTAMP, SYMBOL, DOUBLE])\ng.source(\"left\", 1024:0, `time`sym`price, [TIMESTAMP, SYMBOL, DOUBLE])\n .windowJoinEngine(r, window=-2:2, metrics=<[price,val,sum(val)]>, matchingColumn=`sym, timeColumn=`time, useSystemTime=false,nullFill=[2012.01.01T00:00:00.000, `NONE, 0.0, 0.0, 0.0])\n .sink(\"output\")\ng.submit()\n\ngo\n\nn=10\ntp1=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(NULL join rand(10.0, n-1),2*n) as price)\ntp1.sortBy!(`time)\nappendOrcaStreamTable(\"left\", tp1)\n\ntp2=table(take(2012.01.01T00:00:00.000+0..10, 2*n) as time, take(`A, n) join take(`B, n) as sym, take(double(1..n),2*n) as val)\ntp2.sortBy!(`time)\nappendOrcaStreamTable(\"right\", tp2)\n\n\nselect * from orca_table.output\n```\n" }, "dumpHeapSample": { "url": "https://docs.dolphindb.com/en/Functions/d/dumpHeapSample.html", "signatures": [ { "full": "dumpHeapSample(filename)", "name": "dumpHeapSample", "parameters": [ { "full": "filename", "name": "filename" } ] } ], "markdown": "### [dumpHeapSample](https://docs.dolphindb.com/en/Functions/d/dumpHeapSample.html)\n\n\n\n#### Syntax\n\ndumpHeapSample(filename)\n\n#### Details\n\nThis function generates a snapshot of the current heap memory. It records the current memory usage, including allocated memory blocks, their sizes, and states. Only administrators can execute this function.\n\n#### Parameters\n\n**filename** is a string representing the path for the heap memory snapshot file.\n\n#### Returns\n\nNone.\n\n#### Examples\n\nRecommended workflow for memory usage analysis:\n\n1. Enable heap memory sampling: This can be done by setting the environment variable TCMALLOC\\_SAMPLE\\_PARAMETER to a value between 1 and 524288 (recommended: 524288) before starting DolphinDB; or by dynamically enabling it using `startHeapSample`.\n2. Execute `dumpHeapSample` before and after operations that may cause memory leaks, saving to two different files. Compare these files to confirm memory allocation and usage related to the operation.\n3. Disable heap memory sampling.\n\n```\nstartHeapSample(524288)\n​\ndumpHeapSample(\"/DolphinDB/Data/heap1\")\ndumpHeapSample(\"/DolphinDB/Data/heap2\")\n​\nstopHeapSample()\n```\n\nRelated functions: [startHeapSample](https://docs.dolphindb.com/en/Functions/s/startHeapSample.html), [stopHeapSample](https://docs.dolphindb.com/en/Functions/s/stopHeapSample.html)\n" }, "duration": { "url": "https://docs.dolphindb.com/en/Functions/d/duration.html", "signatures": [ { "full": "duration(X)", "name": "duration", "parameters": [ { "full": "X", "name": "X" } ] } ], "markdown": "### [duration](https://docs.dolphindb.com/en/Functions/d/duration.html)\n\n\n\n#### Syntax\n\nduration(X)\n\n#### Details\n\nConvert *X* to DURATION type which indicates the length of a time interval.\n\nNote:\n\n* The unit of the time interval used for grouping cannot be more granular than the unit of the temporal column.\n\n* Time units are case-sensitive, for example, \"M\" means month and \"m\" means minute. If the unit of the time interval is M, use function [month](https://docs.dolphindb.com/en/Functions/m/month.html) to convert the time column values to months.\n\n* Data of DURATION type cannot participate in calculations. For example, comparisons between DURATION values (such as `duration(`20ms) >= duration(`10ms)`) are not supported.\n\n#### Parameters\n\n**X** is a STRING scalar. It is composed of an integer and a unit of time (y, M, w, d, B, H, m, s, ms, us, ns). For examples: \"2y\", \"3M\", \"30m\", \"100ms\".\n\n**X** is a STRING scalar composed of an integer and a unit of time. It supports the following units of time: y, M, w, d, B, H, m, s, ms, us, ns, and trading calendar identifier consisting of four capital letters. For example, *X* can be \"2y\", \"3M\", \"30m\", \"100ms\", and \"3XNYS\". *X* supports all trading calendars defined by the calendar files stored in *marketHolidayDir*.\n\n#### Returns\n\nA DURATION scalar.\n\n#### Examples\n\n```\ny=duration(\"20H\")\ny\n// output: 20H\n\ntypestr(y)\n// output: DURATION\n\nduration\\(\"3XNYS\"\\)\n// output: 3XNYS\n```\n\nIn function bar, we can use a number followed by a time unit to indicate a duration.\n\n```\nt=table(take(2018.01.01T01:00:00+1..10,10) join take(2018.01.01T02:00:00+1..10,10) join take(2018.01.01T08:00:00+1..10,10) as time, rand(1.0, 30) as x)\nselect max(x) from t group by bar(time, 5);\n```\n\n| bar\\_time | max\\_x |\n| ------------------- | ------ |\n| 2018.01.01T01:00:00 | 0.8824 |\n| 2018.01.01T01:00:05 | 0.8027 |\n| 2018.01.01T01:00:10 | 0.572 |\n| 2018.01.01T02:00:00 | 0.8875 |\n| 2018.01.01T02:00:05 | 0.8542 |\n| 2018.01.01T02:00:10 | 0.4287 |\n| 2018.01.01T08:00:00 | 0.9294 |\n| 2018.01.01T08:00:05 | 0.9804 |\n| 2018.01.01T08:00:10 | 0.2147 |\n\n```\nselect max(x) from t group by bar(time, 1m);\n```\n\n| bar\\_time | max\\_x |\n| ------------------- | ------ |\n| 2018.01.01T01:00:00 | 0.8824 |\n| 2018.01.01T02:00:00 | 0.8875 |\n| 2018.01.01T08:00:00 | 0.9804 |\n\nRelated information: [Trading Calendar](https://docs.dolphindb.com/en/Tutorials/trading_calendar.html)\n" }, "dynamicGroupCumcount": { "url": "https://docs.dolphindb.com/en/Functions/d/dynamicGroupCumcount.html", "signatures": [ { "full": "dynamicGroupCumcount(membership, prevMembership, groupCount)", "name": "dynamicGroupCumcount", "parameters": [ { "full": "membership", "name": "membership" }, { "full": "prevMembership", "name": "prevMembership" }, { "full": "groupCount", "name": "groupCount" } ] } ], "markdown": "### [dynamicGroupCumcount](https://docs.dolphindb.com/en/Functions/d/dynamicGroupCumcount.html)\n\n\n\n#### Syntax\n\ndynamicGroupCumcount(membership, prevMembership, groupCount)\n\n#### Details\n\nThe attribute and category of an event are fixed in most cases. In some scenarios, the category of an event, however, will change dynamically. For example, when processing real-time tick data, users may judge whether an order (attribute) is a large or a small one (category) based on the cumulative volume to analyze capital flow. As real-time data continues to flow in, trading volume keeps increasing, and thus a small order may change to a large one.\n\nFunction `dynamicGroupCumcount` is used in such scenarios to count the number of dynamically cumulative events of different categories.\n\nDetails are as follows:\n\n* If *membership = prevMembership*, count remains unchanged.\n\n* If *membership ≠ prevMembership*, the count of corresponding group of *membership* increases by 1, and the count of corresponding group of *prevMembership* decreases by 1.\n\n* If *prevMembership* is a null value (the first record of each group), the count of corresponding group of *membership* increases by 1.\n\nIt returns a tuple of length *groupCount*. Each element is a vector of the same length as *membership*, which sequentially records the cumulative count of each tag.\n\n**Note**: The index of the tuple matches the tags, which means that the count of tag 0 is output to the vector at index 0 of the tuple.\n\n#### Parameters\n\n**membership** is a vector, of which elements must be integers in the interval \\[0, groupCount), indicating tags for the record at the current timestamp.\n\n**prevMembership** is a vector of INT type, of which elements can be null values (the first record of each group), indicating tags for the record at the previous timestamp of *membership*.\n\n**groupCount** is an integer in the interval \\[2, 8], indicating the number of tags.\n\n#### Returns\n\nA tuple of length *groupCount*.\n\n#### Examples\n\nData preprocessing:\n\n```\n// Define a function to generate tags\ndef tag_func(v){\n\n return iif(v <= 5, 0, iif(v <= 10 and v > 5, 1, 2))\n# output\n}\n// original table\ntime = take(2022.01.01T09:00:00.000 + 1..3, 6)\nsym=`st0`st0`st0`st1`st1`st1\norderNo = `10001`10002`10001`10002`10003`10002\nvolume = 2 4 6 3 2 9\nt = table(sym, time, orderNo, volume)\n\n// calculate cumulative sums and tag the results\nt1 = select *, cumsum(volume) as sumVolume from t context by sym, orderNo\nt2 = lj(t, t1,`sym`time`orderNo)\nt3 = select sym, time, orderNo, volume, sumVolume, tag_func(sumVolume) as groupId from t2\n```\n\nFor historical data, you can use SQL statements to calculate the cumulative count for each group:\n\n```\nt4 = select sym, time, orderNo, prev(groupId) as prevGroupId from t3 context by sym,orderNo\nt5 = lj(t3, t4,`sym`time`orderNo)\nre = select sym, time, orderNo, dynamicGroupCumcount(groupId, prevGroupId, 3) as `groupId0`groupId1`groupId2 from t5 context by sym\nre\n```\n\n| sym | time | orderNo | groupId0 | groupId1 | groupId2 |\n| --- | ----------------------- | ------- | -------- | -------- | -------- |\n| st0 | 2022.01.01T09:00:00.001 | 10001 | 1 | 0 | 0 |\n| st0 | 2022.01.01T09:00:00.002 | 10002 | 2 | 0 | 0 |\n| st0 | 2022.01.01T09:00:00.003 | 10001 | 1 | 1 | 0 |\n| st1 | 2022.01.01T09:00:00.001 | 10002 | 1 | 0 | 0 |\n| st1 | 2022.01.01T09:00:00.002 | 10003 | 2 | 0 | 0 |\n| st1 | 2022.01.01T09:00:00.003 | 10002 | 1 | 0 | 1 |\n\nFor real-time data, you can use reactive state engine to calculate the cumulative count for each group:\n\n```\nresult = table(1000:0, `sym`time`orderNo`groupId0`groupId1`groupId2, [SYMBOL, TIME, SYMBOL,INT,INT,INT])\nfactor0 = [