### Install and Load Plugin

Source: https://docs.dolphindb.com/en/Functions/l/listPluginsByCluster.html

Before listing plugins, this example shows how to install and load a plugin named 'mysql'. This is a prerequisite for using listPluginsByCluster.

```javascript
// MoMSender cluster:
installPlugin("mysql")
loadPlugin("mysql")
```

--------------------------------

### Get Tables from a Database Handle

Source: https://docs.dolphindb.com/en/Functions/g/getTables.html

This example demonstrates how to create a partitioned table and then use getTables to retrieve its name from the database handle. It requires prior setup of a database and tables.

```python
n=1000000
ID=rand(10, n)
dates=2017.08.07..2017.08.11
date=rand(dates, n)
x=rand(10.0, n)
y=rand(10, n)
t1=table(ID, date, x)
t2=table(ID, date, y)
db = database("dfs://valueDB", VALUE, 2017.08.07..2017.08.11)
pt1 = db.createPartitionedTable(t1, `pt1, `date)
pt1.append!(t1)
pt2 = db.createPartitionedTable(t2, `pt2, `date)
pt2.append!(t2);
getTables(db);
// output: ["pt1","pt2"]
```

--------------------------------

### Start Promtail Service

Source: https://docs.dolphindb.com/en/Tutorials/best_practices_for_log_monitoring.html

Execute this command in the Promtail installation directory to start the Promtail service in the background, using a specified configuration file and redirecting output.

```bash
nohup ./promtail-linux-amd64 -config.file=./promtail.yaml >./server.log 2>&1 &
```

--------------------------------

### Get Chunk Paths for Data Sources

Source: https://docs.dolphindb.com/en/Functions/g/getChunkPath.html

This example demonstrates how to create a partitioned table, define data sources using a SQL query, and then retrieve the chunk paths for those data sources using getChunkPath. It includes setup for a database and table, followed by the core function call.

```python
if(existsDatabase("dfs://valuedb")){
  dropDatabase("dfs://valuedb")
}

db=database("dfs://valuedb", VALUE, 1..10)
n=1000000
t=table(rand(1..10, n) as id, rand(100.0, n) as val)
pt=db.createPartitionedTable(t, `pt, `id).append!(t);
ds=sqlDS(<select * from pt where id in 1..3>)
getChunkPath(ds);

// output: ["/valuedb/1","/valuedb/2","/valuedb/3"]
```

--------------------------------

### Setup for Dimension Table Cache Examples

Source: https://docs.dolphindb.com/en/Tutorials/cache_management_and_cleanup.html

This script sets up OLAP and TSDB databases and creates sample dimension tables for cache management examples.

```python
dbNameOLAP = "dfs://test_OLAP"
dbNameTSDB = "dfs://test_TSDB"
if(existsDatabase(dbNameOLAP)){
    dropDatabase(dbNameOLAP)
}
if(existsDatabase(dbNameTSDB)){
    dropDatabase(dbNameTSDB)
}
t = table(1..10 as x, symbol(string(1..10)) as y)
dbOLAP = database(dbNameOLAP, VALUE, 1..10)
dbTSDB = database(dbNameTSDB, VALUE, 1..10, engine="TSDB")
createTable(dbOLAP, t, `dt1).append!(t)
createTable(dbOLAP, t, `dt2).append!(t)
createTable(dbOLAP, t, `dt3).append!(t)
createTable(dbTSDB, t, `dt1, sortColumns=`x).append!(t)
createTable(dbTSDB, t, `dt2, sortColumns=`x).append!(t)
createTable(dbTSDB, t, `dt3, sortColumns=`x).append!(t)
```

--------------------------------

### Setup and Data Ingestion for Memory Management Demo

Source: https://docs.dolphindb.com/en/Tutorials/memory_management.html

Initializes a DFS database, creates a partitioned table, and populates it with simulated data. This setup is required before running memory usage examples. It also includes a step to clear cache and query data to observe memory allocation.

```python
login(`admin,`123456)
if(existsDatabase("dfs://mem")){
	dropDatabase("dfs://mem")
}
db = database("dfs://mem",VALUE,2022.01.01..2022.01.30)
m = "tag" + string(1..9)
schema = table(1:0,`id`day join m, [INT,DATE] join take(LONG,9) )
db.createPartitionedTable(schema,"pt1",`day)
//write simulated data to the database
for (i in 0..29){
	t=table(1..10000000 as tagid,take(2022.01.01+i,10000000) as date,1..10000000 as tag1,1..10000000 as tag2,1..10000000 as tag3,1..10000000 as tag4,1..10000000 as tag5,1..10000000 as tag6,1..10000000 as tag7,1..10000000 as tag8,1..10000000 as tag9 )
	dfsTable=loadTable("dfs://mem","pt1")
	dfsTable.append!(t)
}

//Query 15 partitions from node1
t=select top 15 * from rpc(getControllerAlias(),getClusterChunksStatus) where file like "/mem%" and replicas like "node1%" order by file
pnodeRun(clearAllCache)
days=datetimeParse(t.file.substr(5,8),"yyyyMMdd")
for(d in days){
    select * from loadTable("dfs://mem","pt1") where  day= d
    print mem().allocatedBytes - mem().freeBytes
}
```

--------------------------------

### Full Example: Stream Processing Setup and Replay

Source: https://docs.dolphindb.com/en/Tutorials/functional_programming_cases.html

Combines factor definition, message handling, stream table setup, history initialization, and data replay to simulate real-time factor calculation. Subscribes to a stream table and replays historical data.

```python
quotesData = loadText("/data/ddb/data/sampleQuotes.csv")

defg factorAskPriceRatio(x){
	cnt = x.size()
	if(cnt < 31) return double()
	else return x[cnt - 1]/x[cnt - 31]
}
def factorHandler(mutable historyDict, mutable factors, msg){
	historyDict.dictUpdate!(function=append!, keys=msg.symbol, parameters=msg.askPrice1, initFunc=x->array(x.type(), 0, 512).append!(x))
	syms = msg.symbol.distinct()
	cnt = syms.size()
	v = array(DOUBLE, cnt)
	for(i in 0:cnt){
	    v[i] = factorAskPriceRatio(historyDict[syms[i]])
	}
	factors.tableInsert([take(now(), cnt), syms, v])
}

x=quotesData.schema().colDefs
share streamTable(100:0, x.name, x.typeString) as quotes1
history = dict(STRING, ANY)
share streamTable(100000:0, `timestamp`symbol`factor, [TIMESTAMP,SYMBOL,DOUBLE]) as factors
subscribeTable(tableName = "quotes1", offset=0, handler=factorHandler{history, factors}, msgAsTable=true, batchSize=3000, throttle=0.005)

