{
  "repo": "tidbcloud/dataservices",
  "binary": "dataapi_executor",
  "binary_path": "cmd/dataapi_executor/main.go",
  "dependencies": {
    "DataAPIExecutorLifecycle.LoadConfigAndLogger": {
      "infrastructure": {
        "filesystem": {
          "conditions": [
            "Always at startup"
          ],
          "operations": [
            {
              "operation": "READ FILE",
              "trigger": "Load the executor config before logger and backend initialization",
              "conditions": [
                "Always"
              ],
              "implementation": "config.InitConfig(configPath)"
            }
          ]
        }
      },
      "services": []
    },
    "DataAPIExecutorLifecycle.ValidateRegionalConfig": {
      "infrastructure": {},
      "services": []
    },
    "DataAPIExecutorLifecycle.InitCachesAndBackends": {
      "infrastructure": {
        "redis": {
          "conditions": [
            "Only when AliCloud regional mode is disabled"
          ],
          "operations": [
            {
              "operation": "CONNECT",
              "trigger": "Initialize the Redis-backed session driver used by standard session ids",
              "conditions": [
                "!config.IsAliCloudRegionalMode()"
              ],
              "implementation": "redisutil.NewRedisClient(ctx, config); sessioncache.RegisterRedisDriver(ctx)"
            }
          ]
        },
        "dynamodb": {
          "conditions": [
            "Only when AliCloud regional mode is disabled"
          ],
          "operations": [
            {
              "operation": "CONNECT",
              "trigger": "Initialize DynamoDB-backed metadata used by DBHub regional helpers",
              "conditions": [
                "!config.IsAliCloudRegionalMode()"
              ],
              "implementation": "ddb.Init(ctx, config)"
            }
          ]
        }
      },
      "services": [
        {
          "name": "regional-dbhub-sdk",
          "target_repo": "tidbcloud/dataservices",
          "target_interface": "dbhubsdk.InitRegionalSdk / InitRegionalSdkWithUserMetaProvider",
          "operation_type": "sdk_init",
          "conditions": [
            "Always at startup"
          ],
          "operations": [
            {
              "operation": "INITIALIZE SDK",
              "trigger": "Prepare the TiDB connection builder used by executor requests",
              "conditions": [
                "Always"
              ],
              "implementation": "AliCloud mode -> dbhubsdk.InitRegionalSdkWithUserMetaProvider(...); otherwise -> dbhubsdk.InitRegionalSdk(...)"
            }
          ]
        }
      ]
    },
    "DataAPIExecutorLifecycle.InitHubPoolAndMeasureReport": {
      "infrastructure": {},
      "services": [
        {
          "name": "dbhub-pool",
          "target_repo": "tidbcloud/dataservices",
          "target_interface": "dbhubsdk.InitHubPool",
          "operation_type": "pool_init",
          "conditions": [
            "Always at startup"
          ],
          "operations": [
            {
              "operation": "INITIALIZE POOL",
              "trigger": "Prepare the DB hub pool used by serverless query execution",
              "conditions": [
                "Always"
              ],
              "implementation": "dbhubsdk.InitHubPool(ctx)"
            }
          ]
        },
        {
          "name": "measure-report",
          "target_repo": "tidbcloud/dataservices",
          "target_interface": "measure_report.InitMeasure",
          "operation_type": "background_init",
          "conditions": [
            "Always at startup"
          ],
          "operations": [
            {
              "operation": "INITIALIZE MEASURE REPORTER",
              "trigger": "Enable request/network billing for metered app types",
              "conditions": [
                "Always"
              ],
              "implementation": "measure_report.InitMeasure(ctx)"
            }
          ]
        }
      ]
    },
    "DataAPIExecutorLifecycle.StartTracing": {
      "infrastructure": {},
      "services": []
    },
    "DataAPIExecutorLifecycle.StartMetricsServer": {
      "infrastructure": {},
      "services": []
    },
    "DataAPIExecutorLifecycle.StartGrpcServer": {
      "infrastructure": {
        "tcp": {
          "conditions": [
            "Always at startup"
          ],
          "operations": [
            {
              "operation": "LISTEN",
              "trigger": "Expose the DataAPIExecutorService gRPC server",
              "conditions": [
                "Always"
              ],
              "implementation": "startupGRPC -> net.Listen(\"tcp\", \":\"+GrpcPort); grpcServer.Serve(listen)"
            }
          ]
        }
      },
      "services": []
    },
    "HTTP GET /metrics": {
      "infrastructure": {},
      "services": []
    },
    "DataAPIExecutorService.CreateSession": {
      "infrastructure": {
        "sql_connection": {
          "conditions": [
            "Always"
          ],
          "operations": [
            {
              "operation": "BUILD CONNECTION",
              "trigger": "Open the initial DB connection used to seed the session",
              "conditions": [
                "Always"
              ],
              "implementation": "service.CreateSession -> createSessionWithCmds -> buildConnection -> dbhubsdk.Serverless.BuildConnection(ctx, connectInput)"
            }
          ]
        },
        "redis": {
          "conditions": [
            "Only when the session backend is Redis-backed"
          ],
          "operations": [
            {
              "operation": "SAVE SESSION",
              "trigger": "Persist the newly created session item for later reuse by gateway/session clients",
              "conditions": [
                "sessionItem.Save(ctx) is reached"
              ],
              "implementation": "createSessionWithCmds -> sessionItem.Save(ctx)"
            }
          ]
        }
      },
      "services": []
    },
    "DataAPIExecutorService.CloseSession": {
      "infrastructure": {
        "redis": {
          "conditions": [
            "Only for standard sessions that still exist in the session store"
          ],
          "operations": [
            {
              "operation": "LOAD + DELETE SESSION",
              "trigger": "Fetch, validate, and delete the persisted session metadata",
              "conditions": [
                "in.SessionId != \"\""
              ],
              "implementation": "service.CloseSession -> getLocalSession -> sessioncache.GetSession(sessionId); sessionItem.Delete(ctx); sessioncache.CloseSession(in.SessionId)"
            }
          ]
        }
      },
      "services": []
    },
    "DataAPIExecutorService.ExecSql": {
      "infrastructure": {
        "sql_connection": {
          "conditions": [
            "Always"
          ],
          "operations": [
            {
              "operation": "LOAD OR BUILD SESSION CONNECTION",
              "trigger": "Recover a local session, rebuild from SessionItem, or create a one-shot connection depending on SessionId shape",
              "conditions": [
                "Always"
              ],
              "implementation": "service.ExecSql -> GetSession -> getLocalSession / createSessionWithCmds / dbhubsdk.GetConnPool"
            },
            {
              "operation": "EXECUTE SQL",
              "trigger": "Split SQL into statements, optionally inject USE db, and run each statement through DBHub",
              "conditions": [
                "GetSession succeeded"
              ],
              "implementation": "service.ExecSql -> sessionItem.Handle(... execSQLWithSession ...) -> execOneSql -> dbhubsdk.Serverless.QueryByPrepare(ctx, db, stmtSQL, stmtArgs, in.LimitRows)"
            },
            {
              "operation": "SHOW WARNINGS",
              "trigger": "Fetch warning rows after successful console-origin SQL execution",
              "conditions": [
                "lastStmtResult.ErrCode == 0",
                "in.Source is Chat2QueryConsole or DataAPIConsole"
              ],
              "implementation": "getDBWarning -> execOneSql(ctx, sessionItem, db, \"SHOW WARNINGS;\", nil, 10)"
            }
          ]
        },
        "redis": {
          "conditions": [
            "Only for standard sessions or rebuilt sessions"
          ],
          "operations": [
            {
              "operation": "REFRESH / SAVE SESSION STATE",
              "trigger": "Refresh session TTL and persist changed session commands such as SET/BEGIN/COMMIT",
              "conditions": [
                "sessionItem is standard and SQL changes session state"
              ],
              "implementation": "getLocalSession -> sessioncache.RefreshSession(sessionId); execSQLWithSession -> sessionItem.AppendCmd(...); defer sessionItem.RequestPost(utils.TraceContext(ctx))"
            }
          ]
        }
      },
      "services": [
        {
          "name": "measure-reporter",
          "target_repo": "tidbcloud/dataservices",
          "target_interface": "measure_report.Report.PutMeasure",
          "operation_type": "async_measure",
          "conditions": [
            "Only when in.AppType == constants.NeedMeasure"
          ],
          "operations": [
            {
              "operation": "REPORT REQUEST / NETWORK COST",
              "trigger": "Emit billable request and network measurements for metered endpoints",
              "conditions": [
                "in.AppType == constants.NeedMeasure"
              ],
              "implementation": "measureRequest / measureNetwork -> createMeasure -> measure_report.Report.PutMeasure(...)"
            }
          ]
        }
      ]
    },
    "DataAPIExecutorService.GetDatabaseMeta": {
      "infrastructure": {
        "sql_connection": {
          "conditions": [
            "Always"
          ],
          "operations": [
            {
              "operation": "BUILD ONE-SHOT CONNECTION",
              "trigger": "Open a short-lived connection to INFORMATION_SCHEMA and query column metadata",
              "conditions": [
                "Always"
              ],
              "implementation": "service.GetDatabaseMeta -> ExecSimpleSql -> dbhubsdk.Serverless.BuildConnection(ctx, ConnectionInput{...})"
            },
            {
              "operation": "EXECUTE SQL",
              "trigger": "Run the INFORMATION_SCHEMA.COLUMNS query and close the connection afterwards",
              "conditions": [
                "BuildConnection succeeded"
              ],
              "implementation": "ExecSimpleSql -> dbhubsdk.HandleWithDBConn(... QueryByPrepare(ctx, conn, in.Sql, nil, in.LimitRows) ...)"
            }
          ]
        }
      },
      "services": []
    },
    "DataAPIExecutorService.ParseOneStmt": {
      "infrastructure": {},
      "services": []
    }
  }
}