Query data

import asyncio

from viam.rpc.dial import DialOptions, Credentials
from viam.app.viam_client import ViamClient


# Configuration constants – replace with your actual values
API_KEY = ""  # API key, find or create in your organization settings
API_KEY_ID = ""  # API key ID, find or create in your organization settings
ORG_ID = ""  # Organization ID, find or create in your organization settings


async def connect() -> ViamClient:
    """Establish a connection to the Viam client using API credentials."""
    dial_options = DialOptions(
        credentials=Credentials(
            type="api-key",
            payload=API_KEY,
        ),
        auth_entity=API_KEY_ID
    )
    return await ViamClient.create_from_dial_options(dial_options)


async def main() -> int:
    viam_client = await connect()
    data_client = viam_client.data_client

    tabular_data_mql = await data_client.tabular_data_by_mql(
        organization_id=ORG_ID,
        query=[
            {
                "$match": {
                    "component_name": "sensor-1"
                },
            }, {
                "$limit": 5
            }
        ]
    )
    print(f"Tabular Data: {tabular_data_mql}")

    tabular_data_sql = await data_client.tabular_data_by_sql(
        organization_id=ORG_ID,
        sql_query="SELECT * FROM readings WHERE component_name = 'sensor-1' LIMIT 5"
    )
    print(f"Tabular Data: {tabular_data_sql}")

    viam_client.close()
    return 0

if __name__ == "__main__":
    asyncio.run(main())

tabular_data_mql_filter = await data_client.tabular_data_by_mql(
    organization_id=ORG_ID,
    query=[
        {
            "$match": {
                "component_name": "sensor-1"
            },
        }, {
            "$limit": 2
        }, {
            "$project": {
                "time_received": 1,
                "data": 1,
                "tags": 1
            }
        }
    ]
)
print(f"Tabular Data: {tabular_data_mql_filter}")
tabular_data_sql_filter = await data_client.tabular_data_by_sql(
organization_id=ORG_ID,
sql_query="SELECT time_received, data, tags FROM readings "
"WHERE component_name = 'sensor-1' LIMIT 2"
)
print(f"Tabular Data: {tabular_data_sql_filter}")

tabular_data_mql_count = await data_client.tabular_data_by_mql(
    organization_id=ORG_ID,
    query=[
        {
            "$match": {
                "component_name": "sensor-1"
            },
        }, {
            "$count": "count"
        }
    ]
)
print(f"Tabular Data: {tabular_data_mql_count}")
tabular_data_sql_count = await data_client.tabular_data_by_sql(
organization_id=ORG_ID,
sql_query="SELECT count(*) FROM readings "
"WHERE component_name = 'sensor-1'"
)
print(f"Tabular Data: {tabular_data_sql_count}")

package main

import (
	"context"
	"fmt"

	"go.viam.com/rdk/app"
	"go.viam.com/rdk/logging"
)

func main() {
	apiKey := ""
	apiKeyID := ""
	orgID := ""

	logger := logging.NewDebugLogger("client")
	ctx := context.Background()
	viamClient, err := app.CreateViamClientWithAPIKey(
		ctx, app.Options{}, apiKey, apiKeyID, logger)
	if err != nil {
		logger.Fatal(err)
	}
	defer viamClient.Close()

	dataClient := viamClient.DataClient()

	// Create MQL stages as map slices
	mqlStages := []map[string]interface{}{
		{"$match": map[string]interface{}{"component_name": "sensor-1"}},
		{"$limit": 5},
	}

	tabularDataMQL, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, &app.TabularDataByMQLOptions{})
	if err != nil {
		logger.Fatal(err)
	}

	fmt.Printf("Tabular Data: %v\n", tabularDataMQL)

	tabularDataSQL, err := dataClient.TabularDataBySQL(ctx, orgID, "SELECT * FROM readings WHERE component_name = 'sensor-1' LIMIT 5")
	if err != nil {
		logger.Fatal(err)
	}

	fmt.Printf("Tabular Data: %v\n", tabularDataSQL)
}