replay(inputTables=quotesData, outputTables=quotes1, dateColumn=`date, timeColumn=`time)
```

--------------------------------

### Remove Existing DolphinDB Installation Package

Source: https://docs.dolphindb.com/en/Tutorials/docker_single_deployment.html

Before starting a new deployment, remove any previous installation packages to ensure a clean setup.

```bash
rm -rf ./${ddb_name}
```

--------------------------------

### Example Cold Data Volume Configuration

Source: https://docs.dolphindb.com/en/Tutorials/tiered_storage.html

An example demonstrating how to specify local and S3 paths for cold data volumes, using a macro for node-specific paths.

```text
coldVolumes=file://home/mypath/hdd/<ALIAS>,s3://bucket1/data/<ALIAS>
```

--------------------------------

### Multithreaded Data Insertion with MTW

Source: https://docs.dolphindb.com/en/pydoc/BasicOperations/AsyncWrites/MultithreadedTableWriter.html

This example demonstrates how to use multiple threads to concurrently insert data into a DolphinDB table using the MultithreadedTableWriter. Ensure proper session connection and table setup before starting threads.

```python
import numpy as np
import pandas as pd
import dolphindb as ddb
import time
import threading
import random

s = ddb.Session()
s.connect("localhost", 8848, "admin", "123456")

script = """
    dbName = 'dfs://valuedb3'
    if(exists(dbName)){
        dropDatabase(dbName);
    }
    datetest=table(1000:0,`date`symbol`id,[DATE,SYMBOL,INT])
    db = database(directory=dbName, partitionType=HASH, partitionScheme=[INT, 10])
    pt=db.createPartitionedTable(datetest,'pdatetest','id')
"""
s.run(script)

writer = ddb.MultithreadedTableWriter(
    "localhost", 8848, "admin", "123456", dbPath="dfs://valuedb3", tableName="pdatetest",
    batchSize=10000, throttle=1, threadCount=5, partitionCol="id", compressMethods=["LZ4","LZ4","DELTA"]
)

def insert_MTW(writer):
    try:
        # insert 100 records of correct data types and schema
        for i in range(100):
            res = writer.insert(random.randint(1,10000),"AAAAAAAB", random.randint(1,10000))
    except Exception as ex:
        # print error message
        print("MTW exit with exception %s" % ex)

# create 10 threads to insert data into MTW
threads = []
for i in range(10):
    threads.append(threading.Thread(target=insert_MTW, args=(writer,)))

for thread in threads:
    thread.start()


```

--------------------------------

### Create MySQL Database and Table

Source: https://docs.dolphindb.com/en/Tutorials/MySQL_to_DolphinDB.html

Sets up a sample database and table in MySQL for data import.

```sql
create database demo;
create table demo.sample(
    ts VARCHAR(20),
    id VARCHAR(10),
    val DOUBLE
   );
insert into demo.sample (ts,id,val) values('2024-01-01 12:00:00','SID001',1.2);
insert into demo.sample (ts,id,val) values('2024-01-01 12:00:00','SID002',2.3);
insert into demo.sample (ts,id,val) values('2024-01-01 12:00:00','SID003',3.4);
insert into demo.sample (ts,id,val) values('2024-01-01 12:00:00','SID004',4.5);
insert into demo.sample (ts,id,val) values('2024-01-01 12:00:00','SID005',5.6);
insert into demo.sample (ts,id,val) values('2024-01-02 12:00:00','SID001',6.7);
insert into demo.sample (ts,id,val) values('2024-01-02 12:00:00','SID002',7.8);
insert into demo.sample (ts,id,val) values('2024-01-02 12:00:00','SID003',8.9);
insert into demo.sample (ts,id,val) values('2024-01-02 12:00:00','SID004',9.1);
insert into demo.sample (ts,id,val) values('2024-01-02 12:00:00','SID005',1.2);
```

--------------------------------

### Get Quarter Start Date with Custom Starting Month

Source: https://docs.dolphindb.com/en/Functions/q/quarterBegin.html

Calculates the quarter's start date using a specified starting month (e.g., month 5).

```DolphinDB
quarterBegin(2012.06.13 10:10:10.008,5);
```

--------------------------------

### Create an OLAP Database

Source: https://docs.dolphindb.com/en/Programming/SQLStatements/create.html

This example shows how to create an OLAP database named 'dfs://test'. It includes dropping the database if it already exists and defines partitioning by VALUE and HASH with a specified engine.

```SQL
if(existsDatabase("dfs://test")) dropDatabase("dfs://test")
     create database "dfs://test" partitioned by VALUE(1..10), HASH([SYMBOL, 40]), engine='OLAP'
