Smart SQL
The Smart SQL service provides intelligent SQL query execution capabilities with natural language to SQL conversion and automatic metadata management. It enables users to interact with databases using both direct SQL queries and natural language descriptions.
POST /v1/execute_query
Executes a SQL query or converts natural language to SQL and executes it. Supports both direct SQL execution and AI-powered natural language to SQL conversion. Automatically handles metadata updates and PII detection for data governance.
Features:
- Direct SQL query execution
 - Natural language to SQL conversion using AI
 - Automatic metadata tracking for schema changes
 - PII detection for security
 - Multiple output formats (JSON, CSV)
 
Schema Reference
Request Body
smartSqlLocation (object) Required 
Details
Description
Smart SQL locator for targeting the correct smart SQL instance
Example
{  "smartSql": {    "name": "analytics-sql",    "version": "v1.2.0",    "application_name": "data-analytics-app"  }}sqlQuery (string(nullable))
Details
Description
Direct SQL query to execute (mutually exclusive with text_query)
Example
SELECT * FROM users WHERE active = truetextQuery (string(nullable))
Details
Description
Natural language query to convert to SQL (mutually exclusive with sql_query)
Example
Show me all active users from the last monthformat (object(nullable))
Details
Description
Desired output format for query results
Example
jsonimport Raindrop from '@liquidmetal-ai/lm-raindrop';
const client = new Raindrop();
const response = await client.executeQuery.execute({  smartSqlLocation: {    smartSql: { name: 'analytics-sql', version: 'v1.2.0', application_name: 'data-analytics-app' },  },});
console.log(response);from raindrop import Raindrop
client = Raindrop()response = client.execute_query.execute(    smart_sql_location={        "smart_sql": {            "name": "analytics-sql"        }    },)print(response)package main
import (  "context"  "fmt"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option")
func main() {  client := raindrop.NewClient(    option.WithAPIKey("My API Key"),  )  response, err := client.ExecuteQuery.Execute(context.TODO(), raindrop.ExecuteQueryExecuteParams{    SmartSqlLocation: raindrop.ExecuteQueryExecuteParamsSmartSqlLocation{SmartSql: raindrop.ExecuteQueryExecuteParamsSmartSqlLocationSmartSql{Name: "analytics-sql", ApplicationName: raindrop.String("data-analytics-app"), Version: raindrop.String("v1.2.0")}},  })  if err != nil {    panic(err.Error())  }  fmt.Printf("%+v\n", response)}package com.raindrop.api.example;
import com.raindrop.api.client.RaindropClient;import com.raindrop.api.client.okhttp.RaindropOkHttpClient;import com.raindrop.api.core.JsonValue;import com.raindrop.api.models.executequery.ExecuteQueryExecuteParams;import com.raindrop.api.models.executequery.ExecuteQueryExecuteResponse;import java.util.Map;
public final class Main {    private Main() {}
    public static void main(String[] args) {        RaindropClient client = RaindropOkHttpClient.fromEnv();
        ExecuteQueryExecuteParams params = ExecuteQueryExecuteParams.builder()            .smartSqlLocation(JsonValue.from(Map.of(              "smartSql", Map.of(                "name",                "analytics-sql",                "version",                "v1.2.0",                "application_name",                "data-analytics-app"              )            )))            .build();        ExecuteQueryExecuteResponse response = client.executeQuery().execute(params);    }}curl -X POST "https://api.raindrop.run/v1/execute_query" \  -H "Authorization: Bearer lm_apikey_..." \  -H "Content-Type: application/json" \  -d '{  "smart_sql_location": {    "smartSql": {      "name": "analytics-sql",      "version": "v1.2.0",      "application_name": "data-analytics-app"    }  }}'Response Examples
{}POST /v1/get_metadata
Retrieves database schema metadata for a smart SQL instance. Returns table structures, column information, and sample data that can be used for AI context or application development.
Metadata includes:
- Table names and structures
 - Column names and data types
 - Sample data for AI context
 - Schema versioning information
 
Schema Reference
Request Body
smartSqlLocation (object) Required 
Details
Description
Smart SQL locator for targeting the correct smart SQL instance
Example
{  "smartSql": {    "name": "analytics-sql",    "version": "v1.2.0",    "application_name": "data-analytics-app"  }}tableName (string(nullable))
Details
Description
Optional table name to filter metadata
Example
userstables (array)
Details
Description
List of table metadata entries
lastUpdated (object(nullable))
Details
Description
Timestamp when metadata was last updated
import Raindrop from '@liquidmetal-ai/lm-raindrop';
const client = new Raindrop();
const getMetadata = await client.getMetadata.retrieve({  smartSqlLocation: {    smartSql: { name: 'analytics-sql', version: 'v1.2.0', application_name: 'data-analytics-app' },  },});
console.log(getMetadata.lastUpdated);from raindrop import Raindrop
client = Raindrop()get_metadata = client.get_metadata.retrieve(    smart_sql_location={        "smart_sql": {            "name": "analytics-sql"        }    },)print(get_metadata.last_updated)package main
import (  "context"  "fmt"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option")
func main() {  client := raindrop.NewClient(    option.WithAPIKey("My API Key"),  )  getMetadata, err := client.GetMetadata.Get(context.TODO(), raindrop.GetMetadataGetParams{    SmartSqlLocation: raindrop.GetMetadataGetParamsSmartSqlLocation{SmartSql: raindrop.GetMetadataGetParamsSmartSqlLocationSmartSql{Name: "analytics-sql", ApplicationName: raindrop.String("data-analytics-app"), Version: raindrop.String("v1.2.0")}},  })  if err != nil {    panic(err.Error())  }  fmt.Printf("%+v\n", getMetadata.LastUpdated)}package com.raindrop.api.example;
import com.raindrop.api.client.RaindropClient;import com.raindrop.api.client.okhttp.RaindropOkHttpClient;import com.raindrop.api.core.JsonValue;import com.raindrop.api.models.getmetadata.GetMetadataRetrieveParams;import com.raindrop.api.models.getmetadata.GetMetadataRetrieveResponse;import java.util.Map;
public final class Main {    private Main() {}
    public static void main(String[] args) {        RaindropClient client = RaindropOkHttpClient.fromEnv();
        GetMetadataRetrieveParams params = GetMetadataRetrieveParams.builder()            .smartSqlLocation(JsonValue.from(Map.of(              "smartSql", Map.of(                "name",                "analytics-sql",                "version",                "v1.2.0",                "application_name",                "data-analytics-app"              )            )))            .build();        GetMetadataRetrieveResponse getMetadata = client.getMetadata().retrieve(params);    }}curl -X POST "https://api.raindrop.run/v1/get_metadata" \  -H "Authorization: Bearer lm_apikey_..." \  -H "Content-Type: application/json" \  -d '{  "smart_sql_location": {    "smartSql": {      "name": "analytics-sql",      "version": "v1.2.0",      "application_name": "data-analytics-app"    }  }}'Response Examples
{  "tables": [    {      "tableName": "users",      "columns": [        {          "columnName": "user_id",          "dataType": "INTEGER",          "sampleData": "123",          "nullable": true,          "isPrimaryKey": true        }      ],      "createdAt": "2025-05-05T18:36:43.029Z",      "updatedAt": "2025-05-05T18:36:43.029Z"    }  ],  "lastUpdated": "2025-05-05T18:36:43.029Z"}POST /v1/get_pii_data
Retrieves PII detection results for specific database records. Returns detailed information about detected personally identifiable information for compliance and auditing purposes.
PII information includes:
- Entity types detected
 - Confidence scores
 - Character positions
 - Detection timestamps
 
Schema Reference
Request Body
smartSqlLocation (object) Required 
Details
Description
Smart SQL locator for targeting the correct smart SQL instance
Example
{  "smartSql": {    "name": "analytics-sql",    "version": "v1.2.0",    "application_name": "data-analytics-app"  }}tableName (string) Required 
Details
Description
Table name to retrieve PII data from
Example
usersrecordId (string(nullable))
Details
Description
Optional record identifier to filter PII data
Example
user_123piiDetections (array)
Details
Description
List of PII detection results
import Raindrop from '@liquidmetal-ai/lm-raindrop';
const client = new Raindrop();
const getPiiData = await client.getPiiData.retrieve({  smartSqlLocation: {    smartSql: { name: 'analytics-sql', version: 'v1.2.0', application_name: 'data-analytics-app' },  },  tableName: 'users',});
console.log(getPiiData.piiDetections);from raindrop import Raindrop
client = Raindrop()get_pii_data = client.get_pii_data.retrieve(    smart_sql_location={        "smart_sql": {            "name": "analytics-sql"        }    },    table_name="users",)print(get_pii_data.pii_detections)package main
import (  "context"  "fmt"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option")
func main() {  client := raindrop.NewClient(    option.WithAPIKey("My API Key"),  )  getPiiData, err := client.GetPiiData.Get(context.TODO(), raindrop.GetPiiDataGetParams{    SmartSqlLocation: raindrop.GetPiiDataGetParamsSmartSqlLocation{SmartSql: raindrop.GetPiiDataGetParamsSmartSqlLocationSmartSql{Name: "analytics-sql", ApplicationName: raindrop.String("data-analytics-app"), Version: raindrop.String("v1.2.0")}},    TableName: "users",  })  if err != nil {    panic(err.Error())  }  fmt.Printf("%+v\n", getPiiData.PiiDetections)}package com.raindrop.api.example;
import com.raindrop.api.client.RaindropClient;import com.raindrop.api.client.okhttp.RaindropOkHttpClient;import com.raindrop.api.core.JsonValue;import com.raindrop.api.models.getpiidata.GetPiiDataRetrieveParams;import com.raindrop.api.models.getpiidata.GetPiiDataRetrieveResponse;import java.util.Map;
public final class Main {    private Main() {}
    public static void main(String[] args) {        RaindropClient client = RaindropOkHttpClient.fromEnv();
        GetPiiDataRetrieveParams params = GetPiiDataRetrieveParams.builder()            .smartSqlLocation(JsonValue.from(Map.of(              "smartSql", Map.of(                "name",                "analytics-sql",                "version",                "v1.2.0",                "application_name",                "data-analytics-app"              )            )))            .tableName("users")            .build();        GetPiiDataRetrieveResponse getPiiData = client.getPiiData().retrieve(params);    }}curl -X POST "https://api.raindrop.run/v1/get_pii_data" \  -H "Authorization: Bearer lm_apikey_..." \  -H "Content-Type: application/json" \  -d '{  "smart_sql_location": {    "smartSql": {      "name": "analytics-sql",      "version": "v1.2.0",      "application_name": "data-analytics-app"    }  },  "table_name": "users"}'Response Examples
{  "piiDetections": [    {      "detectionId": "01jxanr45haeswhay4n0q8340y",      "tableName": "users",      "recordId": "user_123",      "entities": [        {          "entityType": "EMAIL",          "confidenceScore": 0.95,          "detectedText": "john.doe@example.com",          "startPosition": 25,          "endPosition": 46,          "tokenIndex": 5        }      ],      "detectedAt": "2025-05-05T18:36:43.029Z"    }  ]}POST /v1/update_metadata
Updates database schema metadata manually. Allows for explicit metadata management when automatic detection is insufficient or needs correction.
Use cases:
- Manual schema corrections
 - Bulk metadata updates
 - Custom metadata annotations
 
Schema Reference
Request Body
smartSqlLocation (object) Required 
Details
Description
Smart SQL locator for targeting the correct smart SQL instance
Example
{  "smartSql": {    "name": "analytics-sql",    "version": "v1.2.0",    "application_name": "data-analytics-app"  }}tables (array) Required 
Details
Description
Table metadata to update or create
mode (object(nullable))
Details
Description
Update mode: replace (overwrite), merge (preserve existing), or append (only new entries)
Example
UPDATE_MODE_MERGEsuccess (boolean)
Details
Description
Indicates whether the update was successful
tablesUpdated (integer)
Details
Description
Number of tables updated
import Raindrop from '@liquidmetal-ai/lm-raindrop';
const client = new Raindrop();
const updateMetadata = await client.updateMetadata.update({  smartSqlLocation: {    smartSql: { name: 'analytics-sql', version: 'v1.2.0', application_name: 'data-analytics-app' },  },  tables: [{}],});
console.log(updateMetadata.success);from raindrop import Raindrop
client = Raindrop()update_metadata = client.update_metadata.update(    smart_sql_location={        "smart_sql": {            "name": "analytics-sql"        }    },    tables=[{}],)print(update_metadata.success)package main
import (  "context"  "fmt"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option")
func main() {  client := raindrop.NewClient(    option.WithAPIKey("My API Key"),  )  updateMetadata, err := client.UpdateMetadata.Update(context.TODO(), raindrop.UpdateMetadataUpdateParams{    SmartSqlLocation: raindrop.UpdateMetadataUpdateParamsSmartSqlLocation{SmartSql: raindrop.UpdateMetadataUpdateParamsSmartSqlLocationSmartSql{Name: "analytics-sql", ApplicationName: raindrop.String("data-analytics-app"), Version: raindrop.String("v1.2.0")}},    Tables: []raindrop.UpdateMetadataUpdateParamsTable{raindrop.UpdateMetadataUpdateParamsTable{
    }},  })  if err != nil {    panic(err.Error())  }  fmt.Printf("%+v\n", updateMetadata.Success)}package com.raindrop.api.example;
import com.raindrop.api.client.RaindropClient;import com.raindrop.api.client.okhttp.RaindropOkHttpClient;import com.raindrop.api.core.JsonValue;import com.raindrop.api.models.updatemetadata.UpdateMetadataUpdateParams;import com.raindrop.api.models.updatemetadata.UpdateMetadataUpdateResponse;import java.util.Map;
public final class Main {    private Main() {}
    public static void main(String[] args) {        RaindropClient client = RaindropOkHttpClient.fromEnv();
        UpdateMetadataUpdateParams params = UpdateMetadataUpdateParams.builder()            .smartSqlLocation(JsonValue.from(Map.of(              "smartSql", Map.of(                "name",                "analytics-sql",                "version",                "v1.2.0",                "application_name",                "data-analytics-app"              )            )))            .addTable(UpdateMetadataUpdateParams.Table.builder().build())            .build();        UpdateMetadataUpdateResponse updateMetadata = client.updateMetadata().update(params);    }}curl -X POST "https://api.raindrop.run/v1/update_metadata" \  -H "Authorization: Bearer lm_apikey_..." \  -H "Content-Type: application/json" \  -d '{  "smart_sql_location": {    "smartSql": {      "name": "analytics-sql",      "version": "v1.2.0",      "application_name": "data-analytics-app"    }  },  "tables": [    {}  ]}'Response Examples
{  "success": true,  "tablesUpdated": 123}