// Create MQL stages as map slices
mqlStages := []map[string]interface{}{
	{"$match": map[string]interface{}{"component_name": "sensor-1"}},
	{"$limit": 2},
	{"$project": map[string]interface{}{
		"time_received": 1,
		"data": 1,
		"tags": 1,
	}},
}
tabularDataMQL, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, &app.TabularDataByMQLOptions{})
if err != nil {
logger.Fatal(err)
}
fmt.Printf("Tabular Data: %v\n", tabularDataMQL)
tabularDataSQL, err := dataClient.TabularDataBySQL(ctx, orgID,
"SELECT time_received, data, tags FROM readings " +
"WHERE component_name = 'sensor-1' LIMIT 2")
if err != nil {
logger.Fatal(err)
}
fmt.Printf("Tabular Data: %v\n", tabularDataSQL)

mqlStages = []map[string]interface{}{
	{"$match": map[string]interface{}{"component_name": "sensor-1"}},
	{"$count": "count"},
}
tabularDataMQLCount, err := dataClient.TabularDataByMQL(ctx, orgID, mqlStages, &app.TabularDataByMQLOptions{})
if err != nil {
logger.Fatal(err)
}
fmt.Printf("Tabular Data: %v\n", tabularDataMQLCount)
tabularDataSQLCount, err := dataClient.TabularDataBySQL(ctx, orgID,
"SELECT count(*) FROM readings WHERE component_name = 'sensor-1'")
if err != nil {
logger.Fatal(err)
}
fmt.Printf("Tabular Data: %v\n", tabularDataSQLCount)

import { createViamClient } from "@viamrobotics/sdk";

// Configuration constants – replace with your actual values
let API_KEY = "";  // API key, find or create in your organization settings
let API_KEY_ID = "";  // API key ID, find or create in your organization settings
let ORG_ID = "";  // Organization ID, find or create in your organization settings

async function main(): Promise<void> {
    // Create Viam client
    const client = await createViamClient({
        credentials: {
            type: "api-key",
            authEntity: API_KEY_ID,
            payload: API_KEY,
        },
    });

    const tabularDataMQL = await client.dataClient.tabularDataByMQL(
        ORG_ID,
        [
            { "$match": { "component_name": "sensor-1" } },
            { "$limit": 5 }
        ],
        false
    );
    console.log(tabularDataMQL);

    const tabularDataSQL = await client.dataClient.tabularDataBySQL(
        ORG_ID,
        "SELECT * FROM readings WHERE component_name = 'sensor-1' LIMIT 5"
    );
    console.log(tabularDataSQL);
}

// Run the script
main().catch((error) => {
    console.error("Script failed:", error);
    process.exit(1);
});

const tabularDataMQLFilter = await client.dataClient.tabularDataByMQL(
    ORG_ID,
    [
        { "$match": { "component_name": "sensor-1" } },
        { "$limit": 2 },
        { "$project": {
            "time_received": 1,
            "data": 1,
            "tags": 1
        }}
    ]
);
console.log(tabularDataMQLFilter);
const tabularDataSQLFilter = await client.dataClient.tabularDataBySQL(
ORG_ID,
"SELECT time_received, data, tags FROM readings " +
"WHERE component_name = 'sensor-1' LIMIT 2"
);
console.log(tabularDataSQLFilter);

const tabularDataMQLCount = await client.dataClient.tabularDataByMQL(
    ORG_ID,
    [
        { "$match": { "component_name": "sensor-1" } },
        { "$count": "count" }
    ]
);
console.log(tabularDataMQLCount);
const tabularDataSQLCount = await client.dataClient.tabularDataBySQL(
ORG_ID,
"SELECT count(*) FROM readings WHERE component_name = 'sensor-1'"
);
console.log(tabularDataSQLCount);