```

--------------------------------

### Controller Configuration Example

Source: https://docs.dolphindb.com/en/Tutorials/single_machine_cluster_deploy.html

An example of a controller configuration file. Key parameters like mode, localSite, and resource allocation are defined here.

```ini
mode=controller
localSite=localhost:8900:controller8900
dfsReplicationFactor=1
dfsReplicaReliabilityLevel=2
dataSync=1
workerNum=4
localExecutors=3
maxConnections=512
maxMemSize=8
lanCluster=0

```

--------------------------------

### Start Debugging the Extension

Source: https://docs.dolphindb.com/en/Tutorials/vscode_extension.html

Instructions on how to start debugging the extension within VSCode, including disabling existing installations.

```shell
# Switch to the debug panel in VSCode and start the ddb.ext debugging task (you need to disable or uninstall the installed dolphindb plugin first)
```

--------------------------------

### Install and Load MQTT Plugin by Path

Source: https://docs.dolphindb.com/en/Functions/l/loadPlugin.html

Installs the MQTT plugin and then loads it into DolphinDB using the absolute path to its meta file. Ensure to use forward slashes for paths on Windows.

```sql
installPlugin("mqtt")
loadPlugin("D:/TEST/DolphinDB_Win64_V2.00.10/server/plugins/mqtt/PluginMQTT.txt")
```

--------------------------------

### Get the start of the semiannual period with a custom starting month

Source: https://docs.dolphindb.com/en/Functions/s/semiannualBegin.html

Calculates the first day of the semiannual period for a given datetime, specifying July as the starting month for the semiannual periods.

```sql
semiannualBegin(2025.10.10 10:10:10.008, 3);
// output: 2025.09.01
```

--------------------------------

### Create 3-Second Factor Database and Table

Source: https://docs.dolphindb.com/en/Tutorials/python_parser_in_quantitative_analysis.html

This example shows how to create a database partitioned by day and factor name, along with a partitioned table for storing factors calculated on a 3-second basis. It includes dropping the database if it exists.

```python
import pandas as pd
import dolphindb as ddb

dbName, tbName = "dfs://level2FactorDB", "level2FactorTB"

# Drop the database if it already exists
if existsDatabase(dbName):
    dropDatabase(dbName)

# Create a database with composite VALUE-based partitions (by each day and factor name)
db1 = database("", ddb.VALUE, seq(2022.01.01, 2022.12.31))
db2 = database("", ddb.VALUE, ["f1","f2"].toddb())
db = database(dbName, ddb.COMPO, [db1, db2].toddb(), engine='TSDB', atomic='CHUNK')

# create a partitioned table
schemaTB = table(array(ddb.DATE, 0) as tradetime, 
                array(ddb.SYMBOL, 0) as securityid, 
                array(ddb.SYMBOL, 0) as factorname, 
                array(ddb.DOUBLE, 0) as value)

db.createPartitionedTable(schemaTB, tbName, partitionColumns=["tradetime", "factorname"].toddb(), compressMethods={"tradetime":"delta"}.toddb(), 
                        sortColumns=["securityid", "tradetime"].toddb(), keepDuplicates=ddb.ALL, sortKeyMappingFunction=[lambda x:hashBucket(x, 500)].toddb())
```

--------------------------------

### Get the start of the semiannual period

Source: https://docs.dolphindb.com/en/Functions/s/semiannualBegin.html

Calculates the first day of the semiannual period for a given date. The default starting month is January.

```sql
semiannualBegin(2025.08.10);
// output: 2025.07.01
```

--------------------------------

### DolphinDB: Setting up a partitioned database and tables for backup

Source: https://docs.dolphindb.com/en/Functions/c/checkBackup.html

This snippet demonstrates how to set up a partitioned database and create tables, which are prerequisites for using the backup and checkBackup functions.

```dolphindb
dbName = "dfs://compoDB2"
n=1000
ID=rand("a"+string(1..10), n)
dates=2017.08.07..2017.08.11
date=rand(dates, n)
x=rand(10, n)
t=table(ID, date, x)
db1 = database(, VALUE, 2017.08.07..2017.08.11)
db2 = database(, HASH,[INT, 20])
if(existsDatabase(dbName)){
dropDatabase(dbName)
}
db = database(dbName, COMPO,[ db1,db2])

//create 2 tables
pt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)
pt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)
```

--------------------------------

### Get the first day of the year with a custom starting month

Source: https://docs.dolphindb.com/en/Functions/y/yearBegin.html

Calculates the first day of the year for a given date, starting the year in a specified month. The default starting month is January (1).

```DolphinDB
yearBegin(2012.06.12, 10);
// output: 2011.10.01
```

```DolphinDB
yearBegin(2012.06.12, 4);
// output: 2012.04.01
```

```DolphinDB
yearBegin(2012.06.12);
// output: 2012.01.01
```

--------------------------------

### Get Quarter Start Date

Source: https://docs.dolphindb.com/en/Functions/q/quarterBegin.html

Returns the first day of the quarter for a given date. The starting month determines the quarter's beginning.

```DolphinDB
quarterBegin(2012.06.12);
```

--------------------------------

### Create and Join Tables

Source: https://docs.dolphindb.com/en/Tutorials/sql_execution_plan.html

This snippet demonstrates the creation of two partitioned tables and a subsequent join query using the HINT_EXPLAIN directive to retrieve the execution plan.

```python
if(existsDatabase("dfs://valuedb")) dropDatabase("dfs://valuedb");
if(existsDatabase("dfs://valuedb1")) dropDatabase("dfs://valuedb1");

// Create valuedb database
n = 1000000
month = take(2000.01M..2016.12M, n)
x = rand(1.0, n)
id = rand(1..9, n)
t1 = table(month, x, id)
db1 = database("dfs://valuedb", VALUE, 2000.01M..2016.12M)
pt1 = db1.createPartitionedTable(t1, `pt, `month).append!(t1)

// Create valuedb1 database
id = rand(1..10, n)
times = now() + 1..n
vals = take(1..20, n) + rand(1.0, n)
t2 = table(id, times, vals)
db2 = database("dfs://valuedb1", VALUE, 1..10)
pt2 = db2.createPartitionedTable(t2, `pt, `id).append!(t2)

// Join query
select [HINT_EXPLAIN] times, vals, month from lsj(loadTable("dfs://valuedb", `pt), loadTable("dfs://valuedb1", `pt), `id)
```

--------------------------------

### Offset Parameter Example

Source: https://docs.dolphindb.com/en/Tutorials/streaming_tutorial.html

Demonstrates the use of the 'offset' parameter to control the starting point of a subscription. Offset -1 starts from the next new message, while a positive offset starts from a specific message index.

```python
share streamTable(10000:0,`timestamp`temperature, [TIMESTAMP,DOUBLE]) as pubTable
share streamTable(10000:0,`ts`temp, [TIMESTAMP,DOUBLE]) as subTable1
share streamTable(10000:0,`ts`temp, [TIMESTAMP,DOUBLE]) as subTable2
vtimestamp = 1..100
vtemp = norm(2,0.4,100)
tableInsert(pubTable,vtimestamp,vtemp)
topic1 = subscribeTable(tableName="pubTable", actionName="act1", offset=-1, handler=subTable1, msgAsTable=true)
topic2 = subscribeTable(tableName="pubTable", actionName="act2", offset=50, handler=subTable2, msgAs3=true)
```

--------------------------------

### Create a Table

Source: https://docs.dolphindb.com/en/Functions/d/dropColumns%21.html

Initializes a sample table with multiple columns for demonstration purposes.

```DolphinDB
t=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);
t;
```

--------------------------------

### Kafka Kerberos Libraries Not Installed Log Example

Source: https://docs.dolphindb.com/en/Plugins/kafka.html

This log indicates that the necessary Kerberos libraries are not installed on the environment, preventing successful SASL authentication.

```log
:[PLUGIN::KAFKA] facility: SASLREFRESH, message: [thrd:main]: Kerberos ticket refresh failed: kinit -R -t "/path_to_kerberos/kerberos/kafkaclient.keytab" -k kafkaclient@EXAMPLE.COM || kinit -t "/path_to_kerberos/kerberos/kafkaclient.keytab" -k kafkaclient@EXAMPLE.COM: exited with code 127
2024-12-09 07:02:08.319563000,cea <ERROR> :[PLUGIN::KAFKA] facility: LIBSASL, message: [thrd:sasl_plaintext://aftersale2:9094/bootstrap]: sasl_plaintext://aftersale2:9094/bootstrap: Cyrus/libsasl2 is missing a GSSAPI module: make sure the libsasl2-modules-gssapi-mit or cyrus-sasl-gssapi packages are installed
2024-12-09 07:02:08.319742000,cea <ERROR> :[PLUGIN::KAFKA] facility: FAIL, message: [thrd:sasl_plaintext://aftersale2:9094/bootstrap]: sasl_plaintext://aftersale2:9094/bootstrap: Failed to initialize SASL authentication: SASL handshake failed (start (-4)): SASL(-4): no mechanism available: No worthy mechs found (after 0ms in state AUTH_REQ)
```

--------------------------------

### Get Loaded Plugins Example

Source: https://docs.dolphindb.com/en/Functions/g/getLoadedPlugins.html

Demonstrates loading two plugins ('zip' and 'httpclient') by different users and then retrieving the list of all loaded plugins using getLoadedPlugins(). This function returns a table with plugin details.

```dolphinsql
login("admin","123456")
loadPlugin("zip")
login("user1","123456")
loadPlugin("httpclient")

getLoadedPlugins()
```

--------------------------------

### Complete Example: Task Management with DBConnectionPool

Source: https://docs.dolphindb.com/en/pydoc/BasicOperations/DBConnectionPool/AsyncMethodsAndOthers.html

This example demonstrates the full workflow of adding a task, monitoring its completion with `isFinished`, and retrieving its result using `getData` from a `DBConnectionPool`.

```python
import dolphindb as ddb
import time
pool = ddb.DBConnectionPool("localhost", 8848, 8)
taskid = 12
pool.addTask("sleep(1500);1+2", taskId=taskid)
while True:
    if pool.isFinished(taskId=taskid):
        break
    time.sleep(0.01)

res = pool.getData(taskId=taskid)
print(res)
```

--------------------------------

### Create 1-Second Factor Database and Table

Source: https://docs.dolphindb.com/en/Tutorials/python_parser_in_quantitative_analysis.html

This example shows the creation of a database partitioned by hour and factor name, along with a partitioned table for storing factors calculated every second. It includes dropping the database if it exists.

```python
import pandas as pd
import dolphindb as ddb

dbName, tbName = "dfs://secondFactorDB", "secondFactorTB"

# Drop the database if it already exists
if existsDatabase(dbName):
    dropDatabase(dbName)

# Create a database with composite VALUE-based partitions (by each hour and factor name)
db1 = database("", ddb.VALUE, seq(datehour(2022.01.01T00:00:00), datehour(2022.01.31T00:00:00)))
db2 = database("", ddb.VALUE, ["f1","f2"].toddb())
db = database(dbName, ddb.COMPO, [db1, db2].toddb(), engine='TSDB', atomic='CHUNK')

# create a partitioned table
schemaTB = table(array(ddb.DATE, 0) as tradetime, 
                array(ddb.SYMBOL, 0) as securityid, 
                array(ddb.SYMBOL, 0) as factorname, 
                array(ddb.DOUBLE, 0) as value)

db.createPartitionedTable(schemaTB, tbName, partitionColumns=["tradetime", "factorname"].toddb(), compressMethods={"tradetime":"delta"}.toddb(), 
                        sortColumns=["securityid", "tradetime"].toddb(), keepDuplicates=ddb.ALL, sortKeyMappingFunction=[lambda x:hashBucket(x, 500)].toddb())
```

--------------------------------

### Get Semiannual End Date with Custom Starting Month

Source: https://docs.dolphindb.com/en/Functions/s/semiannualEnd.html

Calculates the end of the semiannual period for a given datetime, specifying March as the starting month of the semiannual period.

```DolphinDB
semiannualEnd(2025.10.10 10:10:10.008, 3);
```

--------------------------------

### Get Instrument Start Date

Source: https://docs.dolphindb.com/en/Functions/g/getinstrumentstart.html

This snippet demonstrates how to define an instrument and then use getInstrumentStart to retrieve its start date. The instrument must be parsed first using parseInstrument.

```DolphinDB
bond = {
    "productType": "Cash",
    "assetType": "Bond",
    "bondType": "ZeroCouponBond",
    "instrumentId": "0001",
    "start": 1996.03.01,
    "maturity": 2032.05.15,
    "dayCountConvention": "ActualActualISDA",
    "coupon": 0.0276,
    "issuePrice": 100.0,
    "frequency": "Semiannual",
    "subType":"TREASURY_BOND",
    "creditRating":"B",
    "settlement": 2022.05.15 
}
ins = parseInstrument(bond)
getInstrumentStart(ins)
// output: 1996.03.01
```

--------------------------------

### Install and Load MQTT Plugin by Name

Source: https://docs.dolphindb.com/en/Functions/l/loadPlugin.html

Installs the MQTT plugin and then loads it into DolphinDB by specifying its name. This is a simpler method when the plugin is registered.

```sql
installPlugin("mqtt")
loadPlugin("mqtt")
```

--------------------------------

### Get First Business Day with Specific Starting Month

Source: https://docs.dolphindb.com/en/Functions/b/businessYearBegin.html

Calculates the first business day of the year, specifying May as the starting month. The result is a DATE type.

```python
businessYearBegin(2012.06.13 10:10:10.008,5);
```

--------------------------------

### getWorkDir

Source: https://docs.dolphindb.com/en/Functions/g/getWorkDir.html

Gets the absolute path of the working directory at the time the dolphindb process is started.

```APIDOC
## getWorkDir

### Description
Gets the absolute path of the working directory at the time the dolphindb process is started.

### Syntax
`getWorkDir()`

### Parameters
None

### Returns
A STRING scalar.

### Example
```
getWorkDir()
// output: /home/dolphindb/server/clusterDemo
```
```

--------------------------------

### Example: Assign Kafka Consumer

Source: https://docs.dolphindb.com/en/Plugins/kafka.html

Example demonstrating how to assign a consumer to a specific partition and offset of a topic.

```dolphindb
kafka::assign(consumer, "test", 1, 3000)
```

--------------------------------

### Install MySQL Plugin on Linux

Source: https://docs.dolphindb.com/en/Functions/i/installPlugin.html

Demonstrates how to install the mysql plugin on a Linux system. It shows two ways to load the plugin: by providing the full path to the description file or by simply using the plugin name. The output shows the full path of the installed plugin description file.

```sql
loadPlugin("/home/DolphinDB_Linux64_V2.00.10/server/plugins/mysql/PluginMySQL.txt")
// Or
loadPlugin("mysql")

// output: /home/DolphinDB_Linux64/server/plugins/mysql/PluginMySQL.txt
```

--------------------------------

### Calculate Fiscal Year Start Date with Leap Quarter

Source: https://docs.dolphindb.com/en/Functions/f/fy5253Quarter.html

Calculates the fiscal year start date, demonstrating the effect of specifying a leap quarter (qtrWithExtraWeek=4). This example highlights how the start date shifts based on which quarter is designated as the leap quarter.

```DolphinDB
fy5253Quarter(2019.12.01,0,1,4,true);
```

--------------------------------

### Get First Business Day with Custom Starting Month

Source: https://docs.dolphindb.com/en/Functions/b/businessQuarterBegin.html

Calculates the first business day of a quarter, specifying the third month (March) as the start of the quarter. This shifts the quarter boundaries.

```DolphinDB
businessQuarterBegin(2012.06.12, 3);
```

--------------------------------

### Full Streaming SQL Client Example

Source: https://docs.dolphindb.com/en/javadoc/streaming/StreamingSQLClient.html

Demonstrates the complete lifecycle of using the StreamingSQLClient, from establishing a connection and setting up streaming SQL tables to registering, subscribing, writing data, and finally unsubscribing. This example is useful for understanding the end-to-end workflow.

```java
DBConnection conn = new DBConnection();
conn.connect(HOST, PORT, "admin", "123456");
// Define keyed tables
String script = "share keyedTable(`id, 1:0, `id`time`value, [SYMBOL, TIMESTAMP, DOUBLE[]]) as t1;\n" +
        "share keyedTable(`id, 1:0, `id`time`value, [SYMBOL, TIMESTAMP, DOUBLE[]]) as t2;";
conn.run(script);

// Create a StreamingSQLClient
StreamingSQLClient streamingSQLClient = new StreamingSQLClient(HOST, PORT, "admin","123456");

// Declare t1 and t2 as streaming SQL tables
streamingSQLClient.declareStreamingSQLTable("t1");
streamingSQLClient.declareStreamingSQLTable("t2");

// List declared streaming SQL tables
BasicTable streamingSQLTables = streamingSQLClient.listStreamingSQLTables();

// Register streaming SQL
String sqlStr1 = "SELECT id, time,t1.value, rowSum(value) FROM t1 FULL JOIN t2 ON t1.id=t2.id\n" ;
String queryId = streamingSQLClient.registerStreamingSQL(sqlStr1);

// List the status of a specified declared streaming SQL
BasicTable streamingSQLStatus = streamingSQLClient.getStreamingSQLStatus(queryId);

// Subscribe to the streaming SQL
BasicTable bt = streamingSQLClient.subscribeStreamingSQL(queryId);

// Write data to declared streaming SQL tables
conn.run("n=100;\n" +
        "data = table(take(\"A\"+string(1..30), n) as id, timestamp(2025.08.26T12:36:23.438+1..n) as timestamp, take([take(1..10,10),take(1..10,10),take(1..10,10)], n) as value)
" +
        "t1.append!(data)\n");
conn.run("n=100;\n" +
        "data = table(take(\"A\"+string(1..30), n) as id, timestamp(2025.08.26T12:36:23.438+1..n) as timestamp, take([take(1..10,10),take(1..10,10),take(1..10,10)], n) as value)
" +
        "t2.append!(data)\n");

Thread.sleep(5000);
// Perform business operations on the local result table bt as needed
System.out.println(bt.getString());

// Unsubscribe the streaming SQL
streamingSQLClient.unsubscribeStreamingSQL(queryId);
```

--------------------------------

### Get Stream Graph FQN

Source: https://docs.dolphindb.com/en/Functions/s/StreamGraph_name.html

Call the name() method on a stream graph object to get its fully qualified name. This example assumes a stream graph 'g' has already been submitted.

```python
g.name()
// Output: 'demo.orca_graph.indicators'
```

--------------------------------

### Check Data Type with typestr and type

Source: https://docs.dolphindb.com/en/Programming/DataTypesandStructures/DataTypes/DataTypes.html

Use typestr to get the string representation of a data type and type to get its integer representation. The example shows checking the type of a LONG and an INT.

```DolphinDB
typestr 3l;
// output
LONG
```

```DolphinDB
type 3l;
// output
5
```

```DolphinDB
x=3;
if(type(x) == INT){y=10};
y;

// output
10
```

--------------------------------

### Generate Sample Data for Partition Deletion Examples

Source: https://docs.dolphindb.com/en/Database/DatabaseOperations/DropPartitions.html

This script sets up a COMPO-partitioned database with VALUE (first level) and RANGE (second level) partitioning. This database is used in subsequent examples for deleting partition data.

```python
drop database if exists "dfs://compoDB"
n=1000000
ID=rand(150, n)
dates=2024.08.07..2024.08.11
date=rand(dates, n)
x=rand(10.0, n)
t=table(ID, date, x)
dbDate = database(, VALUE, 2024.08.07..2024.08.11)
dbID = database(, RANGE, 0 50 100 150)
db = database("dfs://compoDB", COMPO, [dbDate, dbID])
pt = db.createPartitionedTable(t, `pt, `date`ID)
pt.append!(t);
```

--------------------------------

### Insert Data into Redis Stream (Async Mode Setup)

Source: https://docs.dolphindb.com/en/Plugins/redis.html

Loads the redis plugin and inserts a large number of messages into a Redis stream asynchronously. This is a setup step for the async consumption example.

```plaintext
loadPlugin("redis")

// Insert data into the stream in a separate session
REDIS_HOST = "127.0.0.1"
REDIS_PORT = 6379
STREAM_KEY = "test_stream_sub"
GROUP_NAME = "test_group"
CONSUMER_NAME = "consumer1"
ACTION_NAME = "test_action"
conn = redis::connect(REDIS_HOST, REDIS_PORT)
for (i in 1..100000) {
    redis::run(conn, "XADD", STREAM_KEY, "*", "field1", "value_" + string(i), "field2", string(i * 100))
    sleep(10)
}
```

--------------------------------

### Create Partitioned Table and Generate Data Sources

Source: https://docs.dolphindb.com/en/Functions/r/replayDS.html

This snippet demonstrates setting up a partitioned table and then using replayDS to create data sources based on date and time columns. It shows the basic usage for replaying data.

```dfs
n=int(60*60*6.5)
sym = take(take(`IBM,n).join(take(`GS,n)), n*2*3)
date=take(2021.01.04..2021.01.06, n*2*3).sort!()
time=take(09:30:00..15:59:59,n*2*3)
volume = rand(100, n*2*3)
t=table(sym,date,time,volume)
if(existsDatabase("dfs://test_stock")){
dropDatabase("dfs://test_stock")
}
db1=database("",RANGE, 2021.01.04..2021.01.07)
db2=database("",VALUE,`IBM`GS)
db=database("dfs://test_stock",COMPO,[db1, db2])
trades=db.createPartitionedTable(t,`trades,`date`sym)
trades.append!(t);
ds = replayDS(sqlObj=<select * from loadTable(db, `trades)>, dateColumn=`date, timeColumn=`time)
ds.size();
// output: 3
```

--------------------------------

### Prevailing Window Join Example Setup

Source: https://docs.dolphindb.com/en/Programming/SQLStatements/TableJoiners/windowjoin.html

Deletes rows from t2 within a specific time range (09:56:04 to 09:56:06) to prepare for a prevailing window join example. This modifies the t2 table for subsequent operations.

```sql
delete from t2 where 09:56:04<=time<=09:56:06;
t2;
```

--------------------------------

### Restore a Table using restoreTable

Source: https://docs.dolphindb.com/en/Functions/r/restoreTable.html

This example demonstrates how to create a partitioned table, back it up using backupDB, and then restore it using restoreTable. It shows the basic usage of restoring a table to its original location.

```python
dbName = "dfs://compoDB2"
n=1000
ID=rand("a"+string(1..10), n)
dates=2017.08.07..2017.08.11
date=rand(dates, n)
x=rand(10, n)
t=table(ID, date, x)
db1 = database(, VALUE, 2017.08.07..2017.08.11)
db2 = database(, HASH,[INT, 20])
if(existsDatabase(dbName)){
     dropDatabase(dbName)
}
db = database(dbName, COMPO,[ db1,db2])

//create 2 tables
pt1 = db.createPartitionedTable(t, `pt1, `date`x).append!(t)
pt2 = db.createPartitionedTable(t, `pt2, `date`x).append!(t)

backupDB(backupDir, dbName)

restoreTable(backupDir,"dfs://compoDB2",`pt1)
```

--------------------------------

### Get week number for a specific date

Source: https://docs.dolphindb.com/en/Functions/w/weekOfYear.html

Returns the week number for a given date. Weeks start on Sunday.

```DolphinDB
weekOfYear(2012.01.07);
// output: 1
```

```DolphinDB
weekOfYear(2013.01.07);
// output: 2
```

```DolphinDB
weekOfYear(2012.07.02);
// output: 27
```

--------------------------------

### Python Single-Record Subscription Example

Source: https://docs.dolphindb.com/en/pydoc/AdvancedOperations/SubscriptionOptions/SubscriptionOptions.html

Demonstrates setting up a single-record subscription. Use this when immediate processing of individual records is required. Ensure _batchSize_ is unspecified and _msgAsTable_ is False.

```python
import dolphindb as ddb
import numpy as np
import time

s = ddb.Session()
s.connect("192.168.1.113", 8848, "admin", "123456")

s.run("""
share streamTable(10000:0,`time`sym`price`id, [TIMESTAMP,SYMBOL,DOUBLE,INT]) as trades
""")

s.enableStreaming()

def handler(lst):
    print(lst)

s.subscribe("192.168.1.113", 8848, handler, "trades", "SingleMode", offset=-1)

s.run("insert into trades values(take(now(), 6), take(`000905`600001`300201`000908`600002, 6), rand(1000,6)/10.0, 1..6)")

time.sleep(3)

s.unsubscribe("192.168.1.113", 8848, "trades", "SingleMode")
```

--------------------------------

### Create and Display a Table

Source: https://docs.dolphindb.com/en/Programming/SQLStatements/orderOfExecute.html

Creates a sample table 't' with columns 'id', 'time', and 'x', and then displays its content.

```SQL
t = table(1 1 1 1 1 2 2 2 2 2 as id, 09:30:00+1 3 2 5 4 5 2 4 3 1 as time, 1 2 3 4 5 6 5 4 3 2 as x);
t;
```

--------------------------------

### Get Weekday (Starts Sunday)

Source: https://docs.dolphindb.com/en/Functions/w/weekday.html

Returns the weekday of a date, where Sunday is 0 and Saturday is 6. This is the default behavior.

```DolphinDB
weekday 2012.12.05;
// output: 3
```

--------------------------------

### SQL NOT LIKE Operator Example

Source: https://docs.dolphindb.com/en/Programming/SQLStatements/like.html

Demonstrates how to use the NOT LIKE operator to select rows where the 'id' column does not start with 'a'.

```SQL
select * from t where id not like "a%"
```

--------------------------------

### Create Directories with mkdir

Source: https://docs.dolphindb.com/en/Functions/m/mkdir.html

Use the mkdir function to create new directories. This example demonstrates creating multiple directories sequentially. If a directory already exists, an appropriate message is outputted.

```sql
mkdir("/home/test/dir1");
mkdir("/home/test/dir2");
mkdir("/home/test/dir3");
// output: The directory [/home/test/dir3] already exists.
```

--------------------------------

### Java Example: Uploading a Table with tryUpload

Source: https://docs.dolphindb.com/en/javadoc/connection/upload_objects.html

Shows how to upload a table created via `run` using the `tryUpload` method and then retrieve it. This method will throw an exception if the upload lock is already in use.

```java
_@Test_
**public** **void** test_tryUpload() **throws** IOException{
    DBConnection dbConnection = **new** DBConnection();
    dbConnection.connect("192.168.0.68", 8848);

    BasicTable tb = (BasicTable) dbConnection.run("table(1..100 as id,take(`aaa,100) as name)");
    Map<String, Entity> upObj = **new** HashMap<>();
    upObj.put("table_uploaded",tb);
    dbConnection.tryUpload(upObj);
    Entity entity = dbConnection.run("table_uploaded");
    System.out.println(entity.getString());
}
```

--------------------------------

### Get Second of Minute from TIME

Source: https://docs.dolphindb.com/en/Functions/s/secondOfMinute.html

Extracts the second of the minute from a TIME value. Returns 0 for the given example.

```python
secondOfMinute(12:32:00);
// output: 0
```

--------------------------------

### Get Tables by Cluster Name and Database URL

Source: https://docs.dolphindb.com/en/Functions/g/getTablesByCluster.html

This example demonstrates how to use getTablesByCluster to retrieve table names from a specified cluster and database. It first sets up a database and table, then calls the function to get the table list.

```DolphinDB
db = database(directory="dfs://db1", partitionType=RANGE, partitionScheme=0 5 10)
timestamp = [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]
sym = `C`MS`MS`MS`IBM`IBM`C`C`C
price= 49.6 29.46 29.52 30.02 174.97 175.23 50.76 50.32 51.29
qty = 2200 1900 2100 3200 6800 5400 1300 2500 8800
t = table(timestamp, sym, qty, price)
dt=db.createDimensionTable(t,`dt).append!(t)

getTablesByCluster("MoMSender", "dfs://db1")
```

--------------------------------

### Setting up Text Indexing and Querying with matchAll

Source: https://docs.dolphindb.com/en/Functions/m/matchAll.html

This example demonstrates how to create a partitioned table with a text index on the 'remark' column and then use the matchAll function to search for rows containing both 'apple' and 'orange'.

```python
// Generate data for queries
stringColumn = ["There are some apples and oranges.","Mike likes apples.","Alice likes oranges.","Mike gives Alice an apple.","Alice gives Mike an orange.","John likes peaches, so he does not give them to anyone.","Mike, can you give me some apples?","Alice, can you give me some oranges?","Mike traded an orange for an apple with Alice."]
t = table([1,1,1,2,2,2,3,3,3] as id1, [1,2,3,1,2,3,1,2,3] as id2, stringColumn as remark) 
if(existsDatabase("dfs://textDB")) dropDatabase("dfs://textDB")
db = database(directory="dfs://textDB", partitionType=VALUE, partitionScheme=[1,2,3], engine="PKEY")
pt = createPartitionedTable(dbHandle=db, table=t, tableName="pt", partitionColumns="id1",primaryKey=`id1`id2,indexes={"remark":"textindex(parser=english, lowercase=true, stem=true)"})
pt.tableInsert(t)

// Search for rows containing "apple" and "orange"
select * from pt where matchAll(textCol=remark,terms="apple orange")
```

--------------------------------

### Example of Creating, Submitting, Stopping, and Starting a Stream Graph

Source: https://docs.dolphindb.com/en/Functions/s/stopStreamGraph.html

This example demonstrates the lifecycle of a stream graph, including its creation, submission with checkpoint configuration, stopping, and restarting. It also shows how to check the stream graph's metadata.

```python
if !existsCatalog("orca") {
	createCatalog("orca")
}
go

use catalog orca

def callTimes(mutable call, mutable tempTable, msg) {
    call += 1
    price = [call]
    volume = [call]
    t = table(price, volume)
    tempTable.append!(t)
    return t
}
name = "UDF"
g = createStreamGraph(name)
ckptConfig = {
    "enable":true,
    "interval": 10000,
    "timeout": 36000,
    "maxConcurrentCheckpoints": 1
};

g.source("trade", `price`volume, [INT,INT])
 .udfEngine(callTimes,["price", "volume"], [`cnt, `tmpTable], [433, table(128:0, ["price","volume"], [INT, INT])])
 .setEngineName("udf")
 .sink("output")
g.submit(ckptConfig)
go
getStreamGraphMeta()
stopStreamGraph("UDF")
startStreamGraph("UDF") 
```

--------------------------------

### Create a sample table

Source: https://docs.dolphindb.com/en/Programming/SQLStatements/cgroupby.html

Creates a DolphinDB table with stock symbols, timestamps, volumes, and prices for demonstration.

```DolphinDB
t = table(`A`A`A`A`B`B`B`B as sym, 09:30:06 09:30:28 09:31:46 09:31:59 09:30:19 09:30:43 09:31:23 09:31:56 as time, 10 20 10 30 20 40 30 30 as volume, 10.05 10.06 10.07 10.05 20.12 20.13 20.14 20.15 as price);
t;
```

--------------------------------

### Get Message Offset

Source: https://docs.dolphindb.com/en/cppdoc/BasicOperations/subscription.html

Obtain the offset of a message within its table, starting from 0. This function is only effective when no filter is specified.

```cpp
int getOffset();